From 656f1fb733601b6dc7eb472944e0feba34200eb1 Mon Sep 17 00:00:00 2001 From: Jared Wahlstrand Date: Sat, 11 May 2024 16:57:35 -0400 Subject: [PATCH 1/4] GtkTextView: use pointer or ref instead of _GtkTextIter struct This is more consistent with everything else in the package --- src/text.jl | 169 ++++++++++++++++++++------------------------------- test/text.jl | 45 +++++++------- 2 files changed, 87 insertions(+), 127 deletions(-) diff --git a/src/text.jl b/src/text.jl index 6975c1ea..a6350146 100644 --- a/src/text.jl +++ b/src/text.jl @@ -4,46 +4,38 @@ GtkTextMark(left_gravity::Bool = false) = G_.TextMark_new(nothing, left_gravity) GtkTextTag() = G_.TextTag_new(nothing) -const TI = Union{Ref{_GtkTextIter}, _GtkTextIter} +const TI = Union{Ref{_GtkTextIter}, GtkTextIter} zero(::Type{_GtkTextIter}) = _GtkTextIter() copy(ti::_GtkTextIter) = Ref(ti) copy(ti::Ref{_GtkTextIter}) = Ref(ti[]) """ - _GtkTextIter(text::GtkTextBuffer, char_offset::Integer) + GtkTextIter(text::GtkTextBuffer, char_offset::Integer) -Creates a `_GtkTextIter` with offset `char_offset` (one-based index). +Creates a `GtkTextIter` with offset `char_offset` (one-based index). """ -function _GtkTextIter(text::GtkTextBuffer, char_offset::Integer) - iter = Ref{_GtkTextIter}() - ccall((:gtk_text_buffer_get_iter_at_offset, libgtk4), Nothing, - (Ptr{GObject}, Ptr{_GtkTextIter}, Cint), text, iter, char_offset - 1) - iter[] +function GtkTextIter(text::GtkTextBuffer, char_offset::Integer) + i = G_.get_iter_at_offset(text, char_offset - 1) + Ref(i) end -function _GtkTextIter(text::GtkTextBuffer, line::Integer, char_offset::Integer) - iter = Ref{_GtkTextIter}() - ccall((:gtk_text_buffer_get_iter_at_line_offset, libgtk4), Nothing, - (Ptr{GObject}, Ptr{_GtkTextIter}, Cint, Cint), text, iter, line - 1, char_offset - 1) - iter[] +function GtkTextIter(text::GtkTextBuffer, line::Integer, char_offset::Integer) + i = G_.get_iter_at_line_offset(text, line - 1, char_offset - 1) + Ref(i) end -function _GtkTextIter(text::GtkTextBuffer) - iter = Ref{_GtkTextIter}() - ccall((:gtk_text_buffer_get_start_iter, libgtk4), Nothing, - (Ptr{GObject}, Ptr{_GtkTextIter}), text, iter) - iter[] +function GtkTextIter(text::GtkTextBuffer) + i = G_.get_start_iter(text) + Ref(i) end -function _GtkTextIter(text::GtkTextBuffer, mark::GtkTextMark) - iter = Ref{_GtkTextIter}() - ccall((:gtk_text_buffer_get_iter_at_mark, libgtk4), Nothing, - (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{GObject}), text, iter, mark) - iter[] +function GtkTextIter(text::GtkTextBuffer, mark::GtkTextMark) + i = G_.get_iter_at_mark(text, mark) + Ref(i) end show(io::IO, iter::_GtkTextIter) = println("_GtkTextIter($(iter.offset) ))") """ - buffer(iter::Union{Ref{_GtkTextIter}, _GtkTextIter}) + buffer(iter::Union{Ref{_GtkTextIter}, GtkTextIter}) Returns the buffer associated with `iter`. """ @@ -52,7 +44,7 @@ buffer(iter::TI) = convert(GtkTextBuffer, ) """ - char_offset(iter::Union{Ref{_GtkTextIter}, _GtkTextIter}) + char_offset(iter::Union{Ref{_GtkTextIter}, GtkTextIter}) Returns the offset of `iter` (one-based index). """ @@ -60,7 +52,7 @@ char_offset(iter::TI) = iter.offset+1 Base.cconvert(::Type{Ref{_GtkTextIter}}, it::_GtkTextIter) = Ref(it) Base.cconvert(::Type{Ref{_GtkTextIter}}, it::Ref{_GtkTextIter}) = Ref(it[]) -Base.convert(::Type{_GtkTextIter}, it::Ref{_GtkTextIter}) = _GtkTextIter(buffer(it), char_offset(it))#there's a -1 in the constructor +Base.convert(::Type{_GtkTextIter}, it::Ref{_GtkTextIter}) = GtkTextIter(buffer(it), char_offset(it))#there's a -1 in the constructor struct GtkTextRange <: AbstractRange{Char} a::Base.RefValue{_GtkTextIter} @@ -68,17 +60,10 @@ struct GtkTextRange <: AbstractRange{Char} GtkTextRange(a, b) = new(copy(a), copy(b)) end -#type GtkClipboard -#TODO -#end - ##### _GtkTextIter ##### #TODO: search function getproperty(text::TI, key::Symbol) Base.in(key, fieldnames(typeof(text))) && return getfield(text, key) - if isa(text,_GtkTextIter) - text = Ref(text) - end if key === :offset ccall((:gtk_text_iter_get_offset, libgtk4), Cint, (Ptr{_GtkTextIter},), text) elseif key === :line @@ -144,7 +129,7 @@ function getproperty(text::TI, key::Symbol) end end -function setproperty!(text::Ref{_GtkTextIter}, key::Symbol, value) +function setproperty!(text::TI, key::Symbol, value) Base.in(key, fieldnames(typeof(text))) && return setfield!(text, key, value) if key === :offset ccall((:gtk_text_iter_set_offset, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), text, value) @@ -188,7 +173,7 @@ Base.:-(iter::TI, count::Integer) = (iter = copy(iter); skip(iter, -count); iter Moves `iter` `count` characters. Returns a Bool indicating if the move was successful. """ -Base.skip(iter::Ref{_GtkTextIter}, count::Integer) = +Base.skip(iter::TI, count::Integer) = Bool(ccall((:gtk_text_iter_forward_chars, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), iter, count)) @@ -206,7 +191,7 @@ Operations are : * `:backward_sentence_start` (`gtk_text_iter_backward_sentence_start`) * `:forward_sentence_end` (`gtk_text_iter_forward_sentence_end`) """ -function Base.skip(iter::Ref{_GtkTextIter}, what::Symbol) +function Base.skip(iter::TI, what::Symbol) if what === :backward_line Bool(ccall((:gtk_text_iter_backward_line, libgtk4), Cint, (Ptr{_GtkTextIter},), iter)) @@ -252,7 +237,7 @@ Operations are : * `:visible_lines` (`gtk_text_iter_forward_visible_lines`) * `:line_ends` (`gtk_text_iter_forward_visible_lines`) """ -function Base.skip(iter::Ref{_GtkTextIter}, count::Integer, what::Symbol) +function Base.skip(iter::TI, count::Integer, what::Symbol) if what === :char || what === :chars Bool(ccall((:gtk_text_iter_forward_chars, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), iter, count)) @@ -308,7 +293,7 @@ end Implements `gtk_text_iter_forward_search`. """ -function forward_search(iter::Ref{_GtkTextIter}, +function forward_search(iter::TI, str::AbstractString, start::Ref{_GtkTextIter}, stop::Ref{_GtkTextIter}, limit::Ref{_GtkTextIter}, flag) @@ -326,7 +311,7 @@ end Implements `gtk_text_iter_backward_search`. """ -function backward_search(iter::Ref{_GtkTextIter}, +function backward_search(iter::TI, str::AbstractString, start::Ref{_GtkTextIter}, stop::Ref{_GtkTextIter}, limit::Ref{_GtkTextIter}, flag) @@ -350,15 +335,15 @@ was successful and `start` and `stop` are _GtkTextIters containing the location function search(buffer::GtkTextBuffer, str::AbstractString, direction = :forward, flag = Gtk4.TextSearchFlags_TEXT_ONLY) - start = Ref(_GtkTextIter(buffer)) - stop = Ref(_GtkTextIter(buffer)) - iter = Ref(_GtkTextIter(buffer, buffer.cursor_position)) + start = GtkTextIter(buffer) + stop = GtkTextIter(buffer) + iter = GtkTextIter(buffer, buffer.cursor_position) if direction == :forward - limit = Ref(_GtkTextIter(buffer, length(buffer)+1)) + limit = GtkTextIter(buffer, length(buffer)+1) found = forward_search( iter, str, start, stop, limit, flag) elseif direction == :backward - limit = Ref(_GtkTextIter(buffer, 1)) + limit = GtkTextIter(buffer, 1) found = backward_search(iter, str, start, stop, limit, flag) else error("Search direction must be :forward or :backward.") @@ -399,7 +384,7 @@ function next_(r::GtkTextRange, i) skip(i, 1) (c,i) end -done_(r::GtkTextRange, i) = i[] == last(r) +done_(r::GtkTextRange, i) = i == last(r) iterate(r::GtkTextRange, i=start_(r)) = done_(r,i) ? nothing : next_(r, i) function getproperty(text::GtkTextRange, key::Symbol) @@ -421,24 +406,22 @@ function getproperty(text::GtkTextRange, key::Symbol) end end function splice!(text::GtkTextBuffer, index::GtkTextRange) - ccall((:gtk_text_buffer_delete, libgtk4), Nothing, - (Ptr{GObject}, Ref{_GtkTextIter}, Ref{_GtkTextIter}), text, first(index), last(index)) + G_.delete(text, first(index), last(index)) text end in(x::TI, r::GtkTextRange) = Bool(ccall((:gtk_text_iter_in_range, libgtk4), Cint, - (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), Ref(x), first(r), last(r))) + (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), x, first(r), last(r))) ##### GtkTextBuffer ##### #TODO: tags, marks #TODO: clipboard, selection/cursor, user_action_groups -iterate(text::GtkTextBuffer, iter=start_(_GtkTextIter(text))) = iterate(iter, iter) +iterate(text::GtkTextBuffer, iter=start_(GtkTextIter(text))) = iterate(iter, iter) length(text::GtkTextBuffer) = G_.get_char_count(text) #get_line_count(text::GtkTextBuffer) = ccall((:gtk_text_buffer_get_line_count, libgtk4), Cint, (Ptr{GObject},), text) function insert!(text::GtkTextBuffer, index::TI, str::AbstractString) - ccall((:gtk_text_buffer_insert, libgtk4), Nothing, - (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{UInt8}, Cint), text, Ref(index), bytestring(str), sizeof(str)) + G_.insert(text, index, str, sizeof(str)) text end function insert!(text::GtkTextBuffer, str::AbstractString) @@ -446,8 +429,7 @@ function insert!(text::GtkTextBuffer, str::AbstractString) text end function splice!(text::GtkTextBuffer, index::TI) - ccall((:gtk_text_buffer_backspace, libgtk4), Nothing, - (Ptr{GObject}, Ptr{_GtkTextIter}, Cint, Cint), text, Ref(index), false, true) + G_.backspace(text, index, false, true) text end function splice!(text::GtkTextBuffer) @@ -467,23 +449,20 @@ the selected text. Implements `gtk_text_buffer_get_selection_bounds`. """ function selection_bounds(buffer::GtkTextBuffer) - start = Ref(_GtkTextIter(buffer)) - stop = Ref(_GtkTextIter(buffer)) - selected = Bool(ccall((:gtk_text_buffer_get_selection_bounds,libgtk4), Cint, - (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), buffer, start, stop)) - return (selected, start, stop) + selected, start, stop = G_.get_selection_bounds(buffer) # returns the _GtkTextIter, not refs to it + return (selected, Ref(start), Ref(stop)) end """ select_range(buffer::GtkTextBuffer, ins::TI, bound::TI) select_range(buffer::GtkTextBuffer, range::GtkTextRange) -Select the text in `buffer` accorind to _GtkTextIter `ins` and `bound`. +Select the text in `buffer` according to _GtkTextIter `ins` and `bound`. Implements `gtk_text_buffer_select_range`. """ function select_range(buffer::GtkTextBuffer, ins::TI, bound::TI) - ccall((:gtk_text_buffer_select_range, libgtk4), Cvoid, (Ptr{GObject}, Ref{_GtkTextIter}, Ref{_GtkTextIter}), buffer, ins, bound) + G_.select_range(buffer, ins, bound) end select_range(buffer::GtkTextBuffer, range::GtkTextRange) = select_range(buffer, range.a, range.b) @@ -493,10 +472,8 @@ select_range(buffer::GtkTextBuffer, range::GtkTextRange) = select_range(buffer, Place the cursor at indicated position. """ -place_cursor(buffer::GtkTextBuffer, it::_GtkTextIter) = - ccall((:gtk_text_buffer_place_cursor, libgtk4), Cvoid, (Ptr{GObject}, Ref{_GtkTextIter}), buffer, it) -place_cursor(buffer::GtkTextBuffer, pos::Int) = place_cursor(buffer, _GtkTextIter(buffer, pos)) -place_cursor(buffer::GtkTextBuffer, it::Ref{_GtkTextIter}) = place_cursor(buffer, it[]) +place_cursor(buffer::GtkTextBuffer, pos::Int) = place_cursor(buffer, GtkTextIter(buffer, pos)) +place_cursor(buffer::GtkTextBuffer, it::TI) = G_.place_cursor(buffer, it) begin_user_action(buffer::GtkTextBuffer) = G_.begin_user_action(buffer) end_user_action(buffer::GtkTextBuffer) = G_.end_user_action(buffer) @@ -522,21 +499,15 @@ function create_tag(buffer::GtkTextBuffer, tag_name::AbstractString; properties. end function apply_tag(buffer::GtkTextBuffer, name::AbstractString, itstart::TI, itend::TI) - ccall((:gtk_text_buffer_apply_tag_by_name, libgtk4), Nothing, - (Ptr{GObject}, Ptr{UInt8}, Ref{_GtkTextIter}, Ref{_GtkTextIter}), - buffer, bytestring(name), itstart, itend) + G_.apply_tag_by_name(buffer, name, itstart, itend) end function remove_tag(buffer::GtkTextBuffer, name::AbstractString, itstart::TI, itend::TI) - ccall((:gtk_text_buffer_remove_tag_by_name, libgtk4), Nothing, - (Ptr{GObject}, Ptr{UInt8}, Ref{_GtkTextIter}, Ref{_GtkTextIter}), - buffer, bytestring(name), itstart, itend) + G_.remove_tag_by_name(buffer, name, itstart, itend) end function remove_all_tags(buffer::GtkTextBuffer, itstart::TI, itend::TI) - ccall((:gtk_text_buffer_remove_all_tags, libgtk4), Nothing, - (Ptr{GObject}, Ref{_GtkTextIter}, Ref{_GtkTextIter}), - buffer, itstart, itend) + G_.remove_all_tags(buffer, itstart, itend) end """ @@ -578,18 +549,13 @@ function getindex(text::GtkTextView, sym::Symbol, ::Type{Bool}) end function insert!(text::GtkTextView, index::TI, child::GtkWidget) - index = Ref(index) - anchor = ccall((:gtk_text_buffer_create_child_anchor, libgtk4), Ptr{Nothing}, - (Ptr{GObject}, Ptr{_GtkTextIter}), G_.get_buffer(text), index) - ccall((:gtk_text_view_add_child_at_anchor, libgtk4), Nothing, - (Ptr{GObject}, Ptr{GObject}, Ptr{_GtkTextIter}), text, index, anchor) + anchor = G_.create_child_anchor(G_.get_buffer(text), index) + G_.add_child_at_anchor(text, child, anchor) text end function insert!(text::GtkTextView, index::TI, str::AbstractString) - Bool(ccall((:gtk_text_buffer_insert_interactive, libgtk4), Cint, - (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{UInt8}, Cint, Cint), - G_.get_buffer(text), index, bytestring(str), sizeof(str), G_.get_editable(text))) + G_.insert_interactive(G_.get_buffer(text), index, str, sizeof(str), G_.get_editable(text)) text end function insert!(text::GtkTextView, str::AbstractString) @@ -597,9 +563,7 @@ function insert!(text::GtkTextView, str::AbstractString) text end function splice!(text::GtkTextView, index::TI) - ccall((:gtk_text_buffer_backspace, libgtk4), Nothing, - (Ptr{GObject}, Ptr{_GtkTextIter}, Cint, Cint), - G_.get_buffer(text), Ref(index), true, G_.get_editable(text)) + G_.backspace(G_.get_buffer(text), index, true, G_.get_editable(text)) text end function splice!(text::GtkTextView) @@ -623,9 +587,8 @@ end function scroll_to(view::GtkTextView, iter::TI, within_margin::Real, use_align::Bool, xalign::Real, yalign::Real) - ccall((:gtk_text_view_scroll_to_iter, libgtk4), Nothing, - (Ptr{GObject}, Ptr{_GtkTextIter}, Cdouble, Cint, Cdouble, Cdouble), - view, iter, within_margin, use_align, xalign, yalign) + G_.scroll_to_iter(view, iter, within_margin, use_align, xalign, yalign) + nothing end @@ -635,7 +598,7 @@ end Implements `gtk_text_view_buffer_to_window_coords`. """ function buffer_to_window_coords(view::GtkTextView, buffer_x::Integer, buffer_y::Integer, wintype = TextWindowType_WIDGET) - G_.buffer_to_window_coords(view, wintype, buffer_x, buffer_y) + G_.buffer_to_window_coords(view, wintype, buffer_x, buffer_y) end """ @@ -654,29 +617,27 @@ Implements `gtk_text_view_get_iter_at_position`. """ function text_iter_at_position(view::GtkTextView, x::Integer, y::Integer) buffer = view.buffer - iter = Ref(_GtkTextIter(buffer)) - text_iter_at_position(view, iter, C_NULL, Int32(x), Int32(y)) - return _GtkTextIter(buffer, char_offset(iter)) + iter = GtkTextIter(buffer) + text_iter_at_position(view, iter, nothing, Int32(x), Int32(y)) + return GtkTextIter(buffer, char_offset(iter)) end -text_iter_at_position(view::GtkTextView, iter::Ref{_GtkTextIter}, trailing, x::Int32, y::Int32) = ccall( - (:gtk_text_view_get_iter_at_position, libgtk4), Cvoid, - (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{Cint}, Cint, Cint), - view, iter, trailing, x, y -) +function text_iter_at_position(view::GtkTextView, iter::Ref{_GtkTextIter}, trailing, x::Int32, y::Int32) + ret, iter_ret, trailing_ret = G_.get_iter_at_position(view, x, y) + iter[] = iter_ret + if trailing !== nothing + trailing[] = trailing_ret + end +end function cursor_locations(view::GtkTextView) weak = Ref{_GdkRectangle}() strong = Ref{_GdkRectangle}() buffer = view.buffer - iter = Ref(_GtkTextIter(buffer, buffer.cursor_position)) - - ccall( - (:gtk_text_view_get_cursor_locations, libgtk4), Cvoid, - (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GdkRectangle}, Ptr{_GdkRectangle}), - view, iter, strong, weak - ) - return (iter, strong[], weak[]) + iter = GtkTextIter(buffer, buffer.cursor_position) + + string, weak = G_.get_cursor_locations(view, iter) + return (iter, strong, weak) end #### GtkTextMark #### diff --git a/test/text.jl b/test/text.jl index 1ee1b8e1..b1613261 100644 --- a/test/text.jl +++ b/test/text.jl @@ -16,8 +16,8 @@ v = GtkTextView(b) push!(w, v) -its = _GtkTextIter(b, 1) -ite = _GtkTextIter(b, 2) +its = GtkTextIter(b, 1) +ite = GtkTextIter(b, 2) @test buffer(its) == b @test (its:ite).text == "t" @@ -25,10 +25,10 @@ ite = _GtkTextIter(b, 2) splice!(b, its:ite) @test b.text == "est" -insert!(b, _GtkTextIter(b, 1), "t") +insert!(b, GtkTextIter(b, 1), "t") @test b.text == "test" -it = _GtkTextIter(b) +it = GtkTextIter(b) @test it.line == 0 #lines are 0-based @test it.starts_line == true @test it.ends_line == false @@ -40,7 +40,7 @@ it = _GtkTextIter(b) @test it.ends_sentence == false b.text = "line1\nline2" -it = Ref(_GtkTextIter(b)) +it = GtkTextIter(b) it.line = 1 @test it.line == 1 @@ -58,18 +58,18 @@ it.visible_line_index = 0 @test it.can_insert -it1 = _GtkTextIter(b, 1) -it2 = _GtkTextIter(b, 1) +it1 = GtkTextIter(b, 1) +it2 = GtkTextIter(b, 1) @test it1 == it2 -it2 = _GtkTextIter(b, 2) +it2 = GtkTextIter(b, 2) @test (it1 == it2) == false @test it1 < it2 @test it1 <= it2 @test it2 > it1 it2 -= 1 -@test Ref(it1) == it2 +@test it1 == it2 -it3 = _GtkTextIter(b, 2, 1) +it3 = GtkTextIter(b, 2, 1) m = GtkTextMark() #it4 = _GtkTextIter(b, m) @@ -80,17 +80,16 @@ show(m) # tags Gtk4.create_tag(b, "big"; size_points = 24) Gtk4.create_tag(b, "red"; foreground = "red") -f(buffer)=Gtk4.apply_tag(buffer, "big", _GtkTextIter(b, 1), _GtkTextIter(b, 6)) +f(buffer)=Gtk4.apply_tag(buffer, "big", GtkTextIter(b, 1), GtkTextIter(b, 6)) user_action(f, b) -Gtk4.apply_tag(b, "red", _GtkTextIter(b, 1), _GtkTextIter(b, 6)) -Gtk4.remove_tag(b, "red", _GtkTextIter(b, 1), _GtkTextIter(b, 3)) -Gtk4.remove_all_tags(b, _GtkTextIter(b, 4), _GtkTextIter(b, 6)) +Gtk4.apply_tag(b, "red", GtkTextIter(b, 1), GtkTextIter(b, 6)) +Gtk4.remove_tag(b, "red", GtkTextIter(b, 1), GtkTextIter(b, 3)) +Gtk4.remove_all_tags(b, GtkTextIter(b, 4), GtkTextIter(b, 6)) # getproperty @test it1.offset == 0 #Gtk indices are zero based @test it2.offset == 0 -it1 = Ref(it1) it1.offset = 1 @test it1.offset == 1 @@ -106,8 +105,8 @@ skip(it2, :backward_line) skip(it2, :forward_line) @test it2.line == 1 skip(it2, :forward_to_line_end) -it1 = Ref(_GtkTextIter(b, it2.offset-1)) -(it1[]:it2[]).text == "2" +it1 = GtkTextIter(b, it2.offset-1) +(it1:it2).text == "2" whats = [:forward_word_end, :backward_word_start, :backward_sentence_start, :forward_sentence_end] for what in whats @@ -176,15 +175,15 @@ tv.buffer = b insert!(b, "text") -splice!(b, _GtkTextIter(b, 5)) +splice!(b, GtkTextIter(b, 5)) @test b.text == "tex" b[String] = "text" -st=_GtkTextIter(b, 1) -mi=_GtkTextIter(b, 3) -en=_GtkTextIter(b, 5) +st=GtkTextIter(b, 1) +mi=GtkTextIter(b, 3) +en=GtkTextIter(b, 5) @test in(mi, st:en) @@ -195,12 +194,12 @@ splice!(tv) @test b.text == "" b.text = "new" -st = _GtkTextIter(b, 4) +st = GtkTextIter(b, 4) place_cursor(b, st) insert!(tv, " text") @test b.text == "new text" -en = _GtkTextIter(b, 9) +en = GtkTextIter(b, 9) splice!(tv, en) @test b.text == "new tex" From c7a47b8b6c46ad0d440f020c6a79f7bf09b88bb7 Mon Sep 17 00:00:00 2001 From: Jared Wahlstrand Date: Sun, 12 May 2024 12:12:57 -0400 Subject: [PATCH 2/4] random stuff --- gen/gen_gio.jl | 2 +- src/GLib/gerror.jl | 3 +- src/GLib/gtype.jl | 12 ++- src/displays.jl | 15 ++++ src/gen/gio_methods | 175 ++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 204 insertions(+), 3 deletions(-) diff --git a/gen/gen_gio.jl b/gen/gen_gio.jl index 12339c61..bc31cad9 100644 --- a/gen/gen_gio.jl +++ b/gen/gen_gio.jl @@ -31,7 +31,7 @@ object_method_skiplist=[:new_for_bus,:export,:add_option_group,:make_pollfd,:get :new_for_bus_sync,:new_sync,:writev,:writev_all,:flatten_tree,:changed_tree,:receive_messages,:send_message,:send_message_with_timeout,:send_messages, :get_channel_binding_data,:lookup_certificates_issued_by,:get_default,:get_unix_fd_list,:set_unix_fd_list,:get_attribute_file_path,:set_attribute_file_path,:get_timeout,:set_timeout] -object_skiplist=vcat(obj_skiplist,[:AppInfoMonitor,:DBusConnection,:DBusMenuModel,:DBusProxy,:DBusMethodInvocation,:IOModule,:SimpleProxyResolver,:UnixMountMonitor,:Task]) +object_skiplist=vcat(obj_skiplist,[:AppInfoMonitor,:DBusConnection,:DBusMenuModel,:DBusProxy,:DBusMethodInvocation,:IOModule,:SimpleProxyResolver,:UnixMountMonitor]) interface_method_skiplist=[:add_action_entries,:get_info,:receive_messages,:send_messages, :writev_nonblocking,:dup_default,:remove_action_entries,:new_build_filenamev] diff --git a/src/GLib/gerror.jl b/src/GLib/gerror.jl index 5e10dca3..f52bccf7 100644 --- a/src/GLib/gerror.jl +++ b/src/GLib/gerror.jl @@ -26,6 +26,8 @@ end GErrorException(err::GError) = GErrorException(err.domain, err.code, message(err)) +GError(e::GErrorException) = GError(e.domain, e.code, Base.unsafe_convert(Cstring,e.message)) + function check_err(err::Base.RefValue{Ptr{GError}}) if err[] != C_NULL gerror = GError(err[]) @@ -34,4 +36,3 @@ function check_err(err::Base.RefValue{Ptr{GError}}) throw(ee) end end - diff --git a/src/GLib/gtype.jl b/src/GLib/gtype.jl index 00f9ff1b..dfc7eaed 100644 --- a/src/GLib/gtype.jl +++ b/src/GLib/gtype.jl @@ -224,7 +224,11 @@ _gc_unref(@nospecialize(x), ::Ptr{Nothing}) = gc_unref(x) gc_ref_closure(@nospecialize(cb::Function)) = (invoke(gc_ref, Tuple{Any}, cb), @cfunction(_gc_unref, Nothing, (Any, Ptr{Nothing}))) gc_ref_closure(x::T) where {T} = (gc_ref(x), @cfunction(_gc_unref, Nothing, (Any, Ptr{Nothing}))) -# GLib ref/unref functions -- generally, you shouldn't be calling these +""" + glib_ref(x::Ptr) + +Increments the reference count of a pointer managed by a GLib based library. Generally this function will just call a C function, e.g. `g_object_ref`. Most users will not ever need to use this function. +""" function glib_ref(x::Ptr{GObject}) ccall((:g_object_ref, libgobject), Nothing, (Ptr{GObject},), x) end @@ -234,6 +238,12 @@ function glib_ref(x::GObject) end glib_ref(::Nothing) = nothing gc_unref(p::Ptr{GObject}) = glib_unref(p) + +""" + glib_unref(x::Ptr) + +Decrements the reference count of a pointer managed by a GLib based library. Generally this function will just call a C function, e.g. `g_object_unref`. Most users will not ever need to use this function. +""" function glib_unref(x::Ptr{GObject}) ccall((:g_object_unref, libgobject), Nothing, (Ptr{GObject},), x) end diff --git a/src/displays.jl b/src/displays.jl index d78b165d..334bd207 100644 --- a/src/displays.jl +++ b/src/displays.jl @@ -40,7 +40,22 @@ pulse(progress::GtkProgressBar) = G_.pulse(progress) ## GtkSpinner +""" + start(spinner::GtkSpinner) + +Start a GtkSpinner widget spinning. The purpose of this widget is to show that some operation is in process. + +Related GTK function: [`gtk_spinner_start`()]($(gtkdoc_method_url("gtk4","Spinner","start"))) +""" start(spinner::GtkSpinner) = G_.start(spinner) + +""" + stop(spinner::GtkSpinner) + +Stop a GtkSpinner. The purpose of this widget is to show that some operation is in process. + +Related GTK function: [`gtk_spinner_stop`()]($(gtkdoc_method_url("gtk4","Spinner","stop"))) +""" stop(spinner::GtkSpinner) = G_.stop(spinner) ## GtkStatusbar diff --git a/src/gen/gio_methods b/src/gen/gio_methods index aa295b24..cad5aa2d 100644 --- a/src/gen/gio_methods +++ b/src/gen/gio_methods @@ -5773,6 +5773,181 @@ $(Expr(:toplevel, quote ret = ccall(("g_subprocess_launcher_unsetenv", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _variable) nothing end + function Task_new(_source_object::Maybe(GObject), _cancellable::Maybe(GCancellable), _callback::Maybe(Function)) + _source_object_maybe = nothing_to_null(_source_object) + _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(("g_task_new", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), _source_object_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure) + ret2 = GTaskLeaf(ret, true) + ret2 + end + function is_valid(_result::GAsyncResult, _source_object::Maybe(GObject)) + _source_object_maybe = nothing_to_null(_source_object) + ret = ccall(("g_task_is_valid", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), _result, _source_object_maybe) + ret2 = convert(Bool, ret) + ret2 + end + function report_error(_source_object::Maybe(GObject), _callback::Maybe(Function), _source_tag::Maybe(Nothing), _error) + _source_object_maybe = nothing_to_null(_source_object) + 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 + _source_tag_maybe = nothing_to_null(_source_tag) + ret = ccall(("g_task_report_error", libgio), Nothing, (Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Nothing}, Ptr{GError}), _source_object_maybe, _callback_cfunc, _callback_closure, _source_tag_maybe, _error) + nothing + end + function get_cancellable(instance::GTask) + ret = ccall(("g_task_get_cancellable", libgio), Ptr{GObject}, (Ptr{GObject},), instance) + ret2 = convert_if_not_null(GCancellable, ret, false) + ret2 + end + function get_check_cancellable(instance::GTask) + ret = ccall(("g_task_get_check_cancellable", libgio), Cint, (Ptr{GObject},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function get_completed(instance::GTask) + ret = ccall(("g_task_get_completed", libgio), Cint, (Ptr{GObject},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function get_context(instance::GTask) + ret = ccall(("g_task_get_context", libgio), Ptr{GMainContext}, (Ptr{GObject},), instance) + ret2 = convert(GMainContext, ret, false) + ret2 + end + function get_name(instance::GTask) + ret = ccall(("g_task_get_name", libgio), Cstring, (Ptr{GObject},), instance) + ret2 = string_or_nothing(ret, false) + ret2 + end + function get_priority(instance::GTask) + ret = ccall(("g_task_get_priority", libgio), Int32, (Ptr{GObject},), instance) + ret + end + function get_return_on_cancel(instance::GTask) + ret = ccall(("g_task_get_return_on_cancel", libgio), Cint, (Ptr{GObject},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function get_source_object(instance::GTask) + ret = ccall(("g_task_get_source_object", libgio), Ptr{GObject}, (Ptr{GObject},), instance) + ret2 = convert_if_not_null(GObject, ret, false) + ret2 + end + function get_source_tag(instance::GTask) + ret = ccall(("g_task_get_source_tag", libgio), Ptr{Nothing}, (Ptr{GObject},), instance) + ret2 = convert(Nothing, ret) + ret2 + end + function get_task_data(instance::GTask) + ret = ccall(("g_task_get_task_data", libgio), Ptr{Nothing}, (Ptr{GObject},), instance) + ret2 = convert(Nothing, ret) + ret2 + end + function had_error(instance::GTask) + ret = ccall(("g_task_had_error", libgio), Cint, (Ptr{GObject},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function propagate_boolean(instance::GTask) + err = err_buf() + ret = ccall(("g_task_propagate_boolean", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err) + check_err(err) + ret2 = convert(Bool, ret) + ret2 + end + function propagate_int(instance::GTask) + err = err_buf() + ret = ccall(("g_task_propagate_int", libgio), Int64, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err) + check_err(err) + ret + end + function propagate_pointer(instance::GTask) + err = err_buf() + ret = ccall(("g_task_propagate_pointer", libgio), Ptr{Nothing}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err) + check_err(err) + ret2 = convert(Nothing, ret) + ret2 + end + function propagate_value(instance::GTask) + m_value = Ref{_GValue}() + err = err_buf() + ret = ccall(("g_task_propagate_value", libgio), 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 return_boolean(instance::GTask, _result::Bool) + ret = ccall(("g_task_return_boolean", libgio), Nothing, (Ptr{GObject}, Cint), instance, _result) + nothing + end + function return_error(instance::GTask, _error) + ret = ccall(("g_task_return_error", libgio), Nothing, (Ptr{GObject}, Ptr{GError}), instance, _error) + nothing + end + function return_error_if_cancelled(instance::GTask) + ret = ccall(("g_task_return_error_if_cancelled", libgio), Cint, (Ptr{GObject},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function return_int(instance::GTask, _result::Integer) + ret = ccall(("g_task_return_int", libgio), Nothing, (Ptr{GObject}, Int64), instance, _result) + nothing + end + function return_value(instance::GTask, _result::Maybe(Union{GValue, Ref{_GValue}})) + _result_maybe = nothing_to_null(_result) + ret = ccall(("g_task_return_value", libgio), Nothing, (Ptr{GObject}, Ptr{_GValue}), instance, _result_maybe) + nothing + end + function set_check_cancellable(instance::GTask, _check_cancellable::Bool) + ret = ccall(("g_task_set_check_cancellable", libgio), Nothing, (Ptr{GObject}, Cint), instance, _check_cancellable) + nothing + end + function set_name(instance::GTask, _name::Maybe(Union{AbstractString, Symbol})) + _name_maybe = nothing_to_null(_name) + ret = ccall(("g_task_set_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _name_maybe) + nothing + end + function set_priority(instance::GTask, _priority::Integer) + ret = ccall(("g_task_set_priority", libgio), Nothing, (Ptr{GObject}, Int32), instance, _priority) + nothing + end + function set_return_on_cancel(instance::GTask, _return_on_cancel::Bool) + ret = ccall(("g_task_set_return_on_cancel", libgio), Cint, (Ptr{GObject}, Cint), instance, _return_on_cancel) + ret2 = convert(Bool, ret) + ret2 + end + function set_source_tag(instance::GTask, _source_tag::Maybe(Nothing)) + _source_tag_maybe = nothing_to_null(_source_tag) + ret = ccall(("g_task_set_source_tag", libgio), Nothing, (Ptr{GObject}, Ptr{Nothing}), instance, _source_tag_maybe) + nothing + end + function set_static_name(instance::GTask, _name::Maybe(Union{AbstractString, Symbol})) + _name_maybe = nothing_to_null(_name) + ret = ccall(("g_task_set_static_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _name_maybe) + nothing + end + function get_user_data(instance::GTask) + get_user_data(GAsyncResult(instance)) + end + function is_tagged(instance::GTask, _source_tag::Maybe(Nothing)) + is_tagged(GAsyncResult(instance), _source_tag) + end + function legacy_propagate_error(instance::GTask) + legacy_propagate_error(GAsyncResult(instance)) + end function get_graceful_disconnect(instance::GTcpConnection) ret = ccall(("g_tcp_connection_get_graceful_disconnect", libgio), Cint, (Ptr{GObject},), instance) ret2 = convert(Bool, ret) From 609c69b7e2a7cdedca106114907a118ec443f2f1 Mon Sep 17 00:00:00 2001 From: Jared Wahlstrand Date: Sat, 6 Jul 2024 10:33:31 -0400 Subject: [PATCH 3/4] support adding widgets to gutter --- src/text.jl | 35 ++++++++++++++++++++++++++++++++--- 1 file changed, 32 insertions(+), 3 deletions(-) diff --git a/src/text.jl b/src/text.jl index a6350146..3d0f2345 100644 --- a/src/text.jl +++ b/src/text.jl @@ -1,8 +1,8 @@ -GtkTextBuffer() = G_.TextBuffer_new(nothing) +GtkTextBuffer(; kwargs...) = GtkTextBuffer(nothing; kwargs...) -GtkTextMark(left_gravity::Bool = false) = G_.TextMark_new(nothing, left_gravity) +GtkTextMark(left_gravity::Bool = false; kwargs...) = GtkTextMark(nothing, left_gravity; kwargs...) -GtkTextTag() = G_.TextTag_new(nothing) +GtkTextTag(; kwargs...) = GtkTextTag(nothing; kwargs...) const TI = Union{Ref{_GtkTextIter}, GtkTextIter} zero(::Type{_GtkTextIter}) = _GtkTextIter() @@ -640,6 +640,35 @@ function cursor_locations(view::GtkTextView) return (iter, strong, weak) end +function convert(::Type{Gtk4.TextWindowType}, x::Symbol) + if x === :left + Gtk4.TextWindowType_LEFT + elseif x === :right + Gtk4.TextWindowType_RIGHT + elseif x === :top + Gtk4.TextWindowType_TOP + elseif x === :bottom + Gtk4.TextWindowType_BOTTOM + elseif x === :widget + Gtk4.TextWindowType_WIDGET + elseif x === :text + Gtk4.TextWindowType_TEXT + else + error("can't convert $x to GtkTextWindowType") + end +end + +function gutter(view::GtkTextView, type::TextWindowType, widget::GtkWidget) + G_.set_gutter(view, type, widget) +end + +function gutter(view::GtkTextView, type::Symbol, widget::GtkWidget) + G_.set_gutter(view, convert(TextWindowType, type), widget) +end + +gutter(view::GtkTextView, type::TextWindowType) = G_.get_gutter(view, type) +gutter(view::GtkTextView, type::Symbol) = G_.get_gutter(view, type) + #### GtkTextMark #### show(w::GtkTextMark) = visible(w, true) From 02431e6c2ceea67cb1f118c3c905f6b59131abe5 Mon Sep 17 00:00:00 2001 From: Jared Wahlstrand Date: Sat, 6 Jul 2024 17:12:16 -0400 Subject: [PATCH 4/4] fix GtkTextIter auto-generated methods, better support methods for all non-opaque structs --- GI/src/giexport.jl | 6 + GI/src/giimport.jl | 13 +- examples/HDF5Viewer/Project.toml | 2 +- gen/gen_gtk4.jl | 2 +- src/GLib/GLib.jl | 2 +- src/GLib/gvalues.jl | 1 + src/gen/cairo_structs | 250 +++++---- src/gen/gdk4_functions | 6 +- src/gen/gdk4_methods | 48 +- src/gen/gdk4_structs | 249 +++++---- src/gen/gdkpixbuf_methods | 26 +- src/gen/gdkpixbuf_structs | 4 +- src/gen/gio_functions | 8 +- src/gen/gio_methods | 30 +- src/gen/gio_structs | 192 ++++--- src/gen/glib_methods | 178 +++--- src/gen/glib_structs | 518 ++++++++++-------- src/gen/gobject_functions | 58 +- src/gen/gobject_methods | 118 ++-- src/gen/gobject_structs | 42 +- src/gen/graphene_functions | 52 +- src/gen/graphene_methods | 788 +++++++++++++-------------- src/gen/graphene_structs | 21 +- src/gen/gsk4_functions | 4 +- src/gen/gsk4_methods | 134 ++--- src/gen/gsk4_structs | 100 ++-- src/gen/gtk4_functions | 12 +- src/gen/gtk4_methods | 903 +++++++++++++++++++++++-------- src/gen/gtk4_structs | 268 +++++---- src/gen/pango_functions | 92 ++-- src/gen/pango_methods | 210 +++---- src/gen/pango_structs | 232 ++++---- src/gen/pangocairo_structs | 2 +- src/text.jl | 173 +++--- 34 files changed, 2737 insertions(+), 2007 deletions(-) diff --git a/GI/src/giexport.jl b/GI/src/giexport.jl index 6aafd2f5..77a27566 100644 --- a/GI/src/giexport.jl +++ b/GI/src/giexport.jl @@ -120,6 +120,9 @@ function struct_exprs!(exprs,exports,ns,structs=nothing;print_summary=true,exclu end push!(exports.args, get_full_name(ssi)) length(fields)>0 && push!(exports.args,get_struct_name(ssi,false)) + if length(fields)>0 && !in(name, import_as_opaque) + push!(exports.args, structptrlike(ssi)) + end end if print_summary @@ -168,6 +171,9 @@ function all_struct_exprs!(exprs,exports,ns;print_summary=true,excludelist=[],co push!(exprs, decl(ssi,in(name,import_as_opaque))) push!(exports.args, get_full_name(ssi)) + if length(fields)>0 + push!(exports.args, structptrlike(ssi)) + end push!(loaded, name) length(fields)>0 && push!(exports.args,get_struct_name(ssi,false)) end diff --git a/GI/src/giimport.jl b/GI/src/giimport.jl index a890f34e..ed72f614 100644 --- a/GI/src/giimport.jl +++ b/GI/src/giimport.jl @@ -108,6 +108,7 @@ function decl(structinfo::GIStructInfo,force_opaque=false) end end conv=nothing + structlike = Symbol(gstructname,:Like) if !opaque fieldsexpr=Expr[] for field in get_fields(structinfo) @@ -125,6 +126,11 @@ function decl(structinfo::GIStructInfo,force_opaque=false) conv = quote unsafe_convert(::Type{Ptr{$ustructname}}, box::$gstructname) = convert(Ptr{$ustructname}, box.handle) convert(::Type{$gstructname}, p::Ptr{$ustructname}, owns = false) = $gstructname(p, owns) + const $structlike = Union{Ref{$ustructname},$gstructname} + end + else + conv = quote + const $structlike = $gstructname end end decl = isboxed ? :($gstructname <: GBoxed) : gstructname @@ -501,12 +507,13 @@ function typename(info::GIStructInfo) Symbol(GLib.g_type_name(g_type)) end end +structptrlike(info::GIStructInfo) = Symbol(get_full_name(info),:Like) function extract_type(typeinfo::GITypeInfo, info::GIStructInfo) name = typename(info) sname = get_struct_name(info) if is_pointer(typeinfo) fname = get_full_name(info) - tname = isopaque(info) ? fname : :(Union{$fname,Ref{$sname}}) + tname = isopaque(info) ? fname : structptrlike(info) TypeDesc(info,tname,typename(info),:(Ptr{$sname})) else TypeDesc(info,sname,sname,sname) @@ -517,7 +524,7 @@ function extract_type(typeinfo::Type{InstanceType}, info::GIStructInfo) sname = get_struct_name(info) if is_pointer(typeinfo) fname = get_full_name(info) - tname = isopaque(info) ? fname : :(Union{$fname,Ref{$sname}}) + tname = isopaque(info) ? fname : structptrlike(info) TypeDesc(info,tname,typename(info),:(Ptr{$sname})) else TypeDesc(info,sname,sname,sname) @@ -801,7 +808,7 @@ function extract_type(typeinfo::GITypeInfo, basetype::Type{T}) where {T<:GBoxed} name = get_full_name(interf_info) sname = get_struct_name(interf_info) p = is_pointer(typeinfo) - jarg = (name != sname ? :(Union{$name,Ref{$sname}}) : name) + jarg = (name != sname ? structptrlike(interf_info) : name) ctype = is_pointer(typeinfo) ? :(Ptr{$sname}) : sname TypeDesc{Type{GBoxed}}(GBoxed, jarg, name, ctype) end diff --git a/examples/HDF5Viewer/Project.toml b/examples/HDF5Viewer/Project.toml index d9c358b1..2570cd88 100644 --- a/examples/HDF5Viewer/Project.toml +++ b/examples/HDF5Viewer/Project.toml @@ -8,5 +8,5 @@ HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f" PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a" [compat] -Gtk4 = "0.6" +Gtk4 = "0.7" diff --git a/gen/gen_gtk4.jl b/gen/gen_gtk4.jl index ae1b7162..b36107cb 100644 --- a/gen/gen_gtk4.jl +++ b/gen/gen_gtk4.jl @@ -21,7 +21,7 @@ skiplist=[:create_closure,:activate_cell,:event,:start_editing,:filter_keypress, object_skiplist=vcat(object_skiplist,[:CellRenderer,:MnemonicAction,:NeverTrigger,:NothingAction,:PrintJob,:PrintSettings,:RecentManager]) -GI.export_methods!(ns,path,"gtk4"; exclude_deprecated = false, object_method_skiplist = skiplist, object_skiplist = object_skiplist, interface_method_skiplist = [:start_editing, :install_properties], interface_skiplist = [:PrintOperationPreview], struct_skiplist = vcat(struct_skiplist,[:Bitset,:BitsetIter,:BuildableParseContext,:CssSection,:TextIter])) +GI.export_methods!(ns,path,"gtk4"; exclude_deprecated = false, object_method_skiplist = skiplist, object_skiplist = object_skiplist, interface_method_skiplist = [:start_editing, :install_properties], interface_skiplist = [:PrintOperationPreview], struct_skiplist = vcat(struct_skiplist,[:Bitset,:BitsetIter,:BuildableParseContext,:CssSection])) skiplist=[:editable_install_properties,:ordering_from_cmpfunc,:value_set_expression,:value_take_expression] diff --git a/src/GLib/GLib.jl b/src/GLib/GLib.jl index ae7c70da..14a587b5 100644 --- a/src/GLib/GLib.jl +++ b/src/GLib/GLib.jl @@ -33,7 +33,7 @@ export gtkdoc_const_url, gtkdoc_enum_url, gtkdoc_flags_url, gtkdoc_method_url, gtkdoc_func_url, gtkdoc_struc_url export gtype_wrappers, GVariantDict, GBytes, GVariantType -export GValue, GParamSpec, GTypeModule, _GValue +export GValue, GParamSpec, GTypeModule, _GValue, GValueLike Maybe(T) = Union{T,Nothing} diff --git a/src/GLib/gvalues.jl b/src/GLib/gvalues.jl index b1047a39..ef0696b6 100644 --- a/src/GLib/gvalues.jl +++ b/src/GLib/gvalues.jl @@ -4,6 +4,7 @@ struct GValue field3::UInt64 GValue() = new(0, 0, 0) end +const GValueLike = Union{Ref{GValue},GValue} # This should be a subtype of GBoxed and the above struct should be renamed to _GValue to be consistent with other boxed types const _GValue = GValue Base.zero(::Type{GValue}) = GValue() diff --git a/src/gen/cairo_structs b/src/gen/cairo_structs index f2d5e5e2..c3c80e2e 100644 --- a/src/gen/cairo_structs +++ b/src/gen/cairo_structs @@ -1,155 +1,185 @@ quote $(Expr(:toplevel, quote const gboxed_types = Any[] - mutable struct cairoContext <: GBoxed - handle::Ptr{cairoContext} - begin - (GLib.g_type(::Type{T}) where T <: cairoContext) = begin - ccall(("cairo_gobject_context_get_type", libcairo_gobject), GType, ()) - end - function cairoContext(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct cairoContext <: GBoxed + handle::Ptr{cairoContext} + begin + (GLib.g_type(::Type{T}) where T <: cairoContext) = begin + ccall(("cairo_gobject_context_get_type", libcairo_gobject), GType, ()) + end + function cairoContext(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, cairoContext) end - push!(gboxed_types, cairoContext) end + const cairoContextLike = cairoContext end - mutable struct cairoDevice <: GBoxed - handle::Ptr{cairoDevice} - begin - (GLib.g_type(::Type{T}) where T <: cairoDevice) = begin - ccall(("cairo_gobject_device_get_type", libcairo_gobject), GType, ()) - end - function cairoDevice(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct cairoDevice <: GBoxed + handle::Ptr{cairoDevice} + begin + (GLib.g_type(::Type{T}) where T <: cairoDevice) = begin + ccall(("cairo_gobject_device_get_type", libcairo_gobject), GType, ()) end + function cairoDevice(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, cairoDevice) end - push!(gboxed_types, cairoDevice) end + const cairoDeviceLike = cairoDevice end - mutable struct cairoSurface <: GBoxed - handle::Ptr{cairoSurface} - begin - (GLib.g_type(::Type{T}) where T <: cairoSurface) = begin - ccall(("cairo_gobject_surface_get_type", libcairo_gobject), GType, ()) - end - function cairoSurface(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct cairoSurface <: GBoxed + handle::Ptr{cairoSurface} + begin + (GLib.g_type(::Type{T}) where T <: cairoSurface) = begin + ccall(("cairo_gobject_surface_get_type", libcairo_gobject), GType, ()) + end + function cairoSurface(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, cairoSurface) end - push!(gboxed_types, cairoSurface) end + const cairoSurfaceLike = cairoSurface end - mutable struct cairoMatrix - handle::Ptr{cairoMatrix} + begin + mutable struct cairoMatrix + handle::Ptr{cairoMatrix} + end + const cairoMatrixLike = cairoMatrix end - mutable struct cairoPattern <: GBoxed - handle::Ptr{cairoPattern} - begin - (GLib.g_type(::Type{T}) where T <: cairoPattern) = begin - ccall(("cairo_gobject_pattern_get_type", libcairo_gobject), GType, ()) - end - function cairoPattern(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct cairoPattern <: GBoxed + handle::Ptr{cairoPattern} + begin + (GLib.g_type(::Type{T}) where T <: cairoPattern) = begin + ccall(("cairo_gobject_pattern_get_type", libcairo_gobject), GType, ()) end + function cairoPattern(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, cairoPattern) end - push!(gboxed_types, cairoPattern) end + const cairoPatternLike = cairoPattern end - mutable struct cairoRegion <: GBoxed - handle::Ptr{cairoRegion} - begin - (GLib.g_type(::Type{T}) where T <: cairoRegion) = begin - ccall(("cairo_gobject_region_get_type", libcairo_gobject), GType, ()) - end - function cairoRegion(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct cairoRegion <: GBoxed + handle::Ptr{cairoRegion} + begin + (GLib.g_type(::Type{T}) where T <: cairoRegion) = begin + ccall(("cairo_gobject_region_get_type", libcairo_gobject), GType, ()) + end + function cairoRegion(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, cairoRegion) end - push!(gboxed_types, cairoRegion) end + const cairoRegionLike = cairoRegion end - mutable struct cairoFontOptions <: GBoxed - handle::Ptr{cairoFontOptions} - begin - (GLib.g_type(::Type{T}) where T <: cairoFontOptions) = begin - ccall(("cairo_gobject_font_options_get_type", libcairo_gobject), GType, ()) - end - function cairoFontOptions(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct cairoFontOptions <: GBoxed + handle::Ptr{cairoFontOptions} + begin + (GLib.g_type(::Type{T}) where T <: cairoFontOptions) = begin + ccall(("cairo_gobject_font_options_get_type", libcairo_gobject), GType, ()) end + function cairoFontOptions(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, cairoFontOptions) end - push!(gboxed_types, cairoFontOptions) end + const cairoFontOptionsLike = cairoFontOptions end - mutable struct cairoFontFace <: GBoxed - handle::Ptr{cairoFontFace} - begin - (GLib.g_type(::Type{T}) where T <: cairoFontFace) = begin - ccall(("cairo_gobject_font_face_get_type", libcairo_gobject), GType, ()) - end - function cairoFontFace(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct cairoFontFace <: GBoxed + handle::Ptr{cairoFontFace} + begin + (GLib.g_type(::Type{T}) where T <: cairoFontFace) = begin + ccall(("cairo_gobject_font_face_get_type", libcairo_gobject), GType, ()) + end + function cairoFontFace(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, cairoFontFace) end - push!(gboxed_types, cairoFontFace) end + const cairoFontFaceLike = cairoFontFace end - mutable struct cairoScaledFont <: GBoxed - handle::Ptr{cairoScaledFont} - begin - (GLib.g_type(::Type{T}) where T <: cairoScaledFont) = begin - ccall(("cairo_gobject_scaled_font_get_type", libcairo_gobject), GType, ()) - end - function cairoScaledFont(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct cairoScaledFont <: GBoxed + handle::Ptr{cairoScaledFont} + begin + (GLib.g_type(::Type{T}) where T <: cairoScaledFont) = begin + ccall(("cairo_gobject_scaled_font_get_type", libcairo_gobject), GType, ()) end + function cairoScaledFont(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, cairoScaledFont) end - push!(gboxed_types, cairoScaledFont) end + const cairoScaledFontLike = cairoScaledFont end - mutable struct cairoPath - handle::Ptr{cairoPath} + begin + mutable struct cairoPath + handle::Ptr{cairoPath} + end + const cairoPathLike = cairoPath end begin struct _cairoRectangle @@ -183,6 +213,7 @@ $(Expr(:toplevel, quote convert(::Type{cairoRectangle}, p::Ptr{_cairoRectangle}, owns = false) = begin cairoRectangle(p, owns) end + const cairoRectangleLike = Union{Ref{_cairoRectangle}, cairoRectangle} end end begin @@ -217,11 +248,12 @@ $(Expr(:toplevel, quote convert(::Type{cairoRectangleInt}, p::Ptr{_cairoRectangleInt}, owns = false) = begin cairoRectangleInt(p, owns) end + const cairoRectangleIntLike = Union{Ref{_cairoRectangleInt}, cairoRectangleInt} end end gboxed_cache_init() = begin append!(GLib.gboxed_types, gboxed_types) end - export cairoContext, cairoDevice, cairoSurface, cairoMatrix, cairoPattern, cairoRegion, cairoFontOptions, cairoFontFace, cairoScaledFont, cairoPath, cairoRectangle, _cairoRectangle, cairoRectangleInt, _cairoRectangleInt + export cairoContext, cairoDevice, cairoSurface, cairoMatrix, cairoPattern, cairoRegion, cairoFontOptions, cairoFontFace, cairoScaledFont, cairoPath, cairoRectangle, cairoRectangleLike, _cairoRectangle, cairoRectangleInt, cairoRectangleIntLike, _cairoRectangleInt end)) end diff --git a/src/gen/gdk4_functions b/src/gen/gdk4_functions index 58ec137d..e1f176cb 100644 --- a/src/gen/gdk4_functions +++ b/src/gen/gdk4_functions @@ -1,6 +1,6 @@ quote $(Expr(:toplevel, quote - function cairo_rectangle(_cr::cairoContext, _rectangle::Union{GdkRectangle, Ref{_GdkRectangle}}) + function cairo_rectangle(_cr::cairoContext, _rectangle::GdkRectangleLike) ret = ccall(("gdk_cairo_rectangle", libgtk4), Nothing, (Ptr{cairoContext}, Ptr{_GdkRectangle}), _cr, _rectangle) nothing end @@ -17,7 +17,7 @@ $(Expr(:toplevel, quote ret = ccall(("gdk_cairo_set_source_pixbuf", libgtk4), Nothing, (Ptr{cairoContext}, Ptr{GObject}, Float64, Float64), _cr, _pixbuf, _pixbuf_x, _pixbuf_y) nothing end - function cairo_set_source_rgba(_cr::cairoContext, _rgba::Union{GdkRGBA, Ref{_GdkRGBA}}) + function cairo_set_source_rgba(_cr::cairoContext, _rgba::GdkRGBALike) ret = ccall(("gdk_cairo_set_source_rgba", libgtk4), Nothing, (Ptr{cairoContext}, Ptr{_GdkRGBA}), _cr, _rgba) nothing end @@ -47,7 +47,7 @@ $(Expr(:toplevel, quote ret2 = convert_if_not_null(GdkContentFormats, ret, true) ret2 end - function content_serialize_async(_stream::GOutputStream, _mime_type::Union{AbstractString, Symbol}, _value::Union{GValue, Ref{_GValue}}, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function)) + function content_serialize_async(_stream::GOutputStream, _mime_type::Union{AbstractString, Symbol}, _value::GValueLike, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function)) _cancellable_maybe = nothing_to_null(_cancellable) if _callback === nothing _callback_cfunc = C_NULL diff --git a/src/gen/gdk4_methods b/src/gen/gdk4_methods index c29be2f2..e7b637ed 100644 --- a/src/gen/gdk4_methods +++ b/src/gen/gdk4_methods @@ -50,7 +50,7 @@ $(Expr(:toplevel, quote ret2 = string_or_nothing(ret, false) ret2 end - function print(instance::GdkContentFormats, _string::Union{GString, Ref{_GString}}) + function print(instance::GdkContentFormats, _string::GStringLike) ret = ccall(("gdk_content_formats_print", libgtk4), Nothing, (Ptr{GdkContentFormats}, Ptr{_GString}), instance, _string) nothing end @@ -179,7 +179,7 @@ $(Expr(:toplevel, quote ret = ccall(("gdk_frame_timings_unref", libgtk4), Nothing, (Ptr{GdkFrameTimings},), instance) nothing end - function PopupLayout_new(_anchor_rect::Union{GdkRectangle, Ref{_GdkRectangle}}, _rect_anchor, _surface_anchor) + 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 @@ -201,7 +201,7 @@ $(Expr(:toplevel, quote end function get_anchor_rect(instance::GdkPopupLayout) ret = ccall(("gdk_popup_layout_get_anchor_rect", libgtk4), Ptr{_GdkRectangle}, (Ptr{GdkPopupLayout},), instance) - ret2 = convert(Union{GdkRectangle, Ref{_GdkRectangle}}, ret, false) + ret2 = convert(GdkRectangleLike, ret, false) ret2 end function get_offset(instance::GdkPopupLayout) @@ -243,7 +243,7 @@ $(Expr(:toplevel, quote ret = ccall(("gdk_popup_layout_set_anchor_hints", libgtk4), Nothing, (Ptr{GdkPopupLayout}, UInt32), instance, _anchor_hints) nothing end - function set_anchor_rect(instance::GdkPopupLayout, _anchor_rect::Union{GdkRectangle, Ref{_GdkRectangle}}) + 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 @@ -267,62 +267,62 @@ $(Expr(:toplevel, quote ret = ccall(("gdk_popup_layout_unref", libgtk4), Nothing, (Ptr{GdkPopupLayout},), instance) nothing end - function copy(instance::Union{GdkRGBA, Ref{_GdkRGBA}}) + function copy(instance::GdkRGBALike) ret = ccall(("gdk_rgba_copy", libgtk4), Ptr{_GdkRGBA}, (Ptr{_GdkRGBA},), instance) - ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, true) + ret2 = convert(GdkRGBALike, ret, true) ret2 end - function equal(instance::Union{GdkRGBA, Ref{_GdkRGBA}}, _p2::Union{GdkRGBA, Ref{_GdkRGBA}}) + 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::Union{GdkRGBA, Ref{_GdkRGBA}}) + function free(instance::GdkRGBALike) ret = ccall(("gdk_rgba_free", libgtk4), Nothing, (Ptr{_GdkRGBA},), instance) nothing end - function hash(instance::Union{GdkRGBA, Ref{_GdkRGBA}}) + function hash(instance::GdkRGBALike) ret = ccall(("gdk_rgba_hash", libgtk4), UInt32, (Ptr{_GdkRGBA},), instance) ret end - function is_clear(instance::Union{GdkRGBA, Ref{_GdkRGBA}}) + 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::Union{GdkRGBA, Ref{_GdkRGBA}}) + 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::Union{GdkRGBA, Ref{_GdkRGBA}}, _spec::Union{AbstractString, Symbol}) + 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::Union{GdkRGBA, Ref{_GdkRGBA}}) + 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::Union{GdkRectangle, Ref{_GdkRectangle}}, _x::Integer, _y::Integer) + 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::Union{GdkRectangle, Ref{_GdkRectangle}}, _rect2::Union{GdkRectangle, Ref{_GdkRectangle}}) + 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::Union{GdkRectangle, Ref{_GdkRectangle}}, _src2::Union{GdkRectangle, Ref{_GdkRectangle}}) + 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::Union{GdkRectangle, Ref{_GdkRectangle}}, _src2::Union{GdkRectangle, Ref{_GdkRectangle}}) + 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[] @@ -563,7 +563,7 @@ $(Expr(:toplevel, quote err = err_buf() ret = ccall(("gdk_clipboard_read_value_finish", libgtk4), Ptr{_GValue}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err) check_err(err) - ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false) + ret2 = convert(GValueLike, ret, false) ret2 end function set_content(instance::GdkClipboard, _provider::Maybe(GdkContentProvider)) @@ -572,7 +572,7 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function set(instance::GdkClipboard, _value::Union{GValue, Ref{_GValue}}) + function set(instance::GdkClipboard, _value::GValueLike) ret = ccall(("gdk_clipboard_set_value", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GValue}), instance, _value) nothing end @@ -630,7 +630,7 @@ $(Expr(:toplevel, quote end function get_value(instance::GdkContentDeserializer) ret = ccall(("gdk_content_deserializer_get_value", libgtk4), Ptr{_GValue}, (Ptr{GObject},), instance) - ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false) + ret2 = convert(GValueLike, ret, false) ret2 end function return_error(instance::GdkContentDeserializer, _error) @@ -655,7 +655,7 @@ $(Expr(:toplevel, quote ret2 = GdkContentProviderLeaf(ret, true) ret2 end - function ContentProvider_new_for_value(_value::Union{GValue, Ref{_GValue}}) + 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 @@ -744,7 +744,7 @@ $(Expr(:toplevel, quote end function get_value(instance::GdkContentSerializer) ret = ccall(("gdk_content_serializer_get_value", libgtk4), Ptr{_GValue}, (Ptr{GObject},), instance) - ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false) + ret2 = convert(GValueLike, ret, false) ret2 end function return_error(instance::GdkContentSerializer, _error) @@ -997,7 +997,7 @@ $(Expr(:toplevel, quote ret2 = convert(GdkClipboard, ret, false) ret2 end - function get_setting(instance::GdkDisplay, _name::Union{AbstractString, Symbol}, _value::Union{GValue, Ref{_GValue}}) + 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 @@ -1260,7 +1260,7 @@ $(Expr(:toplevel, quote err = err_buf() ret = ccall(("gdk_drop_read_value_finish", libgtk4), Ptr{_GValue}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err) check_err(err) - ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false) + ret2 = convert(GValueLike, ret, false) ret2 end function status(instance::GdkDrop, _actions, _preferred) diff --git a/src/gen/gdk4_structs b/src/gen/gdk4_structs index 13f3bfba..580d772b 100644 --- a/src/gen/gdk4_structs +++ b/src/gen/gdk4_structs @@ -1,98 +1,116 @@ quote $(Expr(:toplevel, quote const gboxed_types = Any[] - mutable struct GdkContentFormats <: GBoxed - handle::Ptr{GdkContentFormats} - begin - (GLib.g_type(::Type{T}) where T <: GdkContentFormats) = begin - ccall(("gdk_content_formats_get_type", libgtk4), GType, ()) - end - function GdkContentFormats(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GdkContentFormats <: GBoxed + handle::Ptr{GdkContentFormats} + begin + (GLib.g_type(::Type{T}) where T <: GdkContentFormats) = begin + ccall(("gdk_content_formats_get_type", libgtk4), GType, ()) + end + function GdkContentFormats(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GdkContentFormats) end - push!(gboxed_types, GdkContentFormats) end + const GdkContentFormatsLike = GdkContentFormats end - mutable struct GdkContentFormatsBuilder <: GBoxed - handle::Ptr{GdkContentFormatsBuilder} - begin - (GLib.g_type(::Type{T}) where T <: GdkContentFormatsBuilder) = begin - ccall(("gdk_content_formats_builder_get_type", libgtk4), GType, ()) - end - function GdkContentFormatsBuilder(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GdkContentFormatsBuilder <: GBoxed + handle::Ptr{GdkContentFormatsBuilder} + begin + (GLib.g_type(::Type{T}) where T <: GdkContentFormatsBuilder) = begin + ccall(("gdk_content_formats_builder_get_type", libgtk4), GType, ()) end + function GdkContentFormatsBuilder(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GdkContentFormatsBuilder) end - push!(gboxed_types, GdkContentFormatsBuilder) end + const GdkContentFormatsBuilderLike = GdkContentFormatsBuilder end - mutable struct GdkDragSurfaceSize - handle::Ptr{GdkDragSurfaceSize} + begin + mutable struct GdkDragSurfaceSize + handle::Ptr{GdkDragSurfaceSize} + end + const GdkDragSurfaceSizeLike = GdkDragSurfaceSize end - mutable struct GdkEventSequence <: GBoxed - handle::Ptr{GdkEventSequence} - begin - (GLib.g_type(::Type{T}) where T <: GdkEventSequence) = begin - ccall(("gdk_event_sequence_get_type", libgtk4), GType, ()) - end - function GdkEventSequence(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GdkEventSequence <: GBoxed + handle::Ptr{GdkEventSequence} + begin + (GLib.g_type(::Type{T}) where T <: GdkEventSequence) = begin + ccall(("gdk_event_sequence_get_type", libgtk4), GType, ()) + end + function GdkEventSequence(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GdkEventSequence) end - push!(gboxed_types, GdkEventSequence) end + const GdkEventSequenceLike = GdkEventSequence end - mutable struct GdkFileList <: GBoxed - handle::Ptr{GdkFileList} - begin - (GLib.g_type(::Type{T}) where T <: GdkFileList) = begin - ccall(("gdk_file_list_get_type", libgtk4), GType, ()) - end - function GdkFileList(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GdkFileList <: GBoxed + handle::Ptr{GdkFileList} + begin + (GLib.g_type(::Type{T}) where T <: GdkFileList) = begin + ccall(("gdk_file_list_get_type", libgtk4), GType, ()) + end + function GdkFileList(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GdkFileList) end - push!(gboxed_types, GdkFileList) end + const GdkFileListLike = GdkFileList end - mutable struct GdkFrameTimings <: GBoxed - handle::Ptr{GdkFrameTimings} - begin - (GLib.g_type(::Type{T}) where T <: GdkFrameTimings) = begin - ccall(("gdk_frame_timings_get_type", libgtk4), GType, ()) - end - function GdkFrameTimings(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GdkFrameTimings <: GBoxed + handle::Ptr{GdkFrameTimings} + begin + (GLib.g_type(::Type{T}) where T <: GdkFrameTimings) = begin + ccall(("gdk_frame_timings_get_type", libgtk4), GType, ()) + end + function GdkFrameTimings(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GdkFrameTimings) end - push!(gboxed_types, GdkFrameTimings) end + const GdkFrameTimingsLike = GdkFrameTimings end begin struct _GdkKeymapKey @@ -110,25 +128,29 @@ $(Expr(:toplevel, quote convert(::Type{GdkKeymapKey}, p::Ptr{_GdkKeymapKey}, owns = false) = begin GdkKeymapKey(p, owns) end + const GdkKeymapKeyLike = Union{Ref{_GdkKeymapKey}, GdkKeymapKey} end end - mutable struct GdkPopupLayout <: GBoxed - handle::Ptr{GdkPopupLayout} - begin - (GLib.g_type(::Type{T}) where T <: GdkPopupLayout) = begin - ccall(("gdk_popup_layout_get_type", libgtk4), GType, ()) - end - function GdkPopupLayout(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GdkPopupLayout <: GBoxed + handle::Ptr{GdkPopupLayout} + begin + (GLib.g_type(::Type{T}) where T <: GdkPopupLayout) = begin + ccall(("gdk_popup_layout_get_type", libgtk4), GType, ()) end + function GdkPopupLayout(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GdkPopupLayout) end - push!(gboxed_types, GdkPopupLayout) end + const GdkPopupLayoutLike = GdkPopupLayout end begin struct _GdkRGBA @@ -162,6 +184,7 @@ $(Expr(:toplevel, quote convert(::Type{GdkRGBA}, p::Ptr{_GdkRGBA}, owns = false) = begin GdkRGBA(p, owns) end + const GdkRGBALike = Union{Ref{_GdkRGBA}, GdkRGBA} end end begin @@ -196,49 +219,57 @@ $(Expr(:toplevel, quote convert(::Type{GdkRectangle}, p::Ptr{_GdkRectangle}, owns = false) = begin GdkRectangle(p, owns) end + const GdkRectangleLike = Union{Ref{_GdkRectangle}, GdkRectangle} end end - mutable struct GdkTextureDownloader <: GBoxed - handle::Ptr{GdkTextureDownloader} - begin - (GLib.g_type(::Type{T}) where T <: GdkTextureDownloader) = begin - ccall(("gdk_texture_downloader_get_type", libgtk4), GType, ()) - end - function GdkTextureDownloader(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GdkTextureDownloader <: GBoxed + handle::Ptr{GdkTextureDownloader} + begin + (GLib.g_type(::Type{T}) where T <: GdkTextureDownloader) = begin + ccall(("gdk_texture_downloader_get_type", libgtk4), GType, ()) end + function GdkTextureDownloader(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GdkTextureDownloader) end - push!(gboxed_types, GdkTextureDownloader) end + const GdkTextureDownloaderLike = GdkTextureDownloader end begin mutable struct GdkTimeCoord handle::Ptr{GdkTimeCoord} end + const GdkTimeCoordLike = GdkTimeCoord const _GdkTimeCoord = GdkTimeCoord end - mutable struct GdkToplevelLayout <: GBoxed - handle::Ptr{GdkToplevelLayout} - begin - (GLib.g_type(::Type{T}) where T <: GdkToplevelLayout) = begin - ccall(("gdk_toplevel_layout_get_type", libgtk4), GType, ()) - end - function GdkToplevelLayout(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GdkToplevelLayout <: GBoxed + handle::Ptr{GdkToplevelLayout} + begin + (GLib.g_type(::Type{T}) where T <: GdkToplevelLayout) = begin + ccall(("gdk_toplevel_layout_get_type", libgtk4), GType, ()) end + function GdkToplevelLayout(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GdkToplevelLayout) end - push!(gboxed_types, GdkToplevelLayout) end + const GdkToplevelLayoutLike = GdkToplevelLayout end gboxed_cache_init() = begin append!(GLib.gboxed_types, gboxed_types) @@ -1082,7 +1113,7 @@ $(Expr(:toplevel, quote GLib.setproperties!(obj; kwargs...) obj end - function GdkContentProvider(_value::Union{GValue, Ref{_GValue}}; kwargs...) + function GdkContentProvider(_value::GValueLike; kwargs...) obj = G_.ContentProvider_new_for_value(_value) GLib.setproperties!(obj; kwargs...) obj @@ -1155,7 +1186,7 @@ $(Expr(:toplevel, quote function GdkFileList(_files::GLib.LList{GLib._GSList{Ptr{GObject}}}) G_.FileList_new_from_list(_files) end - function GdkPopupLayout(_anchor_rect::Union{GdkRectangle, Ref{_GdkRectangle}}, _rect_anchor, _surface_anchor) + function GdkPopupLayout(_anchor_rect::GdkRectangleLike, _rect_anchor, _surface_anchor) G_.PopupLayout_new(_anchor_rect, _rect_anchor, _surface_anchor) end function GdkTextureDownloader(_texture::GdkTexture) @@ -1314,6 +1345,6 @@ $(Expr(:toplevel, quote function on_images_updated(f, object::GdkVulkanContext, user_data = object, after = false) GLib.signal_connect_generic(f, object, "images-updated", Nothing, (), after, user_data) end - export GdkContentFormats, GdkContentFormatsBuilder, GdkDragSurfaceSize, GdkEventSequence, GdkFileList, GdkFrameTimings, GdkKeymapKey, _GdkKeymapKey, GdkPopupLayout, GdkRGBA, _GdkRGBA, GdkRectangle, _GdkRectangle, GdkTextureDownloader, GdkTimeCoord, _GdkTimeCoord, GdkToplevelLayout, GdkDevicePad, GdkDragSurface, GdkPaintable, GdkPopup, GdkToplevel, GdkAppLaunchContext, GdkAppLaunchContextLeaf, GdkButtonEvent, GdkButtonEventLeaf, GdkCairoContext, GdkClipboard, GdkClipboardLeaf, GdkContentDeserializer, GdkContentDeserializerLeaf, GdkContentProvider, GdkContentProviderLeaf, GdkContentSerializer, GdkContentSerializerLeaf, GdkCrossingEvent, GdkCrossingEventLeaf, GdkCursor, GdkCursorLeaf, GdkDNDEvent, GdkDNDEventLeaf, GdkDeleteEvent, GdkDeleteEventLeaf, GdkDevice, GdkDeviceTool, GdkDeviceToolLeaf, GdkDisplay, GdkDisplayLeaf, GdkDisplayManager, GdkDisplayManagerLeaf, GdkDrag, GdkDrawContext, GdkDrop, GdkEvent, GdkFocusEvent, GdkFocusEventLeaf, GdkFrameClock, GdkGLContext, GdkGLTexture, GdkGLTextureLeaf, GdkGLTextureBuilder, GdkGLTextureBuilderLeaf, GdkGrabBrokenEvent, GdkGrabBrokenEventLeaf, GdkKeyEvent, GdkKeyEventLeaf, GdkMemoryTexture, GdkMemoryTextureLeaf, GdkMonitor, GdkMonitorLeaf, GdkMotionEvent, GdkMotionEventLeaf, GdkPadEvent, GdkPadEventLeaf, GdkProximityEvent, GdkProximityEventLeaf, GdkScrollEvent, GdkScrollEventLeaf, GdkSeat, GdkSnapshot, GdkSurface, GdkTexture, GdkTouchEvent, GdkTouchEventLeaf, GdkTouchpadEvent, GdkTouchpadEventLeaf, GdkVulkanContext + export GdkContentFormats, GdkContentFormatsBuilder, GdkDragSurfaceSize, GdkEventSequence, GdkFileList, GdkFrameTimings, GdkKeymapKey, GdkKeymapKeyLike, _GdkKeymapKey, GdkPopupLayout, GdkRGBA, GdkRGBALike, _GdkRGBA, GdkRectangle, GdkRectangleLike, _GdkRectangle, GdkTextureDownloader, GdkTimeCoord, GdkTimeCoordLike, _GdkTimeCoord, GdkToplevelLayout, GdkDevicePad, GdkDragSurface, GdkPaintable, GdkPopup, GdkToplevel, GdkAppLaunchContext, GdkAppLaunchContextLeaf, GdkButtonEvent, GdkButtonEventLeaf, GdkCairoContext, GdkClipboard, GdkClipboardLeaf, GdkContentDeserializer, GdkContentDeserializerLeaf, GdkContentProvider, GdkContentProviderLeaf, GdkContentSerializer, GdkContentSerializerLeaf, GdkCrossingEvent, GdkCrossingEventLeaf, GdkCursor, GdkCursorLeaf, GdkDNDEvent, GdkDNDEventLeaf, GdkDeleteEvent, GdkDeleteEventLeaf, GdkDevice, GdkDeviceTool, GdkDeviceToolLeaf, GdkDisplay, GdkDisplayLeaf, GdkDisplayManager, GdkDisplayManagerLeaf, GdkDrag, GdkDrawContext, GdkDrop, GdkEvent, GdkFocusEvent, GdkFocusEventLeaf, GdkFrameClock, GdkGLContext, GdkGLTexture, GdkGLTextureLeaf, GdkGLTextureBuilder, GdkGLTextureBuilderLeaf, GdkGrabBrokenEvent, GdkGrabBrokenEventLeaf, GdkKeyEvent, GdkKeyEventLeaf, GdkMemoryTexture, GdkMemoryTextureLeaf, GdkMonitor, GdkMonitorLeaf, GdkMotionEvent, GdkMotionEventLeaf, GdkPadEvent, GdkPadEventLeaf, GdkProximityEvent, GdkProximityEventLeaf, GdkScrollEvent, GdkScrollEventLeaf, GdkSeat, GdkSnapshot, GdkSurface, GdkTexture, GdkTouchEvent, GdkTouchEventLeaf, GdkTouchpadEvent, GdkTouchpadEventLeaf, GdkVulkanContext end)) end diff --git a/src/gen/gdkpixbuf_methods b/src/gen/gdkpixbuf_methods index 86c7d1c0..f708acab 100644 --- a/src/gen/gdkpixbuf_methods +++ b/src/gen/gdkpixbuf_methods @@ -1,20 +1,20 @@ quote $(Expr(:toplevel, quote - function copy(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function copy(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_copy", libgdkpixbuf), Ptr{_GdkPixbufFormat}, (Ptr{_GdkPixbufFormat},), instance) - ret2 = convert(Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}, ret, true) + ret2 = convert(GdkPixbufFormatLike, ret, true) ret2 end - function free(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function free(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_free", libgdkpixbuf), Nothing, (Ptr{_GdkPixbufFormat},), instance) nothing end - function get_description(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function get_description(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_get_description", libgdkpixbuf), Cstring, (Ptr{_GdkPixbufFormat},), instance) ret2 = string_or_nothing(ret, true) ret2 end - function get_extensions(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function get_extensions(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_get_extensions", libgdkpixbuf), Ptr{Cstring}, (Ptr{_GdkPixbufFormat},), instance) ret2 = begin _len = length_zt(ret) @@ -24,12 +24,12 @@ $(Expr(:toplevel, quote end ret2 end - function get_license(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function get_license(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_get_license", libgdkpixbuf), Cstring, (Ptr{_GdkPixbufFormat},), instance) ret2 = string_or_nothing(ret, true) ret2 end - function get_mime_types(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function get_mime_types(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_get_mime_types", libgdkpixbuf), Ptr{Cstring}, (Ptr{_GdkPixbufFormat},), instance) ret2 = begin _len = length_zt(ret) @@ -39,32 +39,32 @@ $(Expr(:toplevel, quote end ret2 end - function get_name(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function get_name(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_get_name", libgdkpixbuf), Cstring, (Ptr{_GdkPixbufFormat},), instance) ret2 = string_or_nothing(ret, true) ret2 end - function is_disabled(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function is_disabled(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_is_disabled", libgdkpixbuf), Cint, (Ptr{_GdkPixbufFormat},), instance) ret2 = convert(Bool, ret) ret2 end - function is_save_option_supported(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}, _option_key::Union{AbstractString, Symbol}) + function is_save_option_supported(instance::GdkPixbufFormatLike, _option_key::Union{AbstractString, Symbol}) ret = ccall(("gdk_pixbuf_format_is_save_option_supported", libgdkpixbuf), Cint, (Ptr{_GdkPixbufFormat}, Cstring), instance, _option_key) ret2 = convert(Bool, ret) ret2 end - function is_scalable(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function is_scalable(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_is_scalable", libgdkpixbuf), Cint, (Ptr{_GdkPixbufFormat},), instance) ret2 = convert(Bool, ret) ret2 end - function is_writable(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}) + function is_writable(instance::GdkPixbufFormatLike) ret = ccall(("gdk_pixbuf_format_is_writable", libgdkpixbuf), Cint, (Ptr{_GdkPixbufFormat},), instance) ret2 = convert(Bool, ret) ret2 end - function set_disabled(instance::Union{GdkPixbufFormat, Ref{_GdkPixbufFormat}}, _disabled::Bool) + function set_disabled(instance::GdkPixbufFormatLike, _disabled::Bool) ret = ccall(("gdk_pixbuf_format_set_disabled", libgdkpixbuf), Nothing, (Ptr{_GdkPixbufFormat}, Cint), instance, _disabled) nothing end diff --git a/src/gen/gdkpixbuf_structs b/src/gen/gdkpixbuf_structs index 30a20d17..ca1716ca 100644 --- a/src/gen/gdkpixbuf_structs +++ b/src/gen/gdkpixbuf_structs @@ -17,6 +17,7 @@ $(Expr(:toplevel, quote convert(::Type{GdkPixbufModulePattern}, p::Ptr{_GdkPixbufModulePattern}, owns = false) = begin GdkPixbufModulePattern(p, owns) end + const GdkPixbufModulePatternLike = Union{Ref{_GdkPixbufModulePattern}, GdkPixbufModulePattern} end end begin @@ -56,6 +57,7 @@ $(Expr(:toplevel, quote convert(::Type{GdkPixbufFormat}, p::Ptr{_GdkPixbufFormat}, owns = false) = begin GdkPixbufFormat(p, owns) end + const GdkPixbufFormatLike = Union{Ref{_GdkPixbufFormat}, GdkPixbufFormat} end end gboxed_cache_init() = begin @@ -359,6 +361,6 @@ $(Expr(:toplevel, quote ret = f(buf, count, error) convert(Cint, ret) end - export GdkPixbufModulePattern, _GdkPixbufModulePattern, GdkPixbufFormat, _GdkPixbufFormat, GdkPixbuf, GdkPixbufLeaf, GdkPixbufAnimation, GdkPixbufAnimationLeaf, GdkPixbufAnimationIter, GdkPixbufAnimationIterLeaf, GdkPixbufLoader, GdkPixbufLoaderLeaf, GdkPixbufNonAnim, GdkPixbufNonAnimLeaf, GdkPixbufSimpleAnim, GdkPixbufSimpleAnimLeaf, GdkPixbufSimpleAnimIter, GdkPixbufSimpleAnimIterLeaf, GdkPixbufDestroyNotify, GdkPixbufModuleLoadXpmDataFunc, GdkPixbufModulePreparedFunc, GdkPixbufModuleSizeFunc, GdkPixbufModuleUpdatedFunc, GdkPixbufSaveFunc + export GdkPixbufModulePattern, _GdkPixbufModulePattern, GdkPixbufModulePatternLike, GdkPixbufFormat, GdkPixbufFormatLike, _GdkPixbufFormat, GdkPixbuf, GdkPixbufLeaf, GdkPixbufAnimation, GdkPixbufAnimationLeaf, GdkPixbufAnimationIter, GdkPixbufAnimationIterLeaf, GdkPixbufLoader, GdkPixbufLoaderLeaf, GdkPixbufNonAnim, GdkPixbufNonAnimLeaf, GdkPixbufSimpleAnim, GdkPixbufSimpleAnimLeaf, GdkPixbufSimpleAnimIter, GdkPixbufSimpleAnimIterLeaf, GdkPixbufDestroyNotify, GdkPixbufModuleLoadXpmDataFunc, GdkPixbufModulePreparedFunc, GdkPixbufModuleSizeFunc, GdkPixbufModuleUpdatedFunc, GdkPixbufSaveFunc end)) end diff --git a/src/gen/gio_functions b/src/gen/gio_functions index e4ba4f6e..7de6b10a 100644 --- a/src/gen/gio_functions +++ b/src/gen/gio_functions @@ -353,7 +353,7 @@ $(Expr(:toplevel, quote ret2 = string_or_nothing(ret, true) ret2 end - function dbus_gvalue_to_gvariant(_gvalue::Union{GValue, Ref{_GValue}}, _type::GVariantType) + function dbus_gvalue_to_gvariant(_gvalue::GValueLike, _type::GVariantType) ret = ccall(("g_dbus_gvalue_to_gvariant", libgio), Ptr{GVariant}, (Ptr{_GValue}, Ptr{GVariantType}), _gvalue, _type) ret2 = convert(GVariant, ret) ret2 @@ -601,14 +601,14 @@ $(Expr(:toplevel, quote end function pollable_source_new(_pollable_stream::GObject) ret = ccall(("g_pollable_source_new", libgio), Ptr{_GSource}, (Ptr{GObject},), _pollable_stream) - ret2 = convert(Union{GSource, Ref{_GSource}}, ret, true) + ret2 = convert(GSourceLike, ret, true) ret2 end - function pollable_source_new_full(_pollable_stream::GObject, _child_source::Maybe(Union{GSource, Ref{_GSource}}), _cancellable::Maybe(GCancellable)) + function pollable_source_new_full(_pollable_stream::GObject, _child_source::Maybe(GSourceLike), _cancellable::Maybe(GCancellable)) _child_source_maybe = nothing_to_null(_child_source) _cancellable_maybe = nothing_to_null(_cancellable) ret = ccall(("g_pollable_source_new_full", libgio), Ptr{_GSource}, (Ptr{GObject}, Ptr{_GSource}, Ptr{GObject}), _pollable_stream, _child_source_maybe, _cancellable_maybe) - ret2 = convert(Union{GSource, Ref{_GSource}}, ret, true) + ret2 = convert(GSourceLike, ret, true) ret2 end function pollable_stream_read(_stream::GInputStream, _buffer, _blocking::Bool, _cancellable::Maybe(GCancellable)) diff --git a/src/gen/gio_methods b/src/gen/gio_methods index cad5aa2d..ce65f65a 100644 --- a/src/gen/gio_methods +++ b/src/gen/gio_methods @@ -2,29 +2,29 @@ quote $(Expr(:toplevel, quote function FileAttributeInfoList_new() ret = ccall(("g_file_attribute_info_list_new", libgio), Ptr{_GFileAttributeInfoList}, ()) - ret2 = convert(Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}, ret, true) + ret2 = convert(GFileAttributeInfoListLike, ret, true) ret2 end - function add(instance::Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}, _name::Union{AbstractString, Symbol}, _type, _flags) + function add(instance::GFileAttributeInfoListLike, _name::Union{AbstractString, Symbol}, _type, _flags) ret = ccall(("g_file_attribute_info_list_add", libgio), Nothing, (Ptr{_GFileAttributeInfoList}, Cstring, UInt32, UInt32), instance, _name, _type, _flags) nothing end - function dup(instance::Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}) + function dup(instance::GFileAttributeInfoListLike) ret = ccall(("g_file_attribute_info_list_dup", libgio), Ptr{_GFileAttributeInfoList}, (Ptr{_GFileAttributeInfoList},), instance) - ret2 = convert(Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}, ret, true) + ret2 = convert(GFileAttributeInfoListLike, ret, true) ret2 end - function lookup(instance::Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}, _name::Union{AbstractString, Symbol}) + function lookup(instance::GFileAttributeInfoListLike, _name::Union{AbstractString, Symbol}) ret = ccall(("g_file_attribute_info_list_lookup", libgio), Ptr{_GFileAttributeInfo}, (Ptr{_GFileAttributeInfoList}, Cstring), instance, _name) - ret2 = convert(Union{GFileAttributeInfo, Ref{_GFileAttributeInfo}}, ret) + ret2 = convert(GFileAttributeInfoLike, ret) ret2 end - function ref(instance::Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}) + function ref(instance::GFileAttributeInfoListLike) ret = ccall(("g_file_attribute_info_list_ref", libgio), Ptr{_GFileAttributeInfoList}, (Ptr{_GFileAttributeInfoList},), instance) - ret2 = convert(Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}, ret, true) + ret2 = convert(GFileAttributeInfoListLike, ret, true) ret2 end - function unref(instance::Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}) + function unref(instance::GFileAttributeInfoListLike) ret = ccall(("g_file_attribute_info_list_unref", libgio), Nothing, (Ptr{_GFileAttributeInfoList},), instance) nothing end @@ -830,7 +830,7 @@ $(Expr(:toplevel, quote end function source_new(instance::GCancellable) ret = ccall(("g_cancellable_source_new", libgio), Ptr{_GSource}, (Ptr{GObject},), instance) - ret2 = convert(Union{GSource, Ref{_GSource}}, ret, true) + ret2 = convert(GSourceLike, ret, true) ret2 end function CharsetConverter_new(_to_charset::Union{AbstractString, Symbol}, _from_charset::Union{AbstractString, Symbol}) @@ -5906,7 +5906,7 @@ $(Expr(:toplevel, quote ret = ccall(("g_task_return_int", libgio), Nothing, (Ptr{GObject}, Int64), instance, _result) nothing end - function return_value(instance::GTask, _result::Maybe(Union{GValue, Ref{_GValue}})) + function return_value(instance::GTask, _result::Maybe(GValueLike)) _result_maybe = nothing_to_null(_result) ret = ccall(("g_task_return_value", libgio), Nothing, (Ptr{GObject}, Ptr{_GValue}), instance, _result_maybe) nothing @@ -6953,7 +6953,7 @@ $(Expr(:toplevel, quote function create_source(instance::GDatagramBased, _condition, _cancellable::Maybe(GCancellable)) _cancellable_maybe = nothing_to_null(_cancellable) ret = ccall(("g_datagram_based_create_source", libgio), Ptr{_GSource}, (Ptr{GObject}, UInt32, Ptr{GObject}), instance, _condition, _cancellable_maybe) - ret2 = convert(Union{GSource, Ref{_GSource}}, ret, true) + ret2 = convert(GSourceLike, ret, true) ret2 end function get_debug_enabled(instance::GDebugController) @@ -8049,7 +8049,7 @@ $(Expr(:toplevel, quote err = err_buf() ret = ccall(("g_file_query_settable_attributes", libgio), Ptr{_GFileAttributeInfoList}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err) check_err(err) - ret2 = convert(Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}, ret, true) + ret2 = convert(GFileAttributeInfoListLike, ret, true) ret2 end function query_writable_namespaces(instance::GFile, _cancellable::Maybe(GCancellable)) @@ -8057,7 +8057,7 @@ $(Expr(:toplevel, quote err = err_buf() ret = ccall(("g_file_query_writable_namespaces", libgio), Ptr{_GFileAttributeInfoList}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err) check_err(err) - ret2 = convert(Union{GFileAttributeInfoList, Ref{_GFileAttributeInfoList}}, ret, true) + ret2 = convert(GFileAttributeInfoListLike, ret, true) ret2 end function read(instance::GFile, _cancellable::Maybe(GCancellable)) @@ -8487,7 +8487,7 @@ $(Expr(:toplevel, quote function create_source(instance::GPollableInputStream, _cancellable::Maybe(GCancellable)) _cancellable_maybe = nothing_to_null(_cancellable) ret = ccall(("g_pollable_input_stream_create_source", libgio), Ptr{_GSource}, (Ptr{GObject}, Ptr{GObject}), instance, _cancellable_maybe) - ret2 = convert(Union{GSource, Ref{_GSource}}, ret, true) + ret2 = convert(GSourceLike, ret, true) ret2 end function is_readable(instance::GPollableInputStream) diff --git a/src/gen/gio_structs b/src/gen/gio_structs index fa0bb44b..8e5d890a 100644 --- a/src/gen/gio_structs +++ b/src/gen/gio_structs @@ -15,6 +15,7 @@ $(Expr(:toplevel, quote convert(::Type{GDBusErrorEntry}, p::Ptr{_GDBusErrorEntry}, owns = false) = begin GDBusErrorEntry(p, owns) end + const GDBusErrorEntryLike = Union{Ref{_GDBusErrorEntry}, GDBusErrorEntry} end end begin @@ -33,6 +34,7 @@ $(Expr(:toplevel, quote convert(::Type{GFileAttributeInfo}, p::Ptr{_GFileAttributeInfo}, owns = false) = begin GFileAttributeInfo(p, owns) end + const GFileAttributeInfoLike = Union{Ref{_GFileAttributeInfo}, GFileAttributeInfo} end end begin @@ -65,25 +67,29 @@ $(Expr(:toplevel, quote convert(::Type{GFileAttributeInfoList}, p::Ptr{_GFileAttributeInfoList}, owns = false) = begin GFileAttributeInfoList(p, owns) end + const GFileAttributeInfoListLike = Union{Ref{_GFileAttributeInfoList}, GFileAttributeInfoList} end end - mutable struct GFileAttributeMatcher <: GBoxed - handle::Ptr{GFileAttributeMatcher} - begin - (GLib.g_type(::Type{T}) where T <: GFileAttributeMatcher) = begin - ccall(("g_file_attribute_matcher_get_type", libgio), GType, ()) - end - function GFileAttributeMatcher(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GFileAttributeMatcher <: GBoxed + handle::Ptr{GFileAttributeMatcher} + begin + (GLib.g_type(::Type{T}) where T <: GFileAttributeMatcher) = begin + ccall(("g_file_attribute_matcher_get_type", libgio), GType, ()) end + function GFileAttributeMatcher(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GFileAttributeMatcher) end - push!(gboxed_types, GFileAttributeMatcher) end + const GFileAttributeMatcherLike = GFileAttributeMatcher end begin struct _GInputVector @@ -100,6 +106,7 @@ $(Expr(:toplevel, quote convert(::Type{GInputVector}, p::Ptr{_GInputVector}, owns = false) = begin GInputVector(p, owns) end + const GInputVectorLike = Union{Ref{_GInputVector}, GInputVector} end end begin @@ -117,97 +124,113 @@ $(Expr(:toplevel, quote convert(::Type{GOutputVector}, p::Ptr{_GOutputVector}, owns = false) = begin GOutputVector(p, owns) end + const GOutputVectorLike = Union{Ref{_GOutputVector}, GOutputVector} end end - mutable struct GResource <: GBoxed - handle::Ptr{GResource} - begin - (GLib.g_type(::Type{T}) where T <: GResource) = begin - ccall(("g_resource_get_type", libgio), GType, ()) - end - function GResource(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GResource <: GBoxed + handle::Ptr{GResource} + begin + (GLib.g_type(::Type{T}) where T <: GResource) = begin + ccall(("g_resource_get_type", libgio), GType, ()) + end + function GResource(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GResource) end - push!(gboxed_types, GResource) end + const GResourceLike = GResource end - mutable struct GSettingsSchema <: GBoxed - handle::Ptr{GSettingsSchema} - begin - (GLib.g_type(::Type{T}) where T <: GSettingsSchema) = begin - ccall(("g_settings_schema_get_type", libgio), GType, ()) - end - function GSettingsSchema(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GSettingsSchema <: GBoxed + handle::Ptr{GSettingsSchema} + begin + (GLib.g_type(::Type{T}) where T <: GSettingsSchema) = begin + ccall(("g_settings_schema_get_type", libgio), GType, ()) end + function GSettingsSchema(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GSettingsSchema) end - push!(gboxed_types, GSettingsSchema) end + const GSettingsSchemaLike = GSettingsSchema end - mutable struct GSettingsSchemaKey <: GBoxed - handle::Ptr{GSettingsSchemaKey} - begin - (GLib.g_type(::Type{T}) where T <: GSettingsSchemaKey) = begin - ccall(("g_settings_schema_key_get_type", libgio), GType, ()) - end - function GSettingsSchemaKey(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GSettingsSchemaKey <: GBoxed + handle::Ptr{GSettingsSchemaKey} + begin + (GLib.g_type(::Type{T}) where T <: GSettingsSchemaKey) = begin + ccall(("g_settings_schema_key_get_type", libgio), GType, ()) end + function GSettingsSchemaKey(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GSettingsSchemaKey) end - push!(gboxed_types, GSettingsSchemaKey) end + const GSettingsSchemaKeyLike = GSettingsSchemaKey end - mutable struct GSettingsSchemaSource <: GBoxed - handle::Ptr{GSettingsSchemaSource} - begin - (GLib.g_type(::Type{T}) where T <: GSettingsSchemaSource) = begin - ccall(("g_settings_schema_source_get_type", libgio), GType, ()) - end - function GSettingsSchemaSource(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GSettingsSchemaSource <: GBoxed + handle::Ptr{GSettingsSchemaSource} + begin + (GLib.g_type(::Type{T}) where T <: GSettingsSchemaSource) = begin + ccall(("g_settings_schema_source_get_type", libgio), GType, ()) + end + function GSettingsSchemaSource(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GSettingsSchemaSource) end - push!(gboxed_types, GSettingsSchemaSource) end + const GSettingsSchemaSourceLike = GSettingsSchemaSource end - mutable struct GSrvTarget <: GBoxed - handle::Ptr{GSrvTarget} - begin - (GLib.g_type(::Type{T}) where T <: GSrvTarget) = begin - ccall(("g_srv_target_get_type", libgio), GType, ()) - end - function GSrvTarget(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GSrvTarget <: GBoxed + handle::Ptr{GSrvTarget} + begin + (GLib.g_type(::Type{T}) where T <: GSrvTarget) = begin + ccall(("g_srv_target_get_type", libgio), GType, ()) end + function GSrvTarget(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GSrvTarget) end - push!(gboxed_types, GSrvTarget) end + const GSrvTargetLike = GSrvTarget end begin struct _GXdpDocumentsIface @@ -235,6 +258,7 @@ $(Expr(:toplevel, quote convert(::Type{GXdpDocumentsIface}, p::Ptr{_GXdpDocumentsIface}, owns = false) = begin GXdpDocumentsIface(p, owns) end + const GXdpDocumentsIfaceLike = Union{Ref{_GXdpDocumentsIface}, GXdpDocumentsIface} end end begin @@ -255,6 +279,7 @@ $(Expr(:toplevel, quote convert(::Type{GXdpOpenURIIface}, p::Ptr{_GXdpOpenURIIface}, owns = false) = begin GXdpOpenURIIface(p, owns) end + const GXdpOpenURIIfaceLike = Union{Ref{_GXdpOpenURIIface}, GXdpOpenURIIface} end end begin @@ -273,6 +298,7 @@ $(Expr(:toplevel, quote convert(::Type{GXdpProxyResolverIface}, p::Ptr{_GXdpProxyResolverIface}, owns = false) = begin GXdpProxyResolverIface(p, owns) end + const GXdpProxyResolverIfaceLike = Union{Ref{_GXdpProxyResolverIface}, GXdpProxyResolverIface} end end begin @@ -291,6 +317,7 @@ $(Expr(:toplevel, quote convert(::Type{GXdpTrashIface}, p::Ptr{_GXdpTrashIface}, owns = false) = begin GXdpTrashIface(p, owns) end + const GXdpTrashIfaceLike = Union{Ref{_GXdpTrashIface}, GXdpTrashIface} end end begin @@ -327,6 +354,7 @@ $(Expr(:toplevel, quote convert(::Type{G_FreedesktopDBusIface}, p::Ptr{_G_FreedesktopDBusIface}, owns = false) = begin G_FreedesktopDBusIface(p, owns) end + const G_FreedesktopDBusIfaceLike = Union{Ref{_G_FreedesktopDBusIface}, G_FreedesktopDBusIface} end end begin @@ -344,6 +372,7 @@ $(Expr(:toplevel, quote convert(::Type{G_FreedesktopDBusProxy}, p::Ptr{_G_FreedesktopDBusProxy}, owns = false) = begin G_FreedesktopDBusProxy(p, owns) end + const G_FreedesktopDBusProxyLike = Union{Ref{_G_FreedesktopDBusProxy}, G_FreedesktopDBusProxy} end end begin @@ -361,6 +390,7 @@ $(Expr(:toplevel, quote convert(::Type{G_FreedesktopDBusSkeleton}, p::Ptr{_G_FreedesktopDBusSkeleton}, owns = false) = begin G_FreedesktopDBusSkeleton(p, owns) end + const G_FreedesktopDBusSkeletonLike = Union{Ref{_G_FreedesktopDBusSkeleton}, G_FreedesktopDBusSkeleton} end end @doc "See the [GTK docs](https://docs.gtk.org/gio/struct.DBusErrorEntry.html)." GDBusErrorEntry @@ -4096,14 +4126,14 @@ $(Expr(:toplevel, quote convert(Cint, ret) end function GSettingsBindGetMapping(value, variant, user_data) - value = convert(Union{GValue, Ref{_GValue}}, value, false) + value = convert(GValueLike, value, false) variant = convert(GVariant, variant) f = user_data ret = f(value, variant) convert(Cint, ret) end function GSettingsBindSetMapping(value, expected_type, user_data) - value = convert(Union{GValue, Ref{_GValue}}, value, false) + value = convert(GValueLike, value, false) expected_type = convert(GVariantType, expected_type, false) f = user_data ret = f(value, expected_type) @@ -4136,6 +4166,6 @@ $(Expr(:toplevel, quote convert(Ptr{GObject}, GLib.get_pointer(ret)) end end - export GDBusErrorEntry, _GDBusErrorEntry, GFileAttributeInfo, _GFileAttributeInfo, GFileAttributeInfoList, _GFileAttributeInfoList, GFileAttributeMatcher, GInputVector, _GInputVector, GOutputVector, _GOutputVector, GResource, GSettingsSchema, GSettingsSchemaKey, GSettingsSchemaSource, GSrvTarget, GXdpDocumentsIface, _GXdpDocumentsIface, GXdpOpenURIIface, _GXdpOpenURIIface, GXdpProxyResolverIface, _GXdpProxyResolverIface, GXdpTrashIface, _GXdpTrashIface, G_FreedesktopDBusIface, _G_FreedesktopDBusIface, G_FreedesktopDBusProxy, _G_FreedesktopDBusProxy, G_FreedesktopDBusSkeleton, _G_FreedesktopDBusSkeleton, GAction, GActionGroup, GActionMap, GAppInfo, GAsyncInitable, GAsyncResult, GConverter, GDBusInterface, GDBusObject, GDBusObjectManager, GDatagramBased, GDebugController, GDrive, GDtlsClientConnection, GDtlsConnection, GDtlsServerConnection, GFile, GFileDescriptorBased, GIcon, GInitable, GListModel, GLoadableIcon, GMemoryMonitor, GMount, GNetworkMonitor, GPollableInputStream, GPollableOutputStream, GPowerProfileMonitor, GProxy, GProxyResolver, GRemoteActionGroup, GSeekable, GSocketConnectable, GTlsBackend, GTlsClientConnection, GTlsFileDatabase, GTlsServerConnection, GVolume, GAppInfoMonitor, GAppInfoMonitorLeaf, GAppLaunchContext, GAppLaunchContextLeaf, GApplication, GApplicationLeaf, GApplicationCommandLine, GApplicationCommandLineLeaf, GBufferedInputStream, GBufferedInputStreamLeaf, GBufferedOutputStream, GBufferedOutputStreamLeaf, GBytesIcon, GBytesIconLeaf, GCancellable, GCancellableLeaf, GCharsetConverter, GCharsetConverterLeaf, GConverterInputStream, GConverterInputStreamLeaf, GConverterOutputStream, GConverterOutputStreamLeaf, GCredentials, GCredentialsLeaf, GDBusActionGroup, GDBusActionGroupLeaf, GDBusAuthObserver, GDBusAuthObserverLeaf, GDBusConnection, GDBusConnectionLeaf, GDBusInterfaceSkeleton, GDBusMenuModel, GDBusMenuModelLeaf, GDBusMessage, GDBusMessageLeaf, GDBusMethodInvocation, GDBusMethodInvocationLeaf, GDBusObjectManagerClient, GDBusObjectManagerClientLeaf, GDBusObjectManagerServer, GDBusObjectManagerServerLeaf, GDBusObjectProxy, GDBusObjectProxyLeaf, GDBusObjectSkeleton, GDBusObjectSkeletonLeaf, GDBusProxy, GDBusProxyLeaf, GDBusServer, GDBusServerLeaf, GDataInputStream, GDataInputStreamLeaf, GDataOutputStream, GDataOutputStreamLeaf, GDesktopAppInfo, GDesktopAppInfoLeaf, GEmblem, GEmblemLeaf, GEmblemedIcon, GEmblemedIconLeaf, GFileEnumerator, GFileEnumeratorLeaf, GFileIOStream, GFileIOStreamLeaf, GFileIcon, GFileIconLeaf, GFileInfo, GFileInfoLeaf, GFileInputStream, GFileInputStreamLeaf, GFileMonitor, GFileOutputStream, GFileOutputStreamLeaf, GFilenameCompleter, GFilenameCompleterLeaf, GFilterInputStream, GFilterOutputStream, GIOModule, GIOModuleLeaf, GIOStream, GInetAddress, GInetAddressLeaf, GInetAddressMask, GInetAddressMaskLeaf, GInetSocketAddress, GInetSocketAddressLeaf, GInputStream, GListStore, GListStoreLeaf, GMemoryInputStream, GMemoryInputStreamLeaf, GMemoryOutputStream, GMemoryOutputStreamLeaf, GMenu, GMenuLeaf, GMenuAttributeIter, GMenuItem, GMenuItemLeaf, GMenuLinkIter, GMenuModel, GMountOperation, GMountOperationLeaf, GNativeSocketAddress, GNativeSocketAddressLeaf, GNativeVolumeMonitor, GNetworkAddress, GNetworkAddressLeaf, GNetworkService, GNetworkServiceLeaf, GNotification, GNotificationLeaf, GOutputStream, GPermission, GPropertyAction, GPropertyActionLeaf, GProxyAddress, GProxyAddressLeaf, GProxyAddressEnumerator, GProxyAddressEnumeratorLeaf, GResolver, GSettings, GSettingsLeaf, GSettingsBackend, GSimpleAction, GSimpleActionLeaf, GSimpleActionGroup, GSimpleActionGroupLeaf, GSimpleAsyncResult, GSimpleAsyncResultLeaf, GSimpleIOStream, GSimpleIOStreamLeaf, GSimplePermission, GSimplePermissionLeaf, GSimpleProxyResolver, GSimpleProxyResolverLeaf, GSocket, GSocketLeaf, GSocketAddress, GSocketAddressEnumerator, GSocketClient, GSocketClientLeaf, GSocketConnection, GSocketConnectionLeaf, GSocketControlMessage, GSocketListener, GSocketListenerLeaf, GSocketService, GSocketServiceLeaf, GSubprocess, GSubprocessLeaf, GSubprocessLauncher, GSubprocessLauncherLeaf, GTask, GTaskLeaf, GTcpConnection, GTcpConnectionLeaf, GTcpWrapperConnection, GTcpWrapperConnectionLeaf, GTestDBus, GTestDBusLeaf, GThemedIcon, GThemedIconLeaf, GThreadedResolver, GThreadedResolverLeaf, GThreadedSocketService, GThreadedSocketServiceLeaf, GTlsCertificate, GTlsConnection, GTlsDatabase, GTlsInteraction, GTlsInteractionLeaf, GTlsPassword, GTlsPasswordLeaf, GUnixConnection, GUnixConnectionLeaf, GUnixCredentialsMessage, GUnixCredentialsMessageLeaf, GVfs, GVfsLeaf, GVolumeMonitor, GVolumeMonitorLeaf, GZlibCompressor, GZlibCompressorLeaf, GZlibDecompressor, GZlibDecompressorLeaf, GAsyncReadyCallback, GBusAcquiredCallback, GBusNameAcquiredCallback, GBusNameAppearedCallback, GBusNameLostCallback, GBusNameVanishedCallback, GCancellableSourceFunc, GDBusInterfaceGetPropertyFunc, GDBusInterfaceMethodCallFunc, GDBusInterfaceSetPropertyFunc, GDBusMessageFilterFunction, GDBusProxyTypeFunc, GDBusSignalCallback, GDBusSubtreeDispatchFunc, GDBusSubtreeEnumerateFunc, GDBusSubtreeIntrospectFunc, GDatagramBasedSourceFunc, GDesktopAppLaunchCallback, GFileMeasureProgressCallback, GFileProgressCallback, GFileReadMoreCallback, GIOSchedulerJobFunc, GPollableSourceFunc, GSettingsBindGetMapping, GSettingsBindSetMapping, GSettingsGetMapping, GSocketSourceFunc, GVfsFileLookupFunc + export GDBusErrorEntry, GDBusErrorEntryLike, _GDBusErrorEntry, GFileAttributeInfo, GFileAttributeInfoLike, _GFileAttributeInfo, GFileAttributeInfoList, GFileAttributeInfoListLike, _GFileAttributeInfoList, GFileAttributeMatcher, GInputVector, GInputVectorLike, _GInputVector, GOutputVector, GOutputVectorLike, _GOutputVector, GResource, GSettingsSchema, GSettingsSchemaKey, GSettingsSchemaSource, GSrvTarget, GXdpDocumentsIface, GXdpDocumentsIfaceLike, _GXdpDocumentsIface, GXdpOpenURIIface, GXdpOpenURIIfaceLike, _GXdpOpenURIIface, GXdpProxyResolverIface, GXdpProxyResolverIfaceLike, _GXdpProxyResolverIface, GXdpTrashIface, GXdpTrashIfaceLike, _GXdpTrashIface, G_FreedesktopDBusIface, G_FreedesktopDBusIfaceLike, _G_FreedesktopDBusIface, G_FreedesktopDBusProxy, G_FreedesktopDBusProxyLike, _G_FreedesktopDBusProxy, G_FreedesktopDBusSkeleton, G_FreedesktopDBusSkeletonLike, _G_FreedesktopDBusSkeleton, GAction, GActionGroup, GActionMap, GAppInfo, GAsyncInitable, GAsyncResult, GConverter, GDBusInterface, GDBusObject, GDBusObjectManager, GDatagramBased, GDebugController, GDrive, GDtlsClientConnection, GDtlsConnection, GDtlsServerConnection, GFile, GFileDescriptorBased, GIcon, GInitable, GListModel, GLoadableIcon, GMemoryMonitor, GMount, GNetworkMonitor, GPollableInputStream, GPollableOutputStream, GPowerProfileMonitor, GProxy, GProxyResolver, GRemoteActionGroup, GSeekable, GSocketConnectable, GTlsBackend, GTlsClientConnection, GTlsFileDatabase, GTlsServerConnection, GVolume, GAppInfoMonitor, GAppInfoMonitorLeaf, GAppLaunchContext, GAppLaunchContextLeaf, GApplication, GApplicationLeaf, GApplicationCommandLine, GApplicationCommandLineLeaf, GBufferedInputStream, GBufferedInputStreamLeaf, GBufferedOutputStream, GBufferedOutputStreamLeaf, GBytesIcon, GBytesIconLeaf, GCancellable, GCancellableLeaf, GCharsetConverter, GCharsetConverterLeaf, GConverterInputStream, GConverterInputStreamLeaf, GConverterOutputStream, GConverterOutputStreamLeaf, GCredentials, GCredentialsLeaf, GDBusActionGroup, GDBusActionGroupLeaf, GDBusAuthObserver, GDBusAuthObserverLeaf, GDBusConnection, GDBusConnectionLeaf, GDBusInterfaceSkeleton, GDBusMenuModel, GDBusMenuModelLeaf, GDBusMessage, GDBusMessageLeaf, GDBusMethodInvocation, GDBusMethodInvocationLeaf, GDBusObjectManagerClient, GDBusObjectManagerClientLeaf, GDBusObjectManagerServer, GDBusObjectManagerServerLeaf, GDBusObjectProxy, GDBusObjectProxyLeaf, GDBusObjectSkeleton, GDBusObjectSkeletonLeaf, GDBusProxy, GDBusProxyLeaf, GDBusServer, GDBusServerLeaf, GDataInputStream, GDataInputStreamLeaf, GDataOutputStream, GDataOutputStreamLeaf, GDesktopAppInfo, GDesktopAppInfoLeaf, GEmblem, GEmblemLeaf, GEmblemedIcon, GEmblemedIconLeaf, GFileEnumerator, GFileEnumeratorLeaf, GFileIOStream, GFileIOStreamLeaf, GFileIcon, GFileIconLeaf, GFileInfo, GFileInfoLeaf, GFileInputStream, GFileInputStreamLeaf, GFileMonitor, GFileOutputStream, GFileOutputStreamLeaf, GFilenameCompleter, GFilenameCompleterLeaf, GFilterInputStream, GFilterOutputStream, GIOModule, GIOModuleLeaf, GIOStream, GInetAddress, GInetAddressLeaf, GInetAddressMask, GInetAddressMaskLeaf, GInetSocketAddress, GInetSocketAddressLeaf, GInputStream, GListStore, GListStoreLeaf, GMemoryInputStream, GMemoryInputStreamLeaf, GMemoryOutputStream, GMemoryOutputStreamLeaf, GMenu, GMenuLeaf, GMenuAttributeIter, GMenuItem, GMenuItemLeaf, GMenuLinkIter, GMenuModel, GMountOperation, GMountOperationLeaf, GNativeSocketAddress, GNativeSocketAddressLeaf, GNativeVolumeMonitor, GNetworkAddress, GNetworkAddressLeaf, GNetworkService, GNetworkServiceLeaf, GNotification, GNotificationLeaf, GOutputStream, GPermission, GPropertyAction, GPropertyActionLeaf, GProxyAddress, GProxyAddressLeaf, GProxyAddressEnumerator, GProxyAddressEnumeratorLeaf, GResolver, GSettings, GSettingsLeaf, GSettingsBackend, GSimpleAction, GSimpleActionLeaf, GSimpleActionGroup, GSimpleActionGroupLeaf, GSimpleAsyncResult, GSimpleAsyncResultLeaf, GSimpleIOStream, GSimpleIOStreamLeaf, GSimplePermission, GSimplePermissionLeaf, GSimpleProxyResolver, GSimpleProxyResolverLeaf, GSocket, GSocketLeaf, GSocketAddress, GSocketAddressEnumerator, GSocketClient, GSocketClientLeaf, GSocketConnection, GSocketConnectionLeaf, GSocketControlMessage, GSocketListener, GSocketListenerLeaf, GSocketService, GSocketServiceLeaf, GSubprocess, GSubprocessLeaf, GSubprocessLauncher, GSubprocessLauncherLeaf, GTask, GTaskLeaf, GTcpConnection, GTcpConnectionLeaf, GTcpWrapperConnection, GTcpWrapperConnectionLeaf, GTestDBus, GTestDBusLeaf, GThemedIcon, GThemedIconLeaf, GThreadedResolver, GThreadedResolverLeaf, GThreadedSocketService, GThreadedSocketServiceLeaf, GTlsCertificate, GTlsConnection, GTlsDatabase, GTlsInteraction, GTlsInteractionLeaf, GTlsPassword, GTlsPasswordLeaf, GUnixConnection, GUnixConnectionLeaf, GUnixCredentialsMessage, GUnixCredentialsMessageLeaf, GVfs, GVfsLeaf, GVolumeMonitor, GVolumeMonitorLeaf, GZlibCompressor, GZlibCompressorLeaf, GZlibDecompressor, GZlibDecompressorLeaf, GAsyncReadyCallback, GBusAcquiredCallback, GBusNameAcquiredCallback, GBusNameAppearedCallback, GBusNameLostCallback, GBusNameVanishedCallback, GCancellableSourceFunc, GDBusInterfaceGetPropertyFunc, GDBusInterfaceMethodCallFunc, GDBusInterfaceSetPropertyFunc, GDBusMessageFilterFunction, GDBusProxyTypeFunc, GDBusSignalCallback, GDBusSubtreeDispatchFunc, GDBusSubtreeEnumerateFunc, GDBusSubtreeIntrospectFunc, GDatagramBasedSourceFunc, GDesktopAppLaunchCallback, GFileMeasureProgressCallback, GFileProgressCallback, GFileReadMoreCallback, GIOSchedulerJobFunc, GPollableSourceFunc, GSettingsBindGetMapping, GSettingsBindSetMapping, GSettingsGetMapping, GSocketSourceFunc, GVfsFileLookupFunc end)) end diff --git a/src/gen/glib_methods b/src/gen/glib_methods index 6f8371cd..0e20ddf9 100644 --- a/src/gen/glib_methods +++ b/src/gen/glib_methods @@ -385,153 +385,153 @@ $(Expr(:toplevel, quote end function Date_new() ret = ccall(("g_date_new", libglib), Ptr{_GDate}, ()) - ret2 = convert(Union{GDate, Ref{_GDate}}, ret, true) + ret2 = convert(GDateLike, ret, true) ret2 end function Date_new_dmy(_day::Integer, _month, _year::Integer) ret = ccall(("g_date_new_dmy", libglib), Ptr{_GDate}, (UInt8, UInt32, UInt16), _day, _month, _year) - ret2 = convert(Union{GDate, Ref{_GDate}}, ret, true) + ret2 = convert(GDateLike, ret, true) ret2 end function Date_new_julian(_julian_day::Integer) ret = ccall(("g_date_new_julian", libglib), Ptr{_GDate}, (UInt32,), _julian_day) - ret2 = convert(Union{GDate, Ref{_GDate}}, ret, true) + ret2 = convert(GDateLike, ret, true) ret2 end - function add_days(instance::Union{GDate, Ref{_GDate}}, _n_days::Integer) + function add_days(instance::GDateLike, _n_days::Integer) ret = ccall(("g_date_add_days", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_days) nothing end - function add_months(instance::Union{GDate, Ref{_GDate}}, _n_months::Integer) + function add_months(instance::GDateLike, _n_months::Integer) ret = ccall(("g_date_add_months", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_months) nothing end - function add_years(instance::Union{GDate, Ref{_GDate}}, _n_years::Integer) + function add_years(instance::GDateLike, _n_years::Integer) ret = ccall(("g_date_add_years", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_years) nothing end - function clamp(instance::Union{GDate, Ref{_GDate}}, _min_date::Union{GDate, Ref{_GDate}}, _max_date::Union{GDate, Ref{_GDate}}) + function clamp(instance::GDateLike, _min_date::GDateLike, _max_date::GDateLike) ret = ccall(("g_date_clamp", libglib), Nothing, (Ptr{_GDate}, Ptr{_GDate}, Ptr{_GDate}), instance, _min_date, _max_date) nothing end - function clear(instance::Union{GDate, Ref{_GDate}}, _n_dates::Integer) + function clear(instance::GDateLike, _n_dates::Integer) ret = ccall(("g_date_clear", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_dates) nothing end - function compare(instance::Union{GDate, Ref{_GDate}}, _rhs::Union{GDate, Ref{_GDate}}) + function compare(instance::GDateLike, _rhs::GDateLike) ret = ccall(("g_date_compare", libglib), Int32, (Ptr{_GDate}, Ptr{_GDate}), instance, _rhs) ret end - function copy(instance::Union{GDate, Ref{_GDate}}) + function copy(instance::GDateLike) ret = ccall(("g_date_copy", libglib), Ptr{_GDate}, (Ptr{_GDate},), instance) - ret2 = convert(Union{GDate, Ref{_GDate}}, ret, true) + ret2 = convert(GDateLike, ret, true) ret2 end - function days_between(instance::Union{GDate, Ref{_GDate}}, _date2::Union{GDate, Ref{_GDate}}) + function days_between(instance::GDateLike, _date2::GDateLike) ret = ccall(("g_date_days_between", libglib), Int32, (Ptr{_GDate}, Ptr{_GDate}), instance, _date2) ret end - function free(instance::Union{GDate, Ref{_GDate}}) + function free(instance::GDateLike) ret = ccall(("g_date_free", libglib), Nothing, (Ptr{_GDate},), instance) nothing end - function get_day(instance::Union{GDate, Ref{_GDate}}) + function get_day(instance::GDateLike) ret = ccall(("g_date_get_day", libglib), UInt8, (Ptr{_GDate},), instance) ret end - function get_day_of_year(instance::Union{GDate, Ref{_GDate}}) + function get_day_of_year(instance::GDateLike) ret = ccall(("g_date_get_day_of_year", libglib), UInt32, (Ptr{_GDate},), instance) ret end - function get_iso8601_week_of_year(instance::Union{GDate, Ref{_GDate}}) + function get_iso8601_week_of_year(instance::GDateLike) ret = ccall(("g_date_get_iso8601_week_of_year", libglib), UInt32, (Ptr{_GDate},), instance) ret end - function get_julian(instance::Union{GDate, Ref{_GDate}}) + function get_julian(instance::GDateLike) ret = ccall(("g_date_get_julian", libglib), UInt32, (Ptr{_GDate},), instance) ret end - function get_monday_week_of_year(instance::Union{GDate, Ref{_GDate}}) + function get_monday_week_of_year(instance::GDateLike) ret = ccall(("g_date_get_monday_week_of_year", libglib), UInt32, (Ptr{_GDate},), instance) ret end - function get_month(instance::Union{GDate, Ref{_GDate}}) + function get_month(instance::GDateLike) ret = ccall(("g_date_get_month", libglib), UInt32, (Ptr{_GDate},), instance) ret2 = DateMonth(ret) ret2 end - function get_sunday_week_of_year(instance::Union{GDate, Ref{_GDate}}) + function get_sunday_week_of_year(instance::GDateLike) ret = ccall(("g_date_get_sunday_week_of_year", libglib), UInt32, (Ptr{_GDate},), instance) ret end - function get_weekday(instance::Union{GDate, Ref{_GDate}}) + function get_weekday(instance::GDateLike) ret = ccall(("g_date_get_weekday", libglib), UInt32, (Ptr{_GDate},), instance) ret2 = DateWeekday(ret) ret2 end - function get_year(instance::Union{GDate, Ref{_GDate}}) + function get_year(instance::GDateLike) ret = ccall(("g_date_get_year", libglib), UInt16, (Ptr{_GDate},), instance) ret end - function is_first_of_month(instance::Union{GDate, Ref{_GDate}}) + function is_first_of_month(instance::GDateLike) ret = ccall(("g_date_is_first_of_month", libglib), Cint, (Ptr{_GDate},), instance) ret2 = convert(Bool, ret) ret2 end - function is_last_of_month(instance::Union{GDate, Ref{_GDate}}) + function is_last_of_month(instance::GDateLike) ret = ccall(("g_date_is_last_of_month", libglib), Cint, (Ptr{_GDate},), instance) ret2 = convert(Bool, ret) ret2 end - function order(instance::Union{GDate, Ref{_GDate}}, _date2::Union{GDate, Ref{_GDate}}) + function order(instance::GDateLike, _date2::GDateLike) ret = ccall(("g_date_order", libglib), Nothing, (Ptr{_GDate}, Ptr{_GDate}), instance, _date2) nothing end - function set_day(instance::Union{GDate, Ref{_GDate}}, _day::Integer) + function set_day(instance::GDateLike, _day::Integer) ret = ccall(("g_date_set_day", libglib), Nothing, (Ptr{_GDate}, UInt8), instance, _day) nothing end - function set_dmy(instance::Union{GDate, Ref{_GDate}}, _day::Integer, _month, _y::Integer) + function set_dmy(instance::GDateLike, _day::Integer, _month, _y::Integer) ret = ccall(("g_date_set_dmy", libglib), Nothing, (Ptr{_GDate}, UInt8, UInt32, UInt16), instance, _day, _month, _y) nothing end - function set_julian(instance::Union{GDate, Ref{_GDate}}, _julian_date::Integer) + function set_julian(instance::GDateLike, _julian_date::Integer) ret = ccall(("g_date_set_julian", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _julian_date) nothing end - function set_month(instance::Union{GDate, Ref{_GDate}}, _month) + function set_month(instance::GDateLike, _month) ret = ccall(("g_date_set_month", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _month) nothing end - function set_parse(instance::Union{GDate, Ref{_GDate}}, _str::Union{AbstractString, Symbol}) + function set_parse(instance::GDateLike, _str::Union{AbstractString, Symbol}) ret = ccall(("g_date_set_parse", libglib), Nothing, (Ptr{_GDate}, Cstring), instance, _str) nothing end - function set_time_t(instance::Union{GDate, Ref{_GDate}}, _timet::Integer) + function set_time_t(instance::GDateLike, _timet::Integer) ret = ccall(("g_date_set_time_t", libglib), Nothing, (Ptr{_GDate}, Int64), instance, _timet) nothing end - function set_year(instance::Union{GDate, Ref{_GDate}}, _year::Integer) + function set_year(instance::GDateLike, _year::Integer) ret = ccall(("g_date_set_year", libglib), Nothing, (Ptr{_GDate}, UInt16), instance, _year) nothing end - function subtract_days(instance::Union{GDate, Ref{_GDate}}, _n_days::Integer) + function subtract_days(instance::GDateLike, _n_days::Integer) ret = ccall(("g_date_subtract_days", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_days) nothing end - function subtract_months(instance::Union{GDate, Ref{_GDate}}, _n_months::Integer) + function subtract_months(instance::GDateLike, _n_months::Integer) ret = ccall(("g_date_subtract_months", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_months) nothing end - function subtract_years(instance::Union{GDate, Ref{_GDate}}, _n_years::Integer) + function subtract_years(instance::GDateLike, _n_years::Integer) ret = ccall(("g_date_subtract_years", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_years) nothing end - function to_struct_tm(instance::Union{GDate, Ref{_GDate}}, _tm::Nothing) + function to_struct_tm(instance::GDateLike, _tm::Nothing) ret = ccall(("g_date_to_struct_tm", libglib), Nothing, (Ptr{_GDate}, Ptr{Nothing}), instance, _tm) nothing end - function valid(instance::Union{GDate, Ref{_GDate}}) + function valid(instance::GDateLike) ret = ccall(("g_date_valid", libglib), Cint, (Ptr{_GDate},), instance) ret2 = convert(Bool, ret) ret2 @@ -1480,156 +1480,156 @@ $(Expr(:toplevel, quote function String_new(_init::Maybe(Union{AbstractString, Symbol})) _init_maybe = nothing_to_null(_init) ret = ccall(("g_string_new", libglib), Ptr{_GString}, (Cstring,), _init_maybe) - ret2 = convert(Union{GString, Ref{_GString}}, ret, true) + ret2 = convert(GStringLike, ret, true) ret2 end function String_new_len(_init::Union{AbstractString, Symbol}, _len::Integer) ret = ccall(("g_string_new_len", libglib), Ptr{_GString}, (Cstring, Int64), _init, _len) - ret2 = convert(Union{GString, Ref{_GString}}, ret, true) + ret2 = convert(GStringLike, ret, true) ret2 end function String_new_take(_init::Maybe(Union{AbstractString, Symbol})) _init_maybe = nothing_to_null(_init) ret = ccall(("g_string_new_take", libglib), Ptr{_GString}, (Cstring,), _init_maybe) - ret2 = convert(Union{GString, Ref{_GString}}, ret, true) + ret2 = convert(GStringLike, ret, true) ret2 end function String_sized_new(_dfl_size::Integer) ret = ccall(("g_string_sized_new", libglib), Ptr{_GString}, (UInt64,), _dfl_size) - ret2 = convert(Union{GString, Ref{_GString}}, ret, true) + ret2 = convert(GStringLike, ret, true) ret2 end - function append(instance::Union{GString, Ref{_GString}}, _val::Union{AbstractString, Symbol}) + function append(instance::GStringLike, _val::Union{AbstractString, Symbol}) ret = ccall(("g_string_append", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring), instance, _val) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function append_c(instance::Union{GString, Ref{_GString}}, _c::Integer) + function append_c(instance::GStringLike, _c::Integer) ret = ccall(("g_string_append_c", libglib), Ptr{_GString}, (Ptr{_GString}, Int8), instance, _c) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function append_len(instance::Union{GString, Ref{_GString}}, _val::Union{AbstractString, Symbol}, _len::Integer) + function append_len(instance::GStringLike, _val::Union{AbstractString, Symbol}, _len::Integer) ret = ccall(("g_string_append_len", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring, Int64), instance, _val, _len) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function append_unichar(instance::Union{GString, Ref{_GString}}, _wc) + function append_unichar(instance::GStringLike, _wc) ret = ccall(("g_string_append_unichar", libglib), Ptr{_GString}, (Ptr{_GString}, Nothing), instance, _wc) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function append_uri_escaped(instance::Union{GString, Ref{_GString}}, _unescaped::Union{AbstractString, Symbol}, _reserved_chars_allowed::Union{AbstractString, Symbol}, _allow_utf8::Bool) + function append_uri_escaped(instance::GStringLike, _unescaped::Union{AbstractString, Symbol}, _reserved_chars_allowed::Union{AbstractString, Symbol}, _allow_utf8::Bool) ret = ccall(("g_string_append_uri_escaped", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring, Cstring, Cint), instance, _unescaped, _reserved_chars_allowed, _allow_utf8) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function ascii_down(instance::Union{GString, Ref{_GString}}) + function ascii_down(instance::GStringLike) ret = ccall(("g_string_ascii_down", libglib), Ptr{_GString}, (Ptr{_GString},), instance) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function ascii_up(instance::Union{GString, Ref{_GString}}) + function ascii_up(instance::GStringLike) ret = ccall(("g_string_ascii_up", libglib), Ptr{_GString}, (Ptr{_GString},), instance) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function assign(instance::Union{GString, Ref{_GString}}, _rval::Union{AbstractString, Symbol}) + function assign(instance::GStringLike, _rval::Union{AbstractString, Symbol}) ret = ccall(("g_string_assign", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring), instance, _rval) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function equal(instance::Union{GString, Ref{_GString}}, _v2::Union{GString, Ref{_GString}}) + function equal(instance::GStringLike, _v2::GStringLike) ret = ccall(("g_string_equal", libglib), Cint, (Ptr{_GString}, Ptr{_GString}), instance, _v2) ret2 = convert(Bool, ret) ret2 end - function erase(instance::Union{GString, Ref{_GString}}, _pos::Integer, _len::Integer) + function erase(instance::GStringLike, _pos::Integer, _len::Integer) ret = ccall(("g_string_erase", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Int64), instance, _pos, _len) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function free(instance::Union{GString, Ref{_GString}}, _free_segment::Bool) + function free(instance::GStringLike, _free_segment::Bool) ret = ccall(("g_string_free", libglib), Cstring, (Ptr{_GString}, Cint), instance, _free_segment) ret2 = string_or_nothing(ret, true) ret2 end - function free_and_steal(instance::Union{GString, Ref{_GString}}) + function free_and_steal(instance::GStringLike) ret = ccall(("g_string_free_and_steal", libglib), Cstring, (Ptr{_GString},), instance) ret2 = string_or_nothing(ret, true) ret2 end - function free_to_bytes(instance::Union{GString, Ref{_GString}}) + function free_to_bytes(instance::GStringLike) ret = ccall(("g_string_free_to_bytes", libglib), Ptr{GBytes}, (Ptr{_GString},), instance) ret2 = convert(GBytes, ret, true) ret2 end - function hash(instance::Union{GString, Ref{_GString}}) + function hash(instance::GStringLike) ret = ccall(("g_string_hash", libglib), UInt32, (Ptr{_GString},), instance) ret end - function insert(instance::Union{GString, Ref{_GString}}, _pos::Integer, _val::Union{AbstractString, Symbol}) + function insert(instance::GStringLike, _pos::Integer, _val::Union{AbstractString, Symbol}) ret = ccall(("g_string_insert", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Cstring), instance, _pos, _val) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function insert_c(instance::Union{GString, Ref{_GString}}, _pos::Integer, _c::Integer) + function insert_c(instance::GStringLike, _pos::Integer, _c::Integer) ret = ccall(("g_string_insert_c", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Int8), instance, _pos, _c) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function insert_len(instance::Union{GString, Ref{_GString}}, _pos::Integer, _val::Union{AbstractString, Symbol}, _len::Integer) + function insert_len(instance::GStringLike, _pos::Integer, _val::Union{AbstractString, Symbol}, _len::Integer) ret = ccall(("g_string_insert_len", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Cstring, Int64), instance, _pos, _val, _len) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function insert_unichar(instance::Union{GString, Ref{_GString}}, _pos::Integer, _wc) + function insert_unichar(instance::GStringLike, _pos::Integer, _wc) ret = ccall(("g_string_insert_unichar", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Nothing), instance, _pos, _wc) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function overwrite(instance::Union{GString, Ref{_GString}}, _pos::Integer, _val::Union{AbstractString, Symbol}) + function overwrite(instance::GStringLike, _pos::Integer, _val::Union{AbstractString, Symbol}) ret = ccall(("g_string_overwrite", libglib), Ptr{_GString}, (Ptr{_GString}, UInt64, Cstring), instance, _pos, _val) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function overwrite_len(instance::Union{GString, Ref{_GString}}, _pos::Integer, _val::Union{AbstractString, Symbol}, _len::Integer) + function overwrite_len(instance::GStringLike, _pos::Integer, _val::Union{AbstractString, Symbol}, _len::Integer) ret = ccall(("g_string_overwrite_len", libglib), Ptr{_GString}, (Ptr{_GString}, UInt64, Cstring, Int64), instance, _pos, _val, _len) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function prepend(instance::Union{GString, Ref{_GString}}, _val::Union{AbstractString, Symbol}) + function prepend(instance::GStringLike, _val::Union{AbstractString, Symbol}) ret = ccall(("g_string_prepend", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring), instance, _val) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function prepend_c(instance::Union{GString, Ref{_GString}}, _c::Integer) + function prepend_c(instance::GStringLike, _c::Integer) ret = ccall(("g_string_prepend_c", libglib), Ptr{_GString}, (Ptr{_GString}, Int8), instance, _c) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function prepend_len(instance::Union{GString, Ref{_GString}}, _val::Union{AbstractString, Symbol}, _len::Integer) + function prepend_len(instance::GStringLike, _val::Union{AbstractString, Symbol}, _len::Integer) ret = ccall(("g_string_prepend_len", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring, Int64), instance, _val, _len) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function prepend_unichar(instance::Union{GString, Ref{_GString}}, _wc) + function prepend_unichar(instance::GStringLike, _wc) ret = ccall(("g_string_prepend_unichar", libglib), Ptr{_GString}, (Ptr{_GString}, Nothing), instance, _wc) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function replace(instance::Union{GString, Ref{_GString}}, _find::Union{AbstractString, Symbol}, _replace::Union{AbstractString, Symbol}, _limit::Integer) + function replace(instance::GStringLike, _find::Union{AbstractString, Symbol}, _replace::Union{AbstractString, Symbol}, _limit::Integer) ret = ccall(("g_string_replace", libglib), UInt32, (Ptr{_GString}, Cstring, Cstring, UInt32), instance, _find, _replace, _limit) ret end - function set_size(instance::Union{GString, Ref{_GString}}, _len::Integer) + function set_size(instance::GStringLike, _len::Integer) ret = ccall(("g_string_set_size", libglib), Ptr{_GString}, (Ptr{_GString}, UInt64), instance, _len) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end - function truncate(instance::Union{GString, Ref{_GString}}, _len::Integer) + function truncate(instance::GStringLike, _len::Integer) ret = ccall(("g_string_truncate", libglib), Ptr{_GString}, (Ptr{_GString}, UInt64), instance, _len) - ret2 = convert(Union{GString, Ref{_GString}}, ret, false) + ret2 = convert(GStringLike, ret, false) ret2 end function TimeZone_new_identifier(_identifier::Maybe(Union{AbstractString, Symbol})) diff --git a/src/gen/glib_structs b/src/gen/glib_structs index 11ebd63f..8313182a 100644 --- a/src/gen/glib_structs +++ b/src/gen/glib_structs @@ -1,58 +1,67 @@ quote $(Expr(:toplevel, quote - mutable struct GBookmarkFile <: GBoxed - handle::Ptr{GBookmarkFile} - begin - (GLib.g_type(::Type{T}) where T <: GBookmarkFile) = begin - ccall(("g_bookmark_file_get_type", libgobject), GType, ()) - end - function GBookmarkFile(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GBookmarkFile <: GBoxed + handle::Ptr{GBookmarkFile} + begin + (GLib.g_type(::Type{T}) where T <: GBookmarkFile) = begin + ccall(("g_bookmark_file_get_type", libgobject), GType, ()) + end + function GBookmarkFile(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GBookmarkFile) end - push!(gboxed_types, GBookmarkFile) end + const GBookmarkFileLike = GBookmarkFile end - mutable struct GBytes <: GBoxed - handle::Ptr{GBytes} - begin - (GLib.g_type(::Type{T}) where T <: GBytes) = begin - ccall(("g_bytes_get_type", libgobject), GType, ()) - end - function GBytes(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GBytes <: GBoxed + handle::Ptr{GBytes} + begin + (GLib.g_type(::Type{T}) where T <: GBytes) = begin + ccall(("g_bytes_get_type", libgobject), GType, ()) + end + function GBytes(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GBytes) end - push!(gboxed_types, GBytes) end + const GBytesLike = GBytes end - mutable struct GChecksum <: GBoxed - handle::Ptr{GChecksum} - begin - (GLib.g_type(::Type{T}) where T <: GChecksum) = begin - ccall(("g_checksum_get_type", libgobject), GType, ()) - end - function GChecksum(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GChecksum <: GBoxed + handle::Ptr{GChecksum} + begin + (GLib.g_type(::Type{T}) where T <: GChecksum) = begin + ccall(("g_checksum_get_type", libgobject), GType, ()) + end + function GChecksum(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GChecksum) end - push!(gboxed_types, GChecksum) end + const GChecksumLike = GChecksum end begin mutable struct GDate <: GBoxed @@ -73,25 +82,29 @@ $(Expr(:toplevel, quote push!(gboxed_types, GDate) end end + const GDateLike = GDate const _GDate = GDate end - mutable struct GDateTime <: GBoxed - handle::Ptr{GDateTime} - begin - (GLib.g_type(::Type{T}) where T <: GDateTime) = begin - ccall(("g_date_time_get_type", libgobject), GType, ()) - end - function GDateTime(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GDateTime <: GBoxed + handle::Ptr{GDateTime} + begin + (GLib.g_type(::Type{T}) where T <: GDateTime) = begin + ccall(("g_date_time_get_type", libgobject), GType, ()) end + function GDateTime(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GDateTime) end - push!(gboxed_types, GDateTime) end + const GDateTimeLike = GDateTime end begin struct _GDebugKey @@ -108,25 +121,29 @@ $(Expr(:toplevel, quote convert(::Type{GDebugKey}, p::Ptr{_GDebugKey}, owns = false) = begin GDebugKey(p, owns) end + const GDebugKeyLike = Union{Ref{_GDebugKey}, GDebugKey} end end - mutable struct GKeyFile <: GBoxed - handle::Ptr{GKeyFile} - begin - (GLib.g_type(::Type{T}) where T <: GKeyFile) = begin - ccall(("g_key_file_get_type", libgobject), GType, ()) - end - function GKeyFile(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GKeyFile <: GBoxed + handle::Ptr{GKeyFile} + begin + (GLib.g_type(::Type{T}) where T <: GKeyFile) = begin + ccall(("g_key_file_get_type", libgobject), GType, ()) + end + function GKeyFile(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GKeyFile) end - push!(gboxed_types, GKeyFile) end + const GKeyFileLike = GKeyFile end begin struct _GLogField @@ -144,97 +161,113 @@ $(Expr(:toplevel, quote convert(::Type{GLogField}, p::Ptr{_GLogField}, owns = false) = begin GLogField(p, owns) end + const GLogFieldLike = Union{Ref{_GLogField}, GLogField} end end - mutable struct GMainContext <: GBoxed - handle::Ptr{GMainContext} - begin - (GLib.g_type(::Type{T}) where T <: GMainContext) = begin - ccall(("g_main_context_get_type", libgobject), GType, ()) - end - function GMainContext(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GMainContext <: GBoxed + handle::Ptr{GMainContext} + begin + (GLib.g_type(::Type{T}) where T <: GMainContext) = begin + ccall(("g_main_context_get_type", libgobject), GType, ()) end + function GMainContext(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GMainContext) end - push!(gboxed_types, GMainContext) end + const GMainContextLike = GMainContext end - mutable struct GMainLoop <: GBoxed - handle::Ptr{GMainLoop} - begin - (GLib.g_type(::Type{T}) where T <: GMainLoop) = begin - ccall(("g_main_loop_get_type", libgobject), GType, ()) - end - function GMainLoop(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GMainLoop <: GBoxed + handle::Ptr{GMainLoop} + begin + (GLib.g_type(::Type{T}) where T <: GMainLoop) = begin + ccall(("g_main_loop_get_type", libgobject), GType, ()) end + function GMainLoop(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GMainLoop) end - push!(gboxed_types, GMainLoop) end + const GMainLoopLike = GMainLoop end - mutable struct GMappedFile <: GBoxed - handle::Ptr{GMappedFile} - begin - (GLib.g_type(::Type{T}) where T <: GMappedFile) = begin - ccall(("g_mapped_file_get_type", libgobject), GType, ()) - end - function GMappedFile(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GMappedFile <: GBoxed + handle::Ptr{GMappedFile} + begin + (GLib.g_type(::Type{T}) where T <: GMappedFile) = begin + ccall(("g_mapped_file_get_type", libgobject), GType, ()) end + function GMappedFile(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GMappedFile) end - push!(gboxed_types, GMappedFile) end + const GMappedFileLike = GMappedFile end - mutable struct GMarkupParseContext <: GBoxed - handle::Ptr{GMarkupParseContext} - begin - (GLib.g_type(::Type{T}) where T <: GMarkupParseContext) = begin - ccall(("g_markup_parse_context_get_type", libgobject), GType, ()) - end - function GMarkupParseContext(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GMarkupParseContext <: GBoxed + handle::Ptr{GMarkupParseContext} + begin + (GLib.g_type(::Type{T}) where T <: GMarkupParseContext) = begin + ccall(("g_markup_parse_context_get_type", libgobject), GType, ()) end + function GMarkupParseContext(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GMarkupParseContext) end - push!(gboxed_types, GMarkupParseContext) end + const GMarkupParseContextLike = GMarkupParseContext end - mutable struct GMatchInfo <: GBoxed - handle::Ptr{GMatchInfo} - begin - (GLib.g_type(::Type{T}) where T <: GMatchInfo) = begin - ccall(("g_match_info_get_type", libgobject), GType, ()) - end - function GMatchInfo(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GMatchInfo <: GBoxed + handle::Ptr{GMatchInfo} + begin + (GLib.g_type(::Type{T}) where T <: GMatchInfo) = begin + ccall(("g_match_info_get_type", libgobject), GType, ()) + end + function GMatchInfo(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GMatchInfo) end - push!(gboxed_types, GMatchInfo) end + const GMatchInfoLike = GMatchInfo end begin struct _GOptionEntry @@ -256,43 +289,50 @@ $(Expr(:toplevel, quote convert(::Type{GOptionEntry}, p::Ptr{_GOptionEntry}, owns = false) = begin GOptionEntry(p, owns) end + const GOptionEntryLike = Union{Ref{_GOptionEntry}, GOptionEntry} end end - mutable struct GPatternSpec <: GBoxed - handle::Ptr{GPatternSpec} - begin - (GLib.g_type(::Type{T}) where T <: GPatternSpec) = begin - ccall(("g_pattern_spec_get_type", libgobject), GType, ()) - end - function GPatternSpec(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GPatternSpec <: GBoxed + handle::Ptr{GPatternSpec} + begin + (GLib.g_type(::Type{T}) where T <: GPatternSpec) = begin + ccall(("g_pattern_spec_get_type", libgobject), GType, ()) end + function GPatternSpec(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GPatternSpec) end - push!(gboxed_types, GPatternSpec) end + const GPatternSpecLike = GPatternSpec end - mutable struct GRegex <: GBoxed - handle::Ptr{GRegex} - begin - (GLib.g_type(::Type{T}) where T <: GRegex) = begin - ccall(("g_regex_get_type", libgobject), GType, ()) - end - function GRegex(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GRegex <: GBoxed + handle::Ptr{GRegex} + begin + (GLib.g_type(::Type{T}) where T <: GRegex) = begin + ccall(("g_regex_get_type", libgobject), GType, ()) end + function GRegex(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GRegex) end - push!(gboxed_types, GRegex) end + const GRegexLike = GRegex end begin struct _GScannerConfig @@ -334,6 +374,7 @@ $(Expr(:toplevel, quote convert(::Type{GScannerConfig}, p::Ptr{_GScannerConfig}, owns = false) = begin GScannerConfig(p, owns) end + const GScannerConfigLike = Union{Ref{_GScannerConfig}, GScannerConfig} end end begin @@ -355,6 +396,7 @@ $(Expr(:toplevel, quote push!(gboxed_types, GSource) end end + const GSourceLike = GSource const _GSource = GSource end begin @@ -373,6 +415,7 @@ $(Expr(:toplevel, quote convert(::Type{GSourceCallbackFuncs}, p::Ptr{_GSourceCallbackFuncs}, owns = false) = begin GSourceCallbackFuncs(p, owns) end + const GSourceCallbackFuncsLike = Union{Ref{_GSourceCallbackFuncs}, GSourceCallbackFuncs} end end begin @@ -406,6 +449,7 @@ $(Expr(:toplevel, quote convert(::Type{GString}, p::Ptr{_GString}, owns = false) = begin GString(p, owns) end + const GStringLike = Union{Ref{_GString}, GString} end end begin @@ -427,97 +471,113 @@ $(Expr(:toplevel, quote convert(::Type{GTestConfig}, p::Ptr{_GTestConfig}, owns = false) = begin GTestConfig(p, owns) end + const GTestConfigLike = Union{Ref{_GTestConfig}, GTestConfig} end end - mutable struct GTimeZone <: GBoxed - handle::Ptr{GTimeZone} - begin - (GLib.g_type(::Type{T}) where T <: GTimeZone) = begin - ccall(("g_time_zone_get_type", libgobject), GType, ()) - end - function GTimeZone(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GTimeZone <: GBoxed + handle::Ptr{GTimeZone} + begin + (GLib.g_type(::Type{T}) where T <: GTimeZone) = begin + ccall(("g_time_zone_get_type", libgobject), GType, ()) end + function GTimeZone(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GTimeZone) end - push!(gboxed_types, GTimeZone) end + const GTimeZoneLike = GTimeZone end - mutable struct GUri <: GBoxed - handle::Ptr{GUri} - begin - (GLib.g_type(::Type{T}) where T <: GUri) = begin - ccall(("g_uri_get_type", libgobject), GType, ()) - end - function GUri(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GUri <: GBoxed + handle::Ptr{GUri} + begin + (GLib.g_type(::Type{T}) where T <: GUri) = begin + ccall(("g_uri_get_type", libgobject), GType, ()) + end + function GUri(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GUri) end - push!(gboxed_types, GUri) end + const GUriLike = GUri end - mutable struct GVariantBuilder <: GBoxed - handle::Ptr{GVariantBuilder} - begin - (GLib.g_type(::Type{T}) where T <: GVariantBuilder) = begin - ccall(("g_variant_builder_get_type", libgobject), GType, ()) - end - function GVariantBuilder(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GVariantBuilder <: GBoxed + handle::Ptr{GVariantBuilder} + begin + (GLib.g_type(::Type{T}) where T <: GVariantBuilder) = begin + ccall(("g_variant_builder_get_type", libgobject), GType, ()) + end + function GVariantBuilder(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GVariantBuilder) end - push!(gboxed_types, GVariantBuilder) end + const GVariantBuilderLike = GVariantBuilder end - mutable struct GVariantDict <: GBoxed - handle::Ptr{GVariantDict} - begin - (GLib.g_type(::Type{T}) where T <: GVariantDict) = begin - ccall(("g_variant_dict_get_type", libgobject), GType, ()) - end - function GVariantDict(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GVariantDict <: GBoxed + handle::Ptr{GVariantDict} + begin + (GLib.g_type(::Type{T}) where T <: GVariantDict) = begin + ccall(("g_variant_dict_get_type", libgobject), GType, ()) + end + function GVariantDict(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GVariantDict) end - push!(gboxed_types, GVariantDict) end + const GVariantDictLike = GVariantDict end - mutable struct GVariantType <: GBoxed - handle::Ptr{GVariantType} - begin - (GLib.g_type(::Type{T}) where T <: GVariantType) = begin - ccall(("g_variant_type_get_gtype", libgobject), GType, ()) - end - function GVariantType(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GVariantType <: GBoxed + handle::Ptr{GVariantType} + begin + (GLib.g_type(::Type{T}) where T <: GVariantType) = begin + ccall(("g_variant_type_get_gtype", libgobject), GType, ()) end + function GVariantType(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GVariantType) end - push!(gboxed_types, GVariantType) end + const GVariantTypeLike = GVariantType end gboxed_cache_init() = begin append!(GLib.gboxed_types, gboxed_types) @@ -671,13 +731,13 @@ $(Expr(:toplevel, quote convert(Cint, ret) end function GHookCheckMarshaller(hook, marshal_data) - hook = convert(Union{GHook, Ref{_GHook}}, hook) + hook = convert(GHookLike, hook) f = marshal_data ret = f(hook) convert(Cint, ret) end function GHookFindFunc(hook, data) - hook = convert(Union{GHook, Ref{_GHook}}, hook) + hook = convert(GHookLike, hook) f = data ret = f(hook) convert(Cint, ret) @@ -688,13 +748,13 @@ $(Expr(:toplevel, quote nothing end function GHookMarshaller(hook, marshal_data) - hook = convert(Union{GHook, Ref{_GHook}}, hook) + hook = convert(GHookLike, hook) f = marshal_data ret = f(hook) nothing end function GIOFunc(source, condition, data) - source = convert(Union{GIOChannel, Ref{_GIOChannel}}, source, false) + source = convert(GIOChannelLike, source, false) condition = IOCondition(condition) f = data ret = f(source, condition) @@ -716,13 +776,13 @@ $(Expr(:toplevel, quote convert(UInt32, ret) end function GNodeForeachFunc(node, data) - node = convert(Union{GNode, Ref{_GNode}}, node) + node = convert(GNodeLike, node) f = data ret = f(node) nothing end function GNodeTraverseFunc(node, data) - node = convert(Union{GNode, Ref{_GNode}}, node) + node = convert(GNodeLike, node) f = data ret = f(node) convert(Cint, ret) @@ -750,7 +810,7 @@ $(Expr(:toplevel, quote end function GRegexEvalCallback(match_info, result, user_data) match_info = convert(GMatchInfo, match_info, false) - result = convert(Union{GString, Ref{_GString}}, result, false) + result = convert(GStringLike, result, false) f = user_data ret = f(match_info, result) convert(Cint, ret) @@ -826,6 +886,6 @@ $(Expr(:toplevel, quote ret = f(fd, condition) convert(Cint, ret) end - export GBookmarkFile, GBytes, GChecksum, GDate, _GDate, GDateTime, GDebugKey, _GDebugKey, GKeyFile, GLogField, _GLogField, GMainContext, GMainLoop, GMappedFile, GMarkupParseContext, GMatchInfo, GOptionEntry, _GOptionEntry, GPatternSpec, GRegex, GScannerConfig, _GScannerConfig, GSource, _GSource, GSourceCallbackFuncs, _GSourceCallbackFuncs, GString, _GString, GTestConfig, _GTestConfig, GTimeZone, GUri, GVariantBuilder, GVariantDict, GVariantType, GChildWatchFunc, GCompareDataFunc, GCopyFunc, GDataForeachFunc, GDestroyNotify, GDuplicateFunc, GEqualFuncFull, GFreeFunc, GFunc, GHFunc, GHRFunc, GHookCheckFunc, GHookCheckMarshaller, GHookFindFunc, GHookFunc, GHookMarshaller, GIOFunc, GLogFunc, GLogWriterFunc, GNodeForeachFunc, GNodeTraverseFunc, GOptionArgFunc, GOptionErrorFunc, GOptionParseFunc, GRegexEvalCallback, GSequenceIterCompareFunc, GSourceFunc, GSourceOnceFunc, GSpawnChildSetupFunc, GTestDataFunc, GTestFixtureFunc, GTestLogFatalFunc, GThreadFunc, GTranslateFunc, GTraverseFunc, GTraverseNodeFunc, GUnixFDSourceFunc + export GBookmarkFile, GBytes, GChecksum, GDate, GDateLike, _GDate, GDateTime, GDebugKey, GDebugKeyLike, _GDebugKey, GKeyFile, GLogField, GLogFieldLike, _GLogField, GMainContext, GMainLoop, GMappedFile, GMarkupParseContext, GMatchInfo, GOptionEntry, GOptionEntryLike, _GOptionEntry, GPatternSpec, GRegex, GScannerConfig, GScannerConfigLike, _GScannerConfig, GSource, GSourceLike, _GSource, GSourceCallbackFuncs, GSourceCallbackFuncsLike, _GSourceCallbackFuncs, GString, GStringLike, _GString, GTestConfig, GTestConfigLike, _GTestConfig, GTimeZone, GUri, GVariantBuilder, GVariantDict, GVariantType, GChildWatchFunc, GCompareDataFunc, GCopyFunc, GDataForeachFunc, GDestroyNotify, GDuplicateFunc, GEqualFuncFull, GFreeFunc, GFunc, GHFunc, GHRFunc, GHookCheckFunc, GHookCheckMarshaller, GHookFindFunc, GHookFunc, GHookMarshaller, GIOFunc, GLogFunc, GLogWriterFunc, GNodeForeachFunc, GNodeTraverseFunc, GOptionArgFunc, GOptionErrorFunc, GOptionParseFunc, GRegexEvalCallback, GSequenceIterCompareFunc, GSourceFunc, GSourceOnceFunc, GSpawnChildSetupFunc, GTestDataFunc, GTestFixtureFunc, GTestLogFatalFunc, GThreadFunc, GTranslateFunc, GTraverseFunc, GTraverseNodeFunc, GUnixFDSourceFunc end)) end diff --git a/src/gen/gobject_functions b/src/gen/gobject_functions index 372293ca..ac22a25e 100644 --- a/src/gen/gobject_functions +++ b/src/gen/gobject_functions @@ -13,19 +13,19 @@ $(Expr(:toplevel, quote ret = ccall(("g_clear_signal_handler", libgobject), Nothing, (Ptr{UInt64}, Ptr{GObject}), _handler_id_ptr, _instance) nothing end - function enum_get_value(_enum_class::Union{GEnumClass, Ref{_GEnumClass}}, _value::Integer) + function enum_get_value(_enum_class::GEnumClassLike, _value::Integer) ret = ccall(("g_enum_get_value", libgobject), Ptr{_GEnumValue}, (Ptr{_GEnumClass}, Int32), _enum_class, _value) - ret2 = convert(Union{GEnumValue, Ref{_GEnumValue}}, ret) + ret2 = convert(GEnumValueLike, ret) ret2 end - function enum_get_value_by_name(_enum_class::Union{GEnumClass, Ref{_GEnumClass}}, _name::Union{AbstractString, Symbol}) + function enum_get_value_by_name(_enum_class::GEnumClassLike, _name::Union{AbstractString, Symbol}) ret = ccall(("g_enum_get_value_by_name", libgobject), Ptr{_GEnumValue}, (Ptr{_GEnumClass}, Cstring), _enum_class, _name) - ret2 = convert(Union{GEnumValue, Ref{_GEnumValue}}, ret) + ret2 = convert(GEnumValueLike, ret) ret2 end - function enum_get_value_by_nick(_enum_class::Union{GEnumClass, Ref{_GEnumClass}}, _nick::Union{AbstractString, Symbol}) + function enum_get_value_by_nick(_enum_class::GEnumClassLike, _nick::Union{AbstractString, Symbol}) ret = ccall(("g_enum_get_value_by_nick", libgobject), Ptr{_GEnumValue}, (Ptr{_GEnumClass}, Cstring), _enum_class, _nick) - ret2 = convert(Union{GEnumValue, Ref{_GEnumValue}}, ret) + ret2 = convert(GEnumValueLike, ret) ret2 end function enum_to_string(_g_enum_type::Integer, _value::Integer) @@ -33,19 +33,19 @@ $(Expr(:toplevel, quote ret2 = string_or_nothing(ret, true) ret2 end - function flags_get_first_value(_flags_class::Union{GFlagsClass, Ref{_GFlagsClass}}, _value::Integer) + function flags_get_first_value(_flags_class::GFlagsClassLike, _value::Integer) ret = ccall(("g_flags_get_first_value", libgobject), Ptr{_GFlagsValue}, (Ptr{_GFlagsClass}, UInt32), _flags_class, _value) - ret2 = convert(Union{GFlagsValue, Ref{_GFlagsValue}}, ret) + ret2 = convert(GFlagsValueLike, ret) ret2 end - function flags_get_value_by_name(_flags_class::Union{GFlagsClass, Ref{_GFlagsClass}}, _name::Union{AbstractString, Symbol}) + function flags_get_value_by_name(_flags_class::GFlagsClassLike, _name::Union{AbstractString, Symbol}) ret = ccall(("g_flags_get_value_by_name", libgobject), Ptr{_GFlagsValue}, (Ptr{_GFlagsClass}, Cstring), _flags_class, _name) - ret2 = convert(Union{GFlagsValue, Ref{_GFlagsValue}}, ret) + ret2 = convert(GFlagsValueLike, ret) ret2 end - function flags_get_value_by_nick(_flags_class::Union{GFlagsClass, Ref{_GFlagsClass}}, _nick::Union{AbstractString, Symbol}) + function flags_get_value_by_nick(_flags_class::GFlagsClassLike, _nick::Union{AbstractString, Symbol}) ret = ccall(("g_flags_get_value_by_nick", libgobject), Ptr{_GFlagsValue}, (Ptr{_GFlagsClass}, Cstring), _flags_class, _nick) - ret2 = convert(Union{GFlagsValue, Ref{_GFlagsValue}}, ret) + ret2 = convert(GFlagsValueLike, ret) ret2 end function flags_to_string(_flags_type::Integer, _value::Integer) @@ -57,7 +57,7 @@ $(Expr(:toplevel, quote ret = ccall(("g_gtype_get_type", libgobject), UInt64, ()) ret end - function param_value_is_valid(_pspec::GParam, _value::Union{GValue, Ref{_GValue}}) + function param_value_is_valid(_pspec::GParam, _value::GValueLike) ret = ccall(("g_param_value_is_valid", libgobject), Cint, (Ptr{GParam}, Ptr{_GValue}), _pspec, _value) ret2 = convert(Bool, ret) ret2 @@ -66,14 +66,14 @@ $(Expr(:toplevel, quote ret = ccall(("g_pointer_type_register_static", libgobject), UInt64, (Cstring,), _name) ret end - function signal_chain_from_overridden(_instance_and_params, _return_value::Union{GValue, Ref{_GValue}}) + function signal_chain_from_overridden(_instance_and_params, _return_value::GValueLike) _instance_and_params_arr = convert(Vector{_GValue}, _instance_and_params) ret = ccall(("g_signal_chain_from_overridden", libgobject), Nothing, (Ptr{_GValue}, Ptr{_GValue}), _instance_and_params_arr, _return_value) nothing end function signal_get_invocation_hint(_instance::GObject) ret = ccall(("g_signal_get_invocation_hint", libgobject), Ptr{_GSignalInvocationHint}, (Ptr{GObject},), _instance) - ret2 = convert(Union{GSignalInvocationHint, Ref{_GSignalInvocationHint}}, ret) + ret2 = convert(GSignalInvocationHintLike, ret) ret2 end function signal_handler_block(_instance::GObject, _handler_id::Integer) @@ -155,7 +155,7 @@ $(Expr(:toplevel, quote ret = ccall(("g_signal_stop_emission_by_name", libgobject), Nothing, (Ptr{GObject}, Cstring), _instance, _detailed_signal) nothing end - function strdup_value_contents(_value::Union{GValue, Ref{_GValue}}) + function strdup_value_contents(_value::GValueLike) ret = ccall(("g_strdup_value_contents", libgobject), Cstring, (Ptr{_GValue},), _value) ret2 = string_or_nothing(ret, true) ret2 @@ -172,11 +172,11 @@ $(Expr(:toplevel, quote ret = ccall(("g_type_add_interface_dynamic", libgobject), Nothing, (UInt64, UInt64, Ptr{GObject}), _instance_type, _interface_type, _plugin) nothing end - function type_add_interface_static(_instance_type::Integer, _interface_type::Integer, _info::Union{GInterfaceInfo, Ref{_GInterfaceInfo}}) + function type_add_interface_static(_instance_type::Integer, _interface_type::Integer, _info::GInterfaceInfoLike) ret = ccall(("g_type_add_interface_static", libgobject), Nothing, (UInt64, UInt64, Ptr{_GInterfaceInfo}), _instance_type, _interface_type, _info) nothing end - function type_check_class_is_a(_g_class::Union{GTypeClass, Ref{_GTypeClass}}, _is_a_type::Integer) + function type_check_class_is_a(_g_class::GTypeClassLike, _is_a_type::Integer) ret = ccall(("g_type_check_class_is_a", libgobject), Cint, (Ptr{_GTypeClass}, UInt64), _g_class, _is_a_type) ret2 = convert(Bool, ret) ret2 @@ -186,12 +186,12 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function type_check_value(_value::Union{GValue, Ref{_GValue}}) + function type_check_value(_value::GValueLike) ret = ccall(("g_type_check_value", libgobject), Cint, (Ptr{_GValue},), _value) ret2 = convert(Bool, ret) ret2 end - function type_check_value_holds(_value::Union{GValue, Ref{_GValue}}, _type::Integer) + function type_check_value_holds(_value::GValueLike, _type::Integer) ret = ccall(("g_type_check_value_holds", libgobject), Cint, (Ptr{_GValue}, UInt64), _value, _type) ret2 = convert(Bool, ret) ret2 @@ -214,27 +214,27 @@ $(Expr(:toplevel, quote end function type_class_peek(_type::Integer) ret = ccall(("g_type_class_peek", libgobject), Ptr{_GTypeClass}, (UInt64,), _type) - ret2 = convert(Union{GTypeClass, Ref{_GTypeClass}}, ret) + ret2 = convert(GTypeClassLike, ret) ret2 end function type_class_peek_static(_type::Integer) ret = ccall(("g_type_class_peek_static", libgobject), Ptr{_GTypeClass}, (UInt64,), _type) - ret2 = convert(Union{GTypeClass, Ref{_GTypeClass}}, ret) + ret2 = convert(GTypeClassLike, ret) ret2 end function type_class_ref(_type::Integer) ret = ccall(("g_type_class_ref", libgobject), Ptr{_GTypeClass}, (UInt64,), _type) - ret2 = convert(Union{GTypeClass, Ref{_GTypeClass}}, ret) + ret2 = convert(GTypeClassLike, ret) ret2 end function type_default_interface_peek(_g_type::Integer) ret = ccall(("g_type_default_interface_peek", libgobject), Ptr{_GTypeInterface}, (UInt64,), _g_type) - ret2 = convert(Union{GTypeInterface, Ref{_GTypeInterface}}, ret) + ret2 = convert(GTypeInterfaceLike, ret) ret2 end function type_default_interface_ref(_g_type::Integer) ret = ccall(("g_type_default_interface_ref", libgobject), Ptr{_GTypeInterface}, (UInt64,), _g_type) - ret2 = convert(Union{GTypeInterface, Ref{_GTypeInterface}}, ret) + ret2 = convert(GTypeInterfaceLike, ret) ret2 end function type_depth(_type::Integer) @@ -290,9 +290,9 @@ $(Expr(:toplevel, quote ret = ccall(("g_type_interface_instantiatable_prerequisite", libgobject), UInt64, (UInt64,), _interface_type) ret end - function type_interface_peek(_instance_class::Union{GTypeClass, Ref{_GTypeClass}}, _iface_type::Integer) + function type_interface_peek(_instance_class::GTypeClassLike, _iface_type::Integer) ret = ccall(("g_type_interface_peek", libgobject), Ptr{_GTypeInterface}, (Ptr{_GTypeClass}, UInt64), _instance_class, _iface_type) - ret2 = convert(Union{GTypeInterface, Ref{_GTypeInterface}}, ret) + ret2 = convert(GTypeInterfaceLike, ret) ret2 end function type_interface_prerequisites(_interface_type::Integer) @@ -317,7 +317,7 @@ $(Expr(:toplevel, quote _n_interfaces = m_n_interfaces[] ret2 end - function type_name_from_class(_g_class::Union{GTypeClass, Ref{_GTypeClass}}) + function type_name_from_class(_g_class::GTypeClassLike) ret = ccall(("g_type_name_from_class", libgobject), Cstring, (Ptr{_GTypeClass},), _g_class) ret2 = string_or_nothing(ret, false) ret2 @@ -341,7 +341,7 @@ $(Expr(:toplevel, quote ret = ccall(("g_type_register_dynamic", libgobject), UInt64, (UInt64, Cstring, Ptr{GObject}, UInt32), _parent_type, _type_name, _plugin, _flags) ret end - function type_register_static(_parent_type::Integer, _type_name::Union{AbstractString, Symbol}, _info::Union{GTypeInfo, Ref{_GTypeInfo}}, _flags) + function type_register_static(_parent_type::Integer, _type_name::Union{AbstractString, Symbol}, _info::GTypeInfoLike, _flags) ret = ccall(("g_type_register_static", libgobject), UInt64, (UInt64, Cstring, Ptr{_GTypeInfo}, UInt32), _parent_type, _type_name, _info, _flags) ret end diff --git a/src/gen/gobject_methods b/src/gen/gobject_methods index 4894bce2..16c13ab2 100644 --- a/src/gen/gobject_methods +++ b/src/gen/gobject_methods @@ -1,248 +1,248 @@ quote $(Expr(:toplevel, quote - function copy(instance::Union{GValue, Ref{_GValue}}, _dest_value::Union{GValue, Ref{_GValue}}) + function copy(instance::GValueLike, _dest_value::GValueLike) ret = ccall(("g_value_copy", libgobject), Nothing, (Ptr{_GValue}, Ptr{_GValue}), instance, _dest_value) nothing end - function dup_object(instance::Union{GValue, Ref{_GValue}}) + function dup_object(instance::GValueLike) ret = ccall(("g_value_dup_object", libgobject), Ptr{GObject}, (Ptr{_GValue},), instance) ret2 = convert_if_not_null(GObject, ret, true) ret2 end - function dup_string(instance::Union{GValue, Ref{_GValue}}) + function dup_string(instance::GValueLike) ret = ccall(("g_value_dup_string", libgobject), Cstring, (Ptr{_GValue},), instance) ret2 = string_or_nothing(ret, true) ret2 end - function dup_variant(instance::Union{GValue, Ref{_GValue}}) + function dup_variant(instance::GValueLike) ret = ccall(("g_value_dup_variant", libgobject), Ptr{GVariant}, (Ptr{_GValue},), instance) ret2 = convert(GVariant, ret) ret2 end - function fits_pointer(instance::Union{GValue, Ref{_GValue}}) + function fits_pointer(instance::GValueLike) ret = ccall(("g_value_fits_pointer", libgobject), Cint, (Ptr{_GValue},), instance) ret2 = convert(Bool, ret) ret2 end - function get_boolean(instance::Union{GValue, Ref{_GValue}}) + function get_boolean(instance::GValueLike) ret = ccall(("g_value_get_boolean", libgobject), Cint, (Ptr{_GValue},), instance) ret2 = convert(Bool, ret) ret2 end - function get_boxed(instance::Union{GValue, Ref{_GValue}}) + function get_boxed(instance::GValueLike) ret = ccall(("g_value_get_boxed", libgobject), Ptr{Nothing}, (Ptr{_GValue},), instance) ret2 = convert(Nothing, ret) ret2 end - function get_double(instance::Union{GValue, Ref{_GValue}}) + function get_double(instance::GValueLike) ret = ccall(("g_value_get_double", libgobject), Float64, (Ptr{_GValue},), instance) ret end - function get_enum(instance::Union{GValue, Ref{_GValue}}) + function get_enum(instance::GValueLike) ret = ccall(("g_value_get_enum", libgobject), Int32, (Ptr{_GValue},), instance) ret end - function get_flags(instance::Union{GValue, Ref{_GValue}}) + function get_flags(instance::GValueLike) ret = ccall(("g_value_get_flags", libgobject), UInt32, (Ptr{_GValue},), instance) ret end - function get_float(instance::Union{GValue, Ref{_GValue}}) + function get_float(instance::GValueLike) ret = ccall(("g_value_get_float", libgobject), Float32, (Ptr{_GValue},), instance) ret end - function get_gtype(instance::Union{GValue, Ref{_GValue}}) + function get_gtype(instance::GValueLike) ret = ccall(("g_value_get_gtype", libgobject), UInt64, (Ptr{_GValue},), instance) ret end - function get_int(instance::Union{GValue, Ref{_GValue}}) + function get_int(instance::GValueLike) ret = ccall(("g_value_get_int", libgobject), Int32, (Ptr{_GValue},), instance) ret end - function get_int64(instance::Union{GValue, Ref{_GValue}}) + function get_int64(instance::GValueLike) ret = ccall(("g_value_get_int64", libgobject), Int64, (Ptr{_GValue},), instance) ret end - function get_long(instance::Union{GValue, Ref{_GValue}}) + function get_long(instance::GValueLike) ret = ccall(("g_value_get_long", libgobject), Int64, (Ptr{_GValue},), instance) ret end - function get_object(instance::Union{GValue, Ref{_GValue}}) + function get_object(instance::GValueLike) ret = ccall(("g_value_get_object", libgobject), Ptr{GObject}, (Ptr{_GValue},), instance) ret2 = convert_if_not_null(GObject, ret, false) ret2 end - function get_pointer(instance::Union{GValue, Ref{_GValue}}) + function get_pointer(instance::GValueLike) ret = ccall(("g_value_get_pointer", libgobject), Ptr{Nothing}, (Ptr{_GValue},), instance) ret2 = convert(Nothing, ret) ret2 end - function get_schar(instance::Union{GValue, Ref{_GValue}}) + function get_schar(instance::GValueLike) ret = ccall(("g_value_get_schar", libgobject), Int8, (Ptr{_GValue},), instance) ret end - function get_string(instance::Union{GValue, Ref{_GValue}}) + function get_string(instance::GValueLike) ret = ccall(("g_value_get_string", libgobject), Cstring, (Ptr{_GValue},), instance) ret2 = string_or_nothing(ret, false) ret2 end - function get_uchar(instance::Union{GValue, Ref{_GValue}}) + function get_uchar(instance::GValueLike) ret = ccall(("g_value_get_uchar", libgobject), UInt8, (Ptr{_GValue},), instance) ret end - function get_uint(instance::Union{GValue, Ref{_GValue}}) + function get_uint(instance::GValueLike) ret = ccall(("g_value_get_uint", libgobject), UInt32, (Ptr{_GValue},), instance) ret end - function get_uint64(instance::Union{GValue, Ref{_GValue}}) + function get_uint64(instance::GValueLike) ret = ccall(("g_value_get_uint64", libgobject), UInt64, (Ptr{_GValue},), instance) ret end - function get_ulong(instance::Union{GValue, Ref{_GValue}}) + function get_ulong(instance::GValueLike) ret = ccall(("g_value_get_ulong", libgobject), UInt64, (Ptr{_GValue},), instance) ret end - function get_variant(instance::Union{GValue, Ref{_GValue}}) + function get_variant(instance::GValueLike) ret = ccall(("g_value_get_variant", libgobject), Ptr{GVariant}, (Ptr{_GValue},), instance) ret2 = convert(GVariant, ret) ret2 end - function init(instance::Union{GValue, Ref{_GValue}}, _g_type::Integer) + function init(instance::GValueLike, _g_type::Integer) ret = ccall(("g_value_init", libgobject), Ptr{_GValue}, (Ptr{_GValue}, UInt64), instance, _g_type) - ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false) + ret2 = convert(GValueLike, ret, false) ret2 end - function peek_pointer(instance::Union{GValue, Ref{_GValue}}) + function peek_pointer(instance::GValueLike) ret = ccall(("g_value_peek_pointer", libgobject), Ptr{Nothing}, (Ptr{_GValue},), instance) ret2 = convert(Nothing, ret) ret2 end - function reset(instance::Union{GValue, Ref{_GValue}}) + function reset(instance::GValueLike) ret = ccall(("g_value_reset", libgobject), Ptr{_GValue}, (Ptr{_GValue},), instance) - ret2 = convert(Union{GValue, Ref{_GValue}}, ret, true) + ret2 = convert(GValueLike, ret, true) ret2 end - function set_boolean(instance::Union{GValue, Ref{_GValue}}, _v_boolean::Bool) + function set_boolean(instance::GValueLike, _v_boolean::Bool) ret = ccall(("g_value_set_boolean", libgobject), Nothing, (Ptr{_GValue}, Cint), instance, _v_boolean) nothing end - function set_boxed(instance::Union{GValue, Ref{_GValue}}, _v_boxed::Maybe(Nothing)) + function set_boxed(instance::GValueLike, _v_boxed::Maybe(Nothing)) _v_boxed_maybe = nothing_to_null(_v_boxed) ret = ccall(("g_value_set_boxed", libgobject), Nothing, (Ptr{_GValue}, Ptr{Nothing}), instance, _v_boxed_maybe) nothing end - function set_double(instance::Union{GValue, Ref{_GValue}}, _v_double::Real) + function set_double(instance::GValueLike, _v_double::Real) ret = ccall(("g_value_set_double", libgobject), Nothing, (Ptr{_GValue}, Float64), instance, _v_double) nothing end - function set_enum(instance::Union{GValue, Ref{_GValue}}, _v_enum::Integer) + function set_enum(instance::GValueLike, _v_enum::Integer) ret = ccall(("g_value_set_enum", libgobject), Nothing, (Ptr{_GValue}, Int32), instance, _v_enum) nothing end - function set_flags(instance::Union{GValue, Ref{_GValue}}, _v_flags::Integer) + function set_flags(instance::GValueLike, _v_flags::Integer) ret = ccall(("g_value_set_flags", libgobject), Nothing, (Ptr{_GValue}, UInt32), instance, _v_flags) nothing end - function set_float(instance::Union{GValue, Ref{_GValue}}, _v_float::Real) + function set_float(instance::GValueLike, _v_float::Real) ret = ccall(("g_value_set_float", libgobject), Nothing, (Ptr{_GValue}, Float32), instance, _v_float) nothing end - function set_gtype(instance::Union{GValue, Ref{_GValue}}, _v_gtype::Integer) + function set_gtype(instance::GValueLike, _v_gtype::Integer) ret = ccall(("g_value_set_gtype", libgobject), Nothing, (Ptr{_GValue}, UInt64), instance, _v_gtype) nothing end - function set_instance(instance::Union{GValue, Ref{_GValue}}, _instance::Maybe(Nothing)) + function set_instance(instance::GValueLike, _instance::Maybe(Nothing)) _instance_maybe = nothing_to_null(_instance) ret = ccall(("g_value_set_instance", libgobject), Nothing, (Ptr{_GValue}, Ptr{Nothing}), instance, _instance_maybe) nothing end - function set_int(instance::Union{GValue, Ref{_GValue}}, _v_int::Integer) + function set_int(instance::GValueLike, _v_int::Integer) ret = ccall(("g_value_set_int", libgobject), Nothing, (Ptr{_GValue}, Int32), instance, _v_int) nothing end - function set_int64(instance::Union{GValue, Ref{_GValue}}, _v_int64::Integer) + function set_int64(instance::GValueLike, _v_int64::Integer) ret = ccall(("g_value_set_int64", libgobject), Nothing, (Ptr{_GValue}, Int64), instance, _v_int64) nothing end - function set_interned_string(instance::Union{GValue, Ref{_GValue}}, _v_string::Maybe(Union{AbstractString, Symbol})) + function set_interned_string(instance::GValueLike, _v_string::Maybe(Union{AbstractString, Symbol})) _v_string_maybe = nothing_to_null(_v_string) ret = ccall(("g_value_set_interned_string", libgobject), Nothing, (Ptr{_GValue}, Cstring), instance, _v_string_maybe) nothing end - function set_long(instance::Union{GValue, Ref{_GValue}}, _v_long::Integer) + function set_long(instance::GValueLike, _v_long::Integer) ret = ccall(("g_value_set_long", libgobject), Nothing, (Ptr{_GValue}, Int64), instance, _v_long) nothing end - function set_object(instance::Union{GValue, Ref{_GValue}}, _v_object::Maybe(GObject)) + function set_object(instance::GValueLike, _v_object::Maybe(GObject)) _v_object_maybe = nothing_to_null(_v_object) ret = ccall(("g_value_set_object", libgobject), Nothing, (Ptr{_GValue}, Ptr{GObject}), instance, _v_object_maybe) nothing end - function set_pointer(instance::Union{GValue, Ref{_GValue}}, _v_pointer::Maybe(Nothing)) + function set_pointer(instance::GValueLike, _v_pointer::Maybe(Nothing)) _v_pointer_maybe = nothing_to_null(_v_pointer) ret = ccall(("g_value_set_pointer", libgobject), Nothing, (Ptr{_GValue}, Ptr{Nothing}), instance, _v_pointer_maybe) nothing end - function set_schar(instance::Union{GValue, Ref{_GValue}}, _v_char::Integer) + function set_schar(instance::GValueLike, _v_char::Integer) ret = ccall(("g_value_set_schar", libgobject), Nothing, (Ptr{_GValue}, Int8), instance, _v_char) nothing end - function set_static_boxed(instance::Union{GValue, Ref{_GValue}}, _v_boxed::Maybe(Nothing)) + function set_static_boxed(instance::GValueLike, _v_boxed::Maybe(Nothing)) _v_boxed_maybe = nothing_to_null(_v_boxed) ret = ccall(("g_value_set_static_boxed", libgobject), Nothing, (Ptr{_GValue}, Ptr{Nothing}), instance, _v_boxed_maybe) nothing end - function set_static_string(instance::Union{GValue, Ref{_GValue}}, _v_string::Maybe(Union{AbstractString, Symbol})) + function set_static_string(instance::GValueLike, _v_string::Maybe(Union{AbstractString, Symbol})) _v_string_maybe = nothing_to_null(_v_string) ret = ccall(("g_value_set_static_string", libgobject), Nothing, (Ptr{_GValue}, Cstring), instance, _v_string_maybe) nothing end - function set_string(instance::Union{GValue, Ref{_GValue}}, _v_string::Maybe(Union{AbstractString, Symbol})) + function set_string(instance::GValueLike, _v_string::Maybe(Union{AbstractString, Symbol})) _v_string_maybe = nothing_to_null(_v_string) ret = ccall(("g_value_set_string", libgobject), Nothing, (Ptr{_GValue}, Cstring), instance, _v_string_maybe) nothing end - function set_uchar(instance::Union{GValue, Ref{_GValue}}, _v_uchar::Integer) + function set_uchar(instance::GValueLike, _v_uchar::Integer) ret = ccall(("g_value_set_uchar", libgobject), Nothing, (Ptr{_GValue}, UInt8), instance, _v_uchar) nothing end - function set_uint(instance::Union{GValue, Ref{_GValue}}, _v_uint::Integer) + function set_uint(instance::GValueLike, _v_uint::Integer) ret = ccall(("g_value_set_uint", libgobject), Nothing, (Ptr{_GValue}, UInt32), instance, _v_uint) nothing end - function set_uint64(instance::Union{GValue, Ref{_GValue}}, _v_uint64::Integer) + function set_uint64(instance::GValueLike, _v_uint64::Integer) ret = ccall(("g_value_set_uint64", libgobject), Nothing, (Ptr{_GValue}, UInt64), instance, _v_uint64) nothing end - function set_ulong(instance::Union{GValue, Ref{_GValue}}, _v_ulong::Integer) + function set_ulong(instance::GValueLike, _v_ulong::Integer) ret = ccall(("g_value_set_ulong", libgobject), Nothing, (Ptr{_GValue}, UInt64), instance, _v_ulong) nothing end - function set_variant(instance::Union{GValue, Ref{_GValue}}, _variant::Maybe(GVariant)) + function set_variant(instance::GValueLike, _variant::Maybe(GVariant)) _variant_maybe = nothing_to_null(_variant) ret = ccall(("g_value_set_variant", libgobject), Nothing, (Ptr{_GValue}, Ptr{GVariant}), instance, _variant_maybe) nothing end - function take_boxed(instance::Union{GValue, Ref{_GValue}}, _v_boxed::Maybe(Nothing)) + function take_boxed(instance::GValueLike, _v_boxed::Maybe(Nothing)) _v_boxed_maybe = nothing_to_null(_v_boxed) ret = ccall(("g_value_take_boxed", libgobject), Nothing, (Ptr{_GValue}, Ptr{Nothing}), instance, _v_boxed_maybe) nothing end - function take_string(instance::Union{GValue, Ref{_GValue}}, _v_string::Maybe(Union{AbstractString, Symbol})) + function take_string(instance::GValueLike, _v_string::Maybe(Union{AbstractString, Symbol})) _v_string_maybe = nothing_to_null(_v_string) ret = ccall(("g_value_take_string", libgobject), Nothing, (Ptr{_GValue}, Cstring), instance, _v_string_maybe) nothing end - function take_variant(instance::Union{GValue, Ref{_GValue}}, _variant::Maybe(GVariant)) + function take_variant(instance::GValueLike, _variant::Maybe(GVariant)) _variant_maybe = nothing_to_null(_variant) ret = ccall(("g_value_take_variant", libgobject), Nothing, (Ptr{_GValue}, Ptr{GVariant}), instance, _variant_maybe) nothing end - function transform(instance::Union{GValue, Ref{_GValue}}, _dest_value::Union{GValue, Ref{_GValue}}) + function transform(instance::GValueLike, _dest_value::GValueLike) ret = ccall(("g_value_transform", libgobject), Cint, (Ptr{_GValue}, Ptr{_GValue}), instance, _dest_value) ret2 = convert(Bool, ret) ret2 end - function unset(instance::Union{GValue, Ref{_GValue}}) + function unset(instance::GValueLike) ret = ccall(("g_value_unset", libgobject), Nothing, (Ptr{_GValue},), instance) nothing end @@ -298,7 +298,7 @@ $(Expr(:toplevel, quote ret2 = convert(Nothing, ret) ret2 end - function get_property(instance::GObject, _property_name::Union{AbstractString, Symbol}, _value::Union{GValue, Ref{_GValue}}) + function get_property(instance::GObject, _property_name::Union{AbstractString, Symbol}, _value::GValueLike) ret = ccall(("g_object_get_property", libgobject), Nothing, (Ptr{GObject}, Cstring, Ptr{_GValue}), instance, _property_name, _value) nothing end @@ -335,7 +335,7 @@ $(Expr(:toplevel, quote ret = ccall(("g_object_set_data", libgobject), Nothing, (Ptr{GObject}, Cstring, Ptr{Nothing}), instance, _key, _data_maybe) nothing end - function set_property(instance::GObject, _property_name::Union{AbstractString, Symbol}, _value::Union{GValue, Ref{_GValue}}) + function set_property(instance::GObject, _property_name::Union{AbstractString, Symbol}, _value::GValueLike) ret = ccall(("g_object_set_property", libgobject), Nothing, (Ptr{GObject}, Cstring, Ptr{_GValue}), instance, _property_name, _value) nothing end diff --git a/src/gen/gobject_structs b/src/gen/gobject_structs index 2e21f3d7..a7c5d19c 100644 --- a/src/gen/gobject_structs +++ b/src/gen/gobject_structs @@ -16,6 +16,7 @@ $(Expr(:toplevel, quote convert(::Type{GEnumValue}, p::Ptr{_GEnumValue}, owns = false) = begin GEnumValue(p, owns) end + const GEnumValueLike = Union{Ref{_GEnumValue}, GEnumValue} end end begin @@ -32,6 +33,7 @@ $(Expr(:toplevel, quote convert(::Type{GTypeClass}, p::Ptr{_GTypeClass}, owns = false) = begin GTypeClass(p, owns) end + const GTypeClassLike = Union{Ref{_GTypeClass}, GTypeClass} end end begin @@ -49,6 +51,7 @@ $(Expr(:toplevel, quote convert(::Type{GTypeInterface}, p::Ptr{_GTypeInterface}, owns = false) = begin GTypeInterface(p, owns) end + const GTypeInterfaceLike = Union{Ref{_GTypeInterface}, GTypeInterface} end end begin @@ -67,6 +70,7 @@ $(Expr(:toplevel, quote convert(::Type{GFlagsValue}, p::Ptr{_GFlagsValue}, owns = false) = begin GFlagsValue(p, owns) end + const GFlagsValueLike = Union{Ref{_GFlagsValue}, GFlagsValue} end end begin @@ -90,6 +94,7 @@ $(Expr(:toplevel, quote convert(::Type{GTypeValueTable}, p::Ptr{_GTypeValueTable}, owns = false) = begin GTypeValueTable(p, owns) end + const GTypeValueTableLike = Union{Ref{_GTypeValueTable}, GTypeValueTable} end end begin @@ -110,6 +115,7 @@ $(Expr(:toplevel, quote convert(::Type{GEnumClass}, p::Ptr{_GEnumClass}, owns = false) = begin GEnumClass(p, owns) end + const GEnumClassLike = Union{Ref{_GEnumClass}, GEnumClass} end end begin @@ -129,6 +135,7 @@ $(Expr(:toplevel, quote convert(::Type{GFlagsClass}, p::Ptr{_GFlagsClass}, owns = false) = begin GFlagsClass(p, owns) end + const GFlagsClassLike = Union{Ref{_GFlagsClass}, GFlagsClass} end end begin @@ -147,6 +154,7 @@ $(Expr(:toplevel, quote convert(::Type{GInterfaceInfo}, p::Ptr{_GInterfaceInfo}, owns = false) = begin GInterfaceInfo(p, owns) end + const GInterfaceInfoLike = Union{Ref{_GInterfaceInfo}, GInterfaceInfo} end end begin @@ -170,6 +178,7 @@ $(Expr(:toplevel, quote convert(::Type{GParamSpecTypeInfo}, p::Ptr{_GParamSpecTypeInfo}, owns = false) = begin GParamSpecTypeInfo(p, owns) end + const GParamSpecTypeInfoLike = Union{Ref{_GParamSpecTypeInfo}, GParamSpecTypeInfo} end end begin @@ -188,6 +197,7 @@ $(Expr(:toplevel, quote convert(::Type{GSignalInvocationHint}, p::Ptr{_GSignalInvocationHint}, owns = false) = begin GSignalInvocationHint(p, owns) end + const GSignalInvocationHintLike = Union{Ref{_GSignalInvocationHint}, GSignalInvocationHint} end end begin @@ -210,6 +220,7 @@ $(Expr(:toplevel, quote convert(::Type{GSignalQuery}, p::Ptr{_GSignalQuery}, owns = false) = begin GSignalQuery(p, owns) end + const GSignalQueryLike = Union{Ref{_GSignalQuery}, GSignalQuery} end end begin @@ -226,6 +237,7 @@ $(Expr(:toplevel, quote convert(::Type{GTypeFundamentalInfo}, p::Ptr{_GTypeFundamentalInfo}, owns = false) = begin GTypeFundamentalInfo(p, owns) end + const GTypeFundamentalInfoLike = Union{Ref{_GTypeFundamentalInfo}, GTypeFundamentalInfo} end end begin @@ -251,6 +263,7 @@ $(Expr(:toplevel, quote convert(::Type{GTypeInfo}, p::Ptr{_GTypeInfo}, owns = false) = begin GTypeInfo(p, owns) end + const GTypeInfoLike = Union{Ref{_GTypeInfo}, GTypeInfo} end end begin @@ -271,6 +284,7 @@ $(Expr(:toplevel, quote convert(::Type{GTypePluginClass}, p::Ptr{_GTypePluginClass}, owns = false) = begin GTypePluginClass(p, owns) end + const GTypePluginClassLike = Union{Ref{_GTypePluginClass}, GTypePluginClass} end end begin @@ -290,6 +304,7 @@ $(Expr(:toplevel, quote convert(::Type{GTypeQuery}, p::Ptr{_GTypeQuery}, owns = false) = begin GTypeQuery(p, owns) end + const GTypeQueryLike = Union{Ref{_GTypeQuery}, GTypeQuery} end end begin @@ -323,6 +338,7 @@ $(Expr(:toplevel, quote convert(::Type{GValueArray}, p::Ptr{_GValueArray}, owns = false) = begin GValueArray(p, owns) end + const GValueArrayLike = Union{Ref{_GValueArray}, GValueArray} end end @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.EnumClass.html)." GEnumClass @@ -421,27 +437,27 @@ $(Expr(:toplevel, quote gtype_wrapper_cache[:GObject] = GObjectLeaf function GBindingTransformFunc(binding, from_value, to_value, user_data) binding = convert(GBinding, binding, false) - from_value = convert(Union{GValue, Ref{_GValue}}, from_value, false) - to_value = convert(Union{GValue, Ref{_GValue}}, to_value, false) + from_value = convert(GValueLike, from_value, false) + to_value = convert(GValueLike, to_value, false) f = user_data ret = f(binding, from_value, to_value) convert(Cint, ret) end function GClassFinalizeFunc(g_class, class_data) - g_class = convert(Union{GTypeClass, Ref{_GTypeClass}}, g_class) + g_class = convert(GTypeClassLike, g_class) f = class_data ret = f(g_class) nothing end function GClassInitFunc(g_class, class_data) - g_class = convert(Union{GTypeClass, Ref{_GTypeClass}}, g_class) + g_class = convert(GTypeClassLike, g_class) f = class_data ret = f(g_class) nothing end function GClosureMarshal(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data) - closure = convert(Union{GClosure, Ref{_GClosure}}, closure, false) - return_value = convert_if_not_null(Union{GValue, Ref{_GValue}}, return_value, false) + closure = convert(GClosureLike, closure, false) + return_value = convert_if_not_null(GValueLike, return_value, false) param_values = collect(unsafe_wrap(Vector{_GValue}, param_values, m_n_param_values[])) invocation_hint = convert(Maybe(Nothing), invocation_hint) f = marshal_data @@ -449,32 +465,32 @@ $(Expr(:toplevel, quote nothing end function GInterfaceFinalizeFunc(g_iface, iface_data) - g_iface = convert(Union{GTypeInterface, Ref{_GTypeInterface}}, g_iface) + g_iface = convert(GTypeInterfaceLike, g_iface) f = iface_data ret = f(g_iface) nothing end function GInterfaceInitFunc(g_iface, iface_data) - g_iface = convert(Union{GTypeInterface, Ref{_GTypeInterface}}, g_iface) + g_iface = convert(GTypeInterfaceLike, g_iface) f = iface_data ret = f(g_iface) nothing end function GSignalAccumulator(ihint, return_accu, handler_return, data) - ihint = convert(Union{GSignalInvocationHint, Ref{_GSignalInvocationHint}}, ihint) - return_accu = convert(Union{GValue, Ref{_GValue}}, return_accu, false) - handler_return = convert(Union{GValue, Ref{_GValue}}, handler_return, false) + ihint = convert(GSignalInvocationHintLike, ihint) + return_accu = convert(GValueLike, return_accu, false) + handler_return = convert(GValueLike, handler_return, false) f = data ret = f(ihint, return_accu, handler_return) convert(Cint, ret) end function GSignalEmissionHook(ihint, n_param_values, param_values, data) - ihint = convert(Union{GSignalInvocationHint, Ref{_GSignalInvocationHint}}, ihint) + ihint = convert(GSignalInvocationHintLike, ihint) param_values = collect(unsafe_wrap(Vector{_GValue}, param_values, m_n_param_values[])) f = data ret = f(ihint, n_param_values, param_values) convert(Cint, ret) end - export GEnumValue, _GEnumValue, GTypeClass, _GTypeClass, GTypeInterface, _GTypeInterface, GFlagsValue, _GFlagsValue, GTypeValueTable, _GTypeValueTable, GEnumClass, _GEnumClass, GFlagsClass, _GFlagsClass, GInterfaceInfo, _GInterfaceInfo, GParamSpecTypeInfo, _GParamSpecTypeInfo, GSignalInvocationHint, _GSignalInvocationHint, GSignalQuery, _GSignalQuery, GTypeFundamentalInfo, _GTypeFundamentalInfo, GTypeInfo, _GTypeInfo, GTypePluginClass, _GTypePluginClass, GTypeQuery, _GTypeQuery, GValueArray, _GValueArray, GTypePlugin, GBinding, GBindingLeaf, GInitiallyUnowned, GInitiallyUnownedLeaf, GTypeModule, GBindingTransformFunc, GClassFinalizeFunc, GClassInitFunc, GClosureMarshal, GInterfaceFinalizeFunc, GInterfaceInitFunc, GSignalAccumulator, GSignalEmissionHook + export GEnumValue, _GEnumValue, GEnumValueLike, GTypeClass, _GTypeClass, GTypeClassLike, GTypeInterface, _GTypeInterface, GTypeInterfaceLike, GFlagsValue, _GFlagsValue, GFlagsValueLike, GTypeValueTable, _GTypeValueTable, GTypeValueTableLike, GEnumClass, GEnumClassLike, _GEnumClass, GFlagsClass, GFlagsClassLike, _GFlagsClass, GInterfaceInfo, GInterfaceInfoLike, _GInterfaceInfo, GParamSpecTypeInfo, GParamSpecTypeInfoLike, _GParamSpecTypeInfo, GSignalInvocationHint, GSignalInvocationHintLike, _GSignalInvocationHint, GSignalQuery, GSignalQueryLike, _GSignalQuery, GTypeFundamentalInfo, GTypeFundamentalInfoLike, _GTypeFundamentalInfo, GTypeInfo, GTypeInfoLike, _GTypeInfo, GTypePluginClass, GTypePluginClassLike, _GTypePluginClass, GTypeQuery, GTypeQueryLike, _GTypeQuery, GValueArray, GValueArrayLike, _GValueArray, GTypePlugin, GBinding, GBindingLeaf, GInitiallyUnowned, GInitiallyUnownedLeaf, GTypeModule, GBindingTransformFunc, GClassFinalizeFunc, GClassInitFunc, GClosureMarshal, GInterfaceFinalizeFunc, GInterfaceInitFunc, GSignalAccumulator, GSignalEmissionHook end)) end diff --git a/src/gen/graphene_functions b/src/gen/graphene_functions index 11e960dd..d3a6e256 100644 --- a/src/gen/graphene_functions +++ b/src/gen/graphene_functions @@ -2,132 +2,132 @@ quote $(Expr(:toplevel, quote function box_empty() ret = ccall(("graphene_box_empty", libgraphene), Ptr{_GrapheneBox}, ()) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end function box_infinite() ret = ccall(("graphene_box_infinite", libgraphene), Ptr{_GrapheneBox}, ()) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end function box_minus_one() ret = ccall(("graphene_box_minus_one", libgraphene), Ptr{_GrapheneBox}, ()) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end function box_one() ret = ccall(("graphene_box_one", libgraphene), Ptr{_GrapheneBox}, ()) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end function box_one_minus_one() ret = ccall(("graphene_box_one_minus_one", libgraphene), Ptr{_GrapheneBox}, ()) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end function box_zero() ret = ccall(("graphene_box_zero", libgraphene), Ptr{_GrapheneBox}, ()) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end function point3d_zero() ret = ccall(("graphene_point3d_zero", libgraphene), Ptr{_GraphenePoint3D}, ()) - ret2 = convert(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, ret, false) + ret2 = convert(GraphenePoint3DLike, ret, false) ret2 end function point_zero() ret = ccall(("graphene_point_zero", libgraphene), Ptr{_GraphenePoint}, ()) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end function rect_alloc() ret = ccall(("graphene_rect_alloc", libgraphene), Ptr{_GrapheneRect}, ()) - ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, true) + ret2 = convert(GrapheneRectLike, ret, true) ret2 end function rect_zero() ret = ccall(("graphene_rect_zero", libgraphene), Ptr{_GrapheneRect}, ()) - ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false) + ret2 = convert(GrapheneRectLike, ret, false) ret2 end function size_zero() ret = ccall(("graphene_size_zero", libgraphene), Ptr{_GrapheneSize}, ()) - ret2 = convert(Union{GrapheneSize, Ref{_GrapheneSize}}, ret, false) + ret2 = convert(GrapheneSizeLike, ret, false) ret2 end function vec2_one() ret = ccall(("graphene_vec2_one", libgraphene), Ptr{_GrapheneVec2}, ()) - ret2 = convert(Union{GrapheneVec2, Ref{_GrapheneVec2}}, ret, false) + ret2 = convert(GrapheneVec2Like, ret, false) ret2 end function vec2_x_axis() ret = ccall(("graphene_vec2_x_axis", libgraphene), Ptr{_GrapheneVec2}, ()) - ret2 = convert(Union{GrapheneVec2, Ref{_GrapheneVec2}}, ret, false) + ret2 = convert(GrapheneVec2Like, ret, false) ret2 end function vec2_y_axis() ret = ccall(("graphene_vec2_y_axis", libgraphene), Ptr{_GrapheneVec2}, ()) - ret2 = convert(Union{GrapheneVec2, Ref{_GrapheneVec2}}, ret, false) + ret2 = convert(GrapheneVec2Like, ret, false) ret2 end function vec2_zero() ret = ccall(("graphene_vec2_zero", libgraphene), Ptr{_GrapheneVec2}, ()) - ret2 = convert(Union{GrapheneVec2, Ref{_GrapheneVec2}}, ret, false) + ret2 = convert(GrapheneVec2Like, ret, false) ret2 end function vec3_one() ret = ccall(("graphene_vec3_one", libgraphene), Ptr{_GrapheneVec3}, ()) - ret2 = convert(Union{GrapheneVec3, Ref{_GrapheneVec3}}, ret, false) + ret2 = convert(GrapheneVec3Like, ret, false) ret2 end function vec3_x_axis() ret = ccall(("graphene_vec3_x_axis", libgraphene), Ptr{_GrapheneVec3}, ()) - ret2 = convert(Union{GrapheneVec3, Ref{_GrapheneVec3}}, ret, false) + ret2 = convert(GrapheneVec3Like, ret, false) ret2 end function vec3_y_axis() ret = ccall(("graphene_vec3_y_axis", libgraphene), Ptr{_GrapheneVec3}, ()) - ret2 = convert(Union{GrapheneVec3, Ref{_GrapheneVec3}}, ret, false) + ret2 = convert(GrapheneVec3Like, ret, false) ret2 end function vec3_z_axis() ret = ccall(("graphene_vec3_z_axis", libgraphene), Ptr{_GrapheneVec3}, ()) - ret2 = convert(Union{GrapheneVec3, Ref{_GrapheneVec3}}, ret, false) + ret2 = convert(GrapheneVec3Like, ret, false) ret2 end function vec3_zero() ret = ccall(("graphene_vec3_zero", libgraphene), Ptr{_GrapheneVec3}, ()) - ret2 = convert(Union{GrapheneVec3, Ref{_GrapheneVec3}}, ret, false) + ret2 = convert(GrapheneVec3Like, ret, false) ret2 end function vec4_one() ret = ccall(("graphene_vec4_one", libgraphene), Ptr{_GrapheneVec4}, ()) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end function vec4_w_axis() ret = ccall(("graphene_vec4_w_axis", libgraphene), Ptr{_GrapheneVec4}, ()) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end function vec4_x_axis() ret = ccall(("graphene_vec4_x_axis", libgraphene), Ptr{_GrapheneVec4}, ()) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end function vec4_y_axis() ret = ccall(("graphene_vec4_y_axis", libgraphene), Ptr{_GrapheneVec4}, ()) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end function vec4_z_axis() ret = ccall(("graphene_vec4_z_axis", libgraphene), Ptr{_GrapheneVec4}, ()) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end function vec4_zero() ret = ccall(("graphene_vec4_zero", libgraphene), Ptr{_GrapheneVec4}, ()) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end end)) diff --git a/src/gen/graphene_methods b/src/gen/graphene_methods index 244d1958..e3b61e46 100644 --- a/src/gen/graphene_methods +++ b/src/gen/graphene_methods @@ -2,135 +2,135 @@ quote $(Expr(:toplevel, quote function Box_alloc() ret = ccall(("graphene_box_alloc", libgraphene), Ptr{_GrapheneBox}, ()) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, true) + ret2 = convert(GrapheneBoxLike, ret, true) ret2 end - function contains_box(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _b::Union{GrapheneBox, Ref{_GrapheneBox}}) + function contains_box(instance::GrapheneBoxLike, _b::GrapheneBoxLike) ret = ccall(("graphene_box_contains_box", libgraphene), Cint, (Ptr{_GrapheneBox}, Ptr{_GrapheneBox}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function contains_point(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function contains_point(instance::GrapheneBoxLike, _point::GraphenePoint3DLike) ret = ccall(("graphene_box_contains_point", libgraphene), Cint, (Ptr{_GrapheneBox}, Ptr{_GraphenePoint3D}), instance, _point) ret2 = convert(Bool, ret) ret2 end - function equal(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _b::Union{GrapheneBox, Ref{_GrapheneBox}}) + function equal(instance::GrapheneBoxLike, _b::GrapheneBoxLike) ret = ccall(("graphene_box_equal", libgraphene), Cint, (Ptr{_GrapheneBox}, Ptr{_GrapheneBox}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function expand(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function expand(instance::GrapheneBoxLike, _point::GraphenePoint3DLike) m_res = Ref{_GrapheneBox}() ret = ccall(("graphene_box_expand", libgraphene), Nothing, (Ptr{_GrapheneBox}, Ptr{_GraphenePoint3D}, Ptr{_GrapheneBox}), instance, _point, m_res) _res = m_res[] _res end - function expand_scalar(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _scalar::Real) + function expand_scalar(instance::GrapheneBoxLike, _scalar::Real) m_res = Ref{_GrapheneBox}() ret = ccall(("graphene_box_expand_scalar", libgraphene), Nothing, (Ptr{_GrapheneBox}, Float32, Ptr{_GrapheneBox}), instance, _scalar, m_res) _res = m_res[] _res end - function expand_vec3(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _vec::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function expand_vec3(instance::GrapheneBoxLike, _vec::GrapheneVec3Like) m_res = Ref{_GrapheneBox}() ret = ccall(("graphene_box_expand_vec3", libgraphene), Nothing, (Ptr{_GrapheneBox}, Ptr{_GrapheneVec3}, Ptr{_GrapheneBox}), instance, _vec, m_res) _res = m_res[] _res end - function free(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function free(instance::GrapheneBoxLike) ret = ccall(("graphene_box_free", libgraphene), Nothing, (Ptr{_GrapheneBox},), instance) nothing end - function get_bounding_sphere(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function get_bounding_sphere(instance::GrapheneBoxLike) m_sphere = Ref{_GrapheneSphere}() ret = ccall(("graphene_box_get_bounding_sphere", libgraphene), Nothing, (Ptr{_GrapheneBox}, Ptr{_GrapheneSphere}), instance, m_sphere) _sphere = m_sphere[] _sphere end - function get_center(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function get_center(instance::GrapheneBoxLike) m_center = Ref{_GraphenePoint3D}() ret = ccall(("graphene_box_get_center", libgraphene), Nothing, (Ptr{_GrapheneBox}, Ptr{_GraphenePoint3D}), instance, m_center) _center = m_center[] _center end - function get_depth(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function get_depth(instance::GrapheneBoxLike) ret = ccall(("graphene_box_get_depth", libgraphene), Float32, (Ptr{_GrapheneBox},), instance) ret end - function get_height(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function get_height(instance::GrapheneBoxLike) ret = ccall(("graphene_box_get_height", libgraphene), Float32, (Ptr{_GrapheneBox},), instance) ret end - function get_max(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function get_max(instance::GrapheneBoxLike) m_max = Ref{_GraphenePoint3D}() ret = ccall(("graphene_box_get_max", libgraphene), Nothing, (Ptr{_GrapheneBox}, Ptr{_GraphenePoint3D}), instance, m_max) _max = m_max[] _max end - function get_min(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function get_min(instance::GrapheneBoxLike) m_min = Ref{_GraphenePoint3D}() ret = ccall(("graphene_box_get_min", libgraphene), Nothing, (Ptr{_GrapheneBox}, Ptr{_GraphenePoint3D}), instance, m_min) _min = m_min[] _min end - function get_size(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function get_size(instance::GrapheneBoxLike) m_size = Ref{_GrapheneVec3}() ret = ccall(("graphene_box_get_size", libgraphene), Nothing, (Ptr{_GrapheneBox}, Ptr{_GrapheneVec3}), instance, m_size) _size = m_size[] _size end - function get_vertices(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function get_vertices(instance::GrapheneBoxLike) m_vertices = Ref{Ptr{_GrapheneVec3}}() ret = ccall(("graphene_box_get_vertices", libgraphene), Nothing, (Ptr{_GrapheneBox}, Ptr{Ptr{_GrapheneVec3}}), instance, m_vertices) _vertices = m_vertices[] _vertices end - function get_width(instance::Union{GrapheneBox, Ref{_GrapheneBox}}) + function get_width(instance::GrapheneBoxLike) ret = ccall(("graphene_box_get_width", libgraphene), Float32, (Ptr{_GrapheneBox},), instance) ret end - function init(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _min::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}), _max::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}})) + function init(instance::GrapheneBoxLike, _min::Maybe(GraphenePoint3DLike), _max::Maybe(GraphenePoint3DLike)) _min_maybe = nothing_to_null(_min) _max_maybe = nothing_to_null(_max) ret = ccall(("graphene_box_init", libgraphene), Ptr{_GrapheneBox}, (Ptr{_GrapheneBox}, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _min_maybe, _max_maybe) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end - function init_from_box(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _src::Union{GrapheneBox, Ref{_GrapheneBox}}) + function init_from_box(instance::GrapheneBoxLike, _src::GrapheneBoxLike) ret = ccall(("graphene_box_init_from_box", libgraphene), Ptr{_GrapheneBox}, (Ptr{_GrapheneBox}, Ptr{_GrapheneBox}), instance, _src) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end - function init_from_points(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _points) + function init_from_points(instance::GrapheneBoxLike, _points) _points_arr = convert(Vector{_GraphenePoint3D}, _points) _n_points = length(_points) ret = ccall(("graphene_box_init_from_points", libgraphene), Ptr{_GrapheneBox}, (Ptr{_GrapheneBox}, UInt32, Ptr{_GraphenePoint3D}), instance, _n_points, _points_arr) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end - function init_from_vec3(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _min::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}}), _max::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}})) + function init_from_vec3(instance::GrapheneBoxLike, _min::Maybe(GrapheneVec3Like), _max::Maybe(GrapheneVec3Like)) _min_maybe = nothing_to_null(_min) _max_maybe = nothing_to_null(_max) ret = ccall(("graphene_box_init_from_vec3", libgraphene), Ptr{_GrapheneBox}, (Ptr{_GrapheneBox}, Ptr{_GrapheneVec3}, Ptr{_GrapheneVec3}), instance, _min_maybe, _max_maybe) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end - function init_from_vectors(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _vectors) + function init_from_vectors(instance::GrapheneBoxLike, _vectors) _vectors_arr = convert(Vector{_GrapheneVec3}, _vectors) _n_vectors = length(_vectors) ret = ccall(("graphene_box_init_from_vectors", libgraphene), Ptr{_GrapheneBox}, (Ptr{_GrapheneBox}, UInt32, Ptr{_GrapheneVec3}), instance, _n_vectors, _vectors_arr) - ret2 = convert(Union{GrapheneBox, Ref{_GrapheneBox}}, ret, false) + ret2 = convert(GrapheneBoxLike, ret, false) ret2 end - function intersection(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _b::Union{GrapheneBox, Ref{_GrapheneBox}}) + function intersection(instance::GrapheneBoxLike, _b::GrapheneBoxLike) m_res = Ref{_GrapheneBox}() ret = ccall(("graphene_box_intersection", libgraphene), Cint, (Ptr{_GrapheneBox}, Ptr{_GrapheneBox}, Ptr{_GrapheneBox}), instance, _b, m_res) ret2 = convert(Bool, ret) _res = m_res[] (ret2, _res) end - function union(instance::Union{GrapheneBox, Ref{_GrapheneBox}}, _b::Union{GrapheneBox, Ref{_GrapheneBox}}) + function union(instance::GrapheneBoxLike, _b::GrapheneBoxLike) m_res = Ref{_GrapheneBox}() ret = ccall(("graphene_box_union", libgraphene), Nothing, (Ptr{_GrapheneBox}, Ptr{_GrapheneBox}, Ptr{_GrapheneBox}), instance, _b, m_res) _res = m_res[] @@ -138,105 +138,105 @@ $(Expr(:toplevel, quote end function Euler_alloc() ret = ccall(("graphene_euler_alloc", libgraphene), Ptr{_GrapheneEuler}, ()) - ret2 = convert(Union{GrapheneEuler, Ref{_GrapheneEuler}}, ret, true) + ret2 = convert(GrapheneEulerLike, ret, true) ret2 end - function equal(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}, _b::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function equal(instance::GrapheneEulerLike, _b::GrapheneEulerLike) ret = ccall(("graphene_euler_equal", libgraphene), Cint, (Ptr{_GrapheneEuler}, Ptr{_GrapheneEuler}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function free(instance::GrapheneEulerLike) ret = ccall(("graphene_euler_free", libgraphene), Nothing, (Ptr{_GrapheneEuler},), instance) nothing end - function get_alpha(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function get_alpha(instance::GrapheneEulerLike) ret = ccall(("graphene_euler_get_alpha", libgraphene), Float32, (Ptr{_GrapheneEuler},), instance) ret end - function get_beta(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function get_beta(instance::GrapheneEulerLike) ret = ccall(("graphene_euler_get_beta", libgraphene), Float32, (Ptr{_GrapheneEuler},), instance) ret end - function get_gamma(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function get_gamma(instance::GrapheneEulerLike) ret = ccall(("graphene_euler_get_gamma", libgraphene), Float32, (Ptr{_GrapheneEuler},), instance) ret end - function get_order(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function get_order(instance::GrapheneEulerLike) ret = ccall(("graphene_euler_get_order", libgraphene), UInt32, (Ptr{_GrapheneEuler},), instance) ret2 = EulerOrder(ret) ret2 end - function get_x(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function get_x(instance::GrapheneEulerLike) ret = ccall(("graphene_euler_get_x", libgraphene), Float32, (Ptr{_GrapheneEuler},), instance) ret end - function get_y(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function get_y(instance::GrapheneEulerLike) ret = ccall(("graphene_euler_get_y", libgraphene), Float32, (Ptr{_GrapheneEuler},), instance) ret end - function get_z(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function get_z(instance::GrapheneEulerLike) ret = ccall(("graphene_euler_get_z", libgraphene), Float32, (Ptr{_GrapheneEuler},), instance) ret end - function init(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}, _x::Real, _y::Real, _z::Real) + function init(instance::GrapheneEulerLike, _x::Real, _y::Real, _z::Real) ret = ccall(("graphene_euler_init", libgraphene), Ptr{_GrapheneEuler}, (Ptr{_GrapheneEuler}, Float32, Float32, Float32), instance, _x, _y, _z) - ret2 = convert(Union{GrapheneEuler, Ref{_GrapheneEuler}}, ret, false) + ret2 = convert(GrapheneEulerLike, ret, false) ret2 end - function init_from_euler(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}, _src::Maybe(Union{GrapheneEuler, Ref{_GrapheneEuler}})) + function init_from_euler(instance::GrapheneEulerLike, _src::Maybe(GrapheneEulerLike)) _src_maybe = nothing_to_null(_src) ret = ccall(("graphene_euler_init_from_euler", libgraphene), Ptr{_GrapheneEuler}, (Ptr{_GrapheneEuler}, Ptr{_GrapheneEuler}), instance, _src_maybe) - ret2 = convert(Union{GrapheneEuler, Ref{_GrapheneEuler}}, ret, false) + ret2 = convert(GrapheneEulerLike, ret, false) ret2 end - function init_from_matrix(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}, _m::Maybe(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}), _order) + function init_from_matrix(instance::GrapheneEulerLike, _m::Maybe(GrapheneMatrixLike), _order) _m_maybe = nothing_to_null(_m) ret = ccall(("graphene_euler_init_from_matrix", libgraphene), Ptr{_GrapheneEuler}, (Ptr{_GrapheneEuler}, Ptr{_GrapheneMatrix}, UInt32), instance, _m_maybe, _order) - ret2 = convert(Union{GrapheneEuler, Ref{_GrapheneEuler}}, ret, false) + ret2 = convert(GrapheneEulerLike, ret, false) ret2 end - function init_from_quaternion(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}, _q::Maybe(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}), _order) + function init_from_quaternion(instance::GrapheneEulerLike, _q::Maybe(GrapheneQuaternionLike), _order) _q_maybe = nothing_to_null(_q) ret = ccall(("graphene_euler_init_from_quaternion", libgraphene), Ptr{_GrapheneEuler}, (Ptr{_GrapheneEuler}, Ptr{_GrapheneQuaternion}, UInt32), instance, _q_maybe, _order) - ret2 = convert(Union{GrapheneEuler, Ref{_GrapheneEuler}}, ret, false) + ret2 = convert(GrapheneEulerLike, ret, false) ret2 end - function init_from_radians(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}, _x::Real, _y::Real, _z::Real, _order) + function init_from_radians(instance::GrapheneEulerLike, _x::Real, _y::Real, _z::Real, _order) ret = ccall(("graphene_euler_init_from_radians", libgraphene), Ptr{_GrapheneEuler}, (Ptr{_GrapheneEuler}, Float32, Float32, Float32, UInt32), instance, _x, _y, _z, _order) - ret2 = convert(Union{GrapheneEuler, Ref{_GrapheneEuler}}, ret, false) + ret2 = convert(GrapheneEulerLike, ret, false) ret2 end - function init_from_vec3(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}, _v::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}}), _order) + function init_from_vec3(instance::GrapheneEulerLike, _v::Maybe(GrapheneVec3Like), _order) _v_maybe = nothing_to_null(_v) ret = ccall(("graphene_euler_init_from_vec3", libgraphene), Ptr{_GrapheneEuler}, (Ptr{_GrapheneEuler}, Ptr{_GrapheneVec3}, UInt32), instance, _v_maybe, _order) - ret2 = convert(Union{GrapheneEuler, Ref{_GrapheneEuler}}, ret, false) + ret2 = convert(GrapheneEulerLike, ret, false) ret2 end - function init_with_order(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}, _x::Real, _y::Real, _z::Real, _order) + function init_with_order(instance::GrapheneEulerLike, _x::Real, _y::Real, _z::Real, _order) ret = ccall(("graphene_euler_init_with_order", libgraphene), Ptr{_GrapheneEuler}, (Ptr{_GrapheneEuler}, Float32, Float32, Float32, UInt32), instance, _x, _y, _z, _order) - ret2 = convert(Union{GrapheneEuler, Ref{_GrapheneEuler}}, ret, false) + ret2 = convert(GrapheneEulerLike, ret, false) ret2 end - function reorder(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}, _order) + function reorder(instance::GrapheneEulerLike, _order) m_res = Ref{_GrapheneEuler}() ret = ccall(("graphene_euler_reorder", libgraphene), Nothing, (Ptr{_GrapheneEuler}, UInt32, Ptr{_GrapheneEuler}), instance, _order, m_res) _res = m_res[] _res end - function to_matrix(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function to_matrix(instance::GrapheneEulerLike) m_res = Ref{_GrapheneMatrix}() ret = ccall(("graphene_euler_to_matrix", libgraphene), Nothing, (Ptr{_GrapheneEuler}, Ptr{_GrapheneMatrix}), instance, m_res) _res = m_res[] _res end - function to_quaternion(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function to_quaternion(instance::GrapheneEulerLike) m_res = Ref{_GrapheneQuaternion}() ret = ccall(("graphene_euler_to_quaternion", libgraphene), Nothing, (Ptr{_GrapheneEuler}, Ptr{_GrapheneQuaternion}), instance, m_res) _res = m_res[] _res end - function to_vec3(instance::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function to_vec3(instance::GrapheneEulerLike) m_res = Ref{_GrapheneVec3}() ret = ccall(("graphene_euler_to_vec3", libgraphene), Nothing, (Ptr{_GrapheneEuler}, Ptr{_GrapheneVec3}), instance, m_res) _res = m_res[] @@ -244,60 +244,60 @@ $(Expr(:toplevel, quote end function Frustum_alloc() ret = ccall(("graphene_frustum_alloc", libgraphene), Ptr{_GrapheneFrustum}, ()) - ret2 = convert(Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, ret, true) + ret2 = convert(GrapheneFrustumLike, ret, true) ret2 end - function contains_point(instance::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function contains_point(instance::GrapheneFrustumLike, _point::GraphenePoint3DLike) ret = ccall(("graphene_frustum_contains_point", libgraphene), Cint, (Ptr{_GrapheneFrustum}, Ptr{_GraphenePoint3D}), instance, _point) ret2 = convert(Bool, ret) ret2 end - function equal(instance::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, _b::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}) + function equal(instance::GrapheneFrustumLike, _b::GrapheneFrustumLike) ret = ccall(("graphene_frustum_equal", libgraphene), Cint, (Ptr{_GrapheneFrustum}, Ptr{_GrapheneFrustum}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}) + function free(instance::GrapheneFrustumLike) ret = ccall(("graphene_frustum_free", libgraphene), Nothing, (Ptr{_GrapheneFrustum},), instance) nothing end - function get_planes(instance::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}) + function get_planes(instance::GrapheneFrustumLike) m_planes = Ref{Ptr{_GraphenePlane}}() ret = ccall(("graphene_frustum_get_planes", libgraphene), Nothing, (Ptr{_GrapheneFrustum}, Ptr{Ptr{_GraphenePlane}}), instance, m_planes) _planes = m_planes[] _planes end - function init(instance::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, _p0::Union{GraphenePlane, Ref{_GraphenePlane}}, _p1::Union{GraphenePlane, Ref{_GraphenePlane}}, _p2::Union{GraphenePlane, Ref{_GraphenePlane}}, _p3::Union{GraphenePlane, Ref{_GraphenePlane}}, _p4::Union{GraphenePlane, Ref{_GraphenePlane}}, _p5::Union{GraphenePlane, Ref{_GraphenePlane}}) + function init(instance::GrapheneFrustumLike, _p0::GraphenePlaneLike, _p1::GraphenePlaneLike, _p2::GraphenePlaneLike, _p3::GraphenePlaneLike, _p4::GraphenePlaneLike, _p5::GraphenePlaneLike) ret = ccall(("graphene_frustum_init", libgraphene), Ptr{_GrapheneFrustum}, (Ptr{_GrapheneFrustum}, Ptr{_GraphenePlane}, Ptr{_GraphenePlane}, Ptr{_GraphenePlane}, Ptr{_GraphenePlane}, Ptr{_GraphenePlane}, Ptr{_GraphenePlane}), instance, _p0, _p1, _p2, _p3, _p4, _p5) - ret2 = convert(Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, ret, false) + ret2 = convert(GrapheneFrustumLike, ret, false) ret2 end - function init_from_frustum(instance::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, _src::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}) + function init_from_frustum(instance::GrapheneFrustumLike, _src::GrapheneFrustumLike) ret = ccall(("graphene_frustum_init_from_frustum", libgraphene), Ptr{_GrapheneFrustum}, (Ptr{_GrapheneFrustum}, Ptr{_GrapheneFrustum}), instance, _src) - ret2 = convert(Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, ret, false) + ret2 = convert(GrapheneFrustumLike, ret, false) ret2 end - function init_from_matrix(instance::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, _matrix::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function init_from_matrix(instance::GrapheneFrustumLike, _matrix::GrapheneMatrixLike) ret = ccall(("graphene_frustum_init_from_matrix", libgraphene), Ptr{_GrapheneFrustum}, (Ptr{_GrapheneFrustum}, Ptr{_GrapheneMatrix}), instance, _matrix) - ret2 = convert(Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, ret, false) + ret2 = convert(GrapheneFrustumLike, ret, false) ret2 end - function intersects_box(instance::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, _box::Union{GrapheneBox, Ref{_GrapheneBox}}) + function intersects_box(instance::GrapheneFrustumLike, _box::GrapheneBoxLike) ret = ccall(("graphene_frustum_intersects_box", libgraphene), Cint, (Ptr{_GrapheneFrustum}, Ptr{_GrapheneBox}), instance, _box) ret2 = convert(Bool, ret) ret2 end - function intersects_sphere(instance::Union{GrapheneFrustum, Ref{_GrapheneFrustum}}, _sphere::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function intersects_sphere(instance::GrapheneFrustumLike, _sphere::GrapheneSphereLike) ret = ccall(("graphene_frustum_intersects_sphere", libgraphene), Cint, (Ptr{_GrapheneFrustum}, Ptr{_GrapheneSphere}), instance, _sphere) ret2 = convert(Bool, ret) ret2 end function Matrix_alloc() ret = ccall(("graphene_matrix_alloc", libgraphene), Ptr{_GrapheneMatrix}, ()) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, true) + ret2 = convert(GrapheneMatrixLike, ret, true) ret2 end - function decompose(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function decompose(instance::GrapheneMatrixLike) m_translate = Ref{_GrapheneVec3}() m_scale = Ref{_GrapheneVec3}() m_rotate = Ref{_GrapheneQuaternion}() @@ -312,243 +312,243 @@ $(Expr(:toplevel, quote _perspective = m_perspective[] (ret2, _translate, _scale, _rotate, _shear, _perspective) end - function determinant(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function determinant(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_determinant", libgraphene), Float32, (Ptr{_GrapheneMatrix},), instance) ret end - function equal(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _b::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function equal(instance::GrapheneMatrixLike, _b::GrapheneMatrixLike) ret = ccall(("graphene_matrix_equal", libgraphene), Cint, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function equal_fast(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _b::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function equal_fast(instance::GrapheneMatrixLike, _b::GrapheneMatrixLike) ret = ccall(("graphene_matrix_equal_fast", libgraphene), Cint, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function free(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_free", libgraphene), Nothing, (Ptr{_GrapheneMatrix},), instance) nothing end - function get_row(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _index_::Integer) + function get_row(instance::GrapheneMatrixLike, _index_::Integer) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_matrix_get_row", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, UInt32, Ptr{_GrapheneVec4}), instance, _index_, m_res) _res = m_res[] _res end - function get_value(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _row::Integer, _col::Integer) + function get_value(instance::GrapheneMatrixLike, _row::Integer, _col::Integer) ret = ccall(("graphene_matrix_get_value", libgraphene), Float32, (Ptr{_GrapheneMatrix}, UInt32, UInt32), instance, _row, _col) ret end - function get_x_scale(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function get_x_scale(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_get_x_scale", libgraphene), Float32, (Ptr{_GrapheneMatrix},), instance) ret end - function get_x_translation(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function get_x_translation(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_get_x_translation", libgraphene), Float32, (Ptr{_GrapheneMatrix},), instance) ret end - function get_y_scale(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function get_y_scale(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_get_y_scale", libgraphene), Float32, (Ptr{_GrapheneMatrix},), instance) ret end - function get_y_translation(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function get_y_translation(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_get_y_translation", libgraphene), Float32, (Ptr{_GrapheneMatrix},), instance) ret end - function get_z_scale(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function get_z_scale(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_get_z_scale", libgraphene), Float32, (Ptr{_GrapheneMatrix},), instance) ret end - function get_z_translation(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function get_z_translation(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_get_z_translation", libgraphene), Float32, (Ptr{_GrapheneMatrix},), instance) ret end - function init_from_2d(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _xx::Real, _yx::Real, _xy::Real, _yy::Real, _x_0::Real, _y_0::Real) + function init_from_2d(instance::GrapheneMatrixLike, _xx::Real, _yx::Real, _xy::Real, _yy::Real, _x_0::Real, _y_0::Real) ret = ccall(("graphene_matrix_init_from_2d", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Float64, Float64, Float64, Float64, Float64, Float64), instance, _xx, _yx, _xy, _yy, _x_0, _y_0) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_from_float(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _v) + function init_from_float(instance::GrapheneMatrixLike, _v) _v_arr = convert(Vector{Float32}, _v) ret = ccall(("graphene_matrix_init_from_float", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Ptr{Float32}), instance, _v_arr) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_from_matrix(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _src::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function init_from_matrix(instance::GrapheneMatrixLike, _src::GrapheneMatrixLike) ret = ccall(("graphene_matrix_init_from_matrix", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}), instance, _src) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_from_vec4(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _v0::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _v1::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _v2::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _v3::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function init_from_vec4(instance::GrapheneMatrixLike, _v0::GrapheneVec4Like, _v1::GrapheneVec4Like, _v2::GrapheneVec4Like, _v3::GrapheneVec4Like) ret = ccall(("graphene_matrix_init_from_vec4", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _v0, _v1, _v2, _v3) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_frustum(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _left::Real, _right::Real, _bottom::Real, _top::Real, _z_near::Real, _z_far::Real) + function init_frustum(instance::GrapheneMatrixLike, _left::Real, _right::Real, _bottom::Real, _top::Real, _z_near::Real, _z_far::Real) ret = ccall(("graphene_matrix_init_frustum", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Float32, Float32, Float32, Float32, Float32, Float32), instance, _left, _right, _bottom, _top, _z_near, _z_far) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_identity(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function init_identity(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_init_identity", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix},), instance) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_look_at(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _eye::Union{GrapheneVec3, Ref{_GrapheneVec3}}, _center::Union{GrapheneVec3, Ref{_GrapheneVec3}}, _up::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function init_look_at(instance::GrapheneMatrixLike, _eye::GrapheneVec3Like, _center::GrapheneVec3Like, _up::GrapheneVec3Like) ret = ccall(("graphene_matrix_init_look_at", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneVec3}, Ptr{_GrapheneVec3}, Ptr{_GrapheneVec3}), instance, _eye, _center, _up) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_ortho(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _left::Real, _right::Real, _top::Real, _bottom::Real, _z_near::Real, _z_far::Real) + function init_ortho(instance::GrapheneMatrixLike, _left::Real, _right::Real, _top::Real, _bottom::Real, _z_near::Real, _z_far::Real) ret = ccall(("graphene_matrix_init_ortho", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Float32, Float32, Float32, Float32, Float32, Float32), instance, _left, _right, _top, _bottom, _z_near, _z_far) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_perspective(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _fovy::Real, _aspect::Real, _z_near::Real, _z_far::Real) + function init_perspective(instance::GrapheneMatrixLike, _fovy::Real, _aspect::Real, _z_near::Real, _z_far::Real) ret = ccall(("graphene_matrix_init_perspective", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Float32, Float32, Float32, Float32), instance, _fovy, _aspect, _z_near, _z_far) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_rotate(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _angle::Real, _axis::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function init_rotate(instance::GrapheneMatrixLike, _angle::Real, _axis::GrapheneVec3Like) ret = ccall(("graphene_matrix_init_rotate", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Float32, Ptr{_GrapheneVec3}), instance, _angle, _axis) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_scale(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _x::Real, _y::Real, _z::Real) + function init_scale(instance::GrapheneMatrixLike, _x::Real, _y::Real, _z::Real) ret = ccall(("graphene_matrix_init_scale", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Float32, Float32, Float32), instance, _x, _y, _z) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_skew(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _x_skew::Real, _y_skew::Real) + function init_skew(instance::GrapheneMatrixLike, _x_skew::Real, _y_skew::Real) ret = ccall(("graphene_matrix_init_skew", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Float32, Float32), instance, _x_skew, _y_skew) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function init_translate(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _p::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function init_translate(instance::GrapheneMatrixLike, _p::GraphenePoint3DLike) ret = ccall(("graphene_matrix_init_translate", libgraphene), Ptr{_GrapheneMatrix}, (Ptr{_GrapheneMatrix}, Ptr{_GraphenePoint3D}), instance, _p) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end - function interpolate(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _b::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _factor::Real) + function interpolate(instance::GrapheneMatrixLike, _b::GrapheneMatrixLike, _factor::Real) m_res = Ref{_GrapheneMatrix}() ret = ccall(("graphene_matrix_interpolate", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}, Float64, Ptr{_GrapheneMatrix}), instance, _b, _factor, m_res) _res = m_res[] _res end - function inverse(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function inverse(instance::GrapheneMatrixLike) m_res = Ref{_GrapheneMatrix}() ret = ccall(("graphene_matrix_inverse", libgraphene), Cint, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}), instance, m_res) ret2 = convert(Bool, ret) _res = m_res[] (ret2, _res) end - function is_2d(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function is_2d(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_is_2d", libgraphene), Cint, (Ptr{_GrapheneMatrix},), instance) ret2 = convert(Bool, ret) ret2 end - function is_backface_visible(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function is_backface_visible(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_is_backface_visible", libgraphene), Cint, (Ptr{_GrapheneMatrix},), instance) ret2 = convert(Bool, ret) ret2 end - function is_identity(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function is_identity(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_is_identity", libgraphene), Cint, (Ptr{_GrapheneMatrix},), instance) ret2 = convert(Bool, ret) ret2 end - function is_singular(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function is_singular(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_is_singular", libgraphene), Cint, (Ptr{_GrapheneMatrix},), instance) ret2 = convert(Bool, ret) ret2 end - function multiply(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _b::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function multiply(instance::GrapheneMatrixLike, _b::GrapheneMatrixLike) m_res = Ref{_GrapheneMatrix}() ret = ccall(("graphene_matrix_multiply", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}), instance, _b, m_res) _res = m_res[] _res end - function near(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _b::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _epsilon::Real) + function near(instance::GrapheneMatrixLike, _b::GrapheneMatrixLike, _epsilon::Real) ret = ccall(("graphene_matrix_near", libgraphene), Cint, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}, Float32), instance, _b, _epsilon) ret2 = convert(Bool, ret) ret2 end - function normalize(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function normalize(instance::GrapheneMatrixLike) m_res = Ref{_GrapheneMatrix}() ret = ccall(("graphene_matrix_normalize", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}), instance, m_res) _res = m_res[] _res end - function perspective(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _depth::Real) + function perspective(instance::GrapheneMatrixLike, _depth::Real) m_res = Ref{_GrapheneMatrix}() ret = ccall(("graphene_matrix_perspective", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Float32, Ptr{_GrapheneMatrix}), instance, _depth, m_res) _res = m_res[] _res end - function print(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function print(instance::GrapheneMatrixLike) ret = ccall(("graphene_matrix_print", libgraphene), Nothing, (Ptr{_GrapheneMatrix},), instance) nothing end - function project_point(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _p::Union{GraphenePoint, Ref{_GraphenePoint}}) + function project_point(instance::GrapheneMatrixLike, _p::GraphenePointLike) m_res = Ref{_GraphenePoint}() ret = ccall(("graphene_matrix_project_point", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}), instance, _p, m_res) _res = m_res[] _res end - function project_rect(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _r::Union{GrapheneRect, Ref{_GrapheneRect}}) + function project_rect(instance::GrapheneMatrixLike, _r::GrapheneRectLike) m_res = Ref{_GrapheneQuad}() ret = ccall(("graphene_matrix_project_rect", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneRect}, Ptr{_GrapheneQuad}), instance, _r, m_res) _res = m_res[] _res end - function project_rect_bounds(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _r::Union{GrapheneRect, Ref{_GrapheneRect}}) + function project_rect_bounds(instance::GrapheneMatrixLike, _r::GrapheneRectLike) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_matrix_project_rect_bounds", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _r, m_res) _res = m_res[] _res end - function rotate(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _angle::Real, _axis::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function rotate(instance::GrapheneMatrixLike, _angle::Real, _axis::GrapheneVec3Like) ret = ccall(("graphene_matrix_rotate", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Float32, Ptr{_GrapheneVec3}), instance, _angle, _axis) nothing end - function rotate_euler(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _e::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function rotate_euler(instance::GrapheneMatrixLike, _e::GrapheneEulerLike) ret = ccall(("graphene_matrix_rotate_euler", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneEuler}), instance, _e) nothing end - function rotate_quaternion(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _q::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function rotate_quaternion(instance::GrapheneMatrixLike, _q::GrapheneQuaternionLike) ret = ccall(("graphene_matrix_rotate_quaternion", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneQuaternion}), instance, _q) nothing end - function rotate_x(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _angle::Real) + function rotate_x(instance::GrapheneMatrixLike, _angle::Real) ret = ccall(("graphene_matrix_rotate_x", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Float32), instance, _angle) nothing end - function rotate_y(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _angle::Real) + function rotate_y(instance::GrapheneMatrixLike, _angle::Real) ret = ccall(("graphene_matrix_rotate_y", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Float32), instance, _angle) nothing end - function rotate_z(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _angle::Real) + function rotate_z(instance::GrapheneMatrixLike, _angle::Real) ret = ccall(("graphene_matrix_rotate_z", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Float32), instance, _angle) nothing end - function scale(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _factor_x::Real, _factor_y::Real, _factor_z::Real) + function scale(instance::GrapheneMatrixLike, _factor_x::Real, _factor_y::Real, _factor_z::Real) ret = ccall(("graphene_matrix_scale", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Float32, Float32, Float32), instance, _factor_x, _factor_y, _factor_z) nothing end - function skew_xy(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _factor::Real) + function skew_xy(instance::GrapheneMatrixLike, _factor::Real) ret = ccall(("graphene_matrix_skew_xy", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Float32), instance, _factor) nothing end - function skew_xz(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _factor::Real) + function skew_xz(instance::GrapheneMatrixLike, _factor::Real) ret = ccall(("graphene_matrix_skew_xz", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Float32), instance, _factor) nothing end - function skew_yz(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _factor::Real) + function skew_yz(instance::GrapheneMatrixLike, _factor::Real) ret = ccall(("graphene_matrix_skew_yz", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Float32), instance, _factor) nothing end - function to_2d(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function to_2d(instance::GrapheneMatrixLike) m_xx = Ref{Float64}() m_yx = Ref{Float64}() m_xy = Ref{Float64}() @@ -565,89 +565,89 @@ $(Expr(:toplevel, quote _y_0 = m_y_0[] (ret2, _xx, _yx, _xy, _yy, _x_0, _y_0) end - function to_float(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function to_float(instance::GrapheneMatrixLike) m_v = Ref{Ptr{Float32}}() ret = ccall(("graphene_matrix_to_float", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{Ptr{Float32}}), instance, m_v) _v = m_v[] _v end - function transform_bounds(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _r::Union{GrapheneRect, Ref{_GrapheneRect}}) + function transform_bounds(instance::GrapheneMatrixLike, _r::GrapheneRectLike) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_matrix_transform_bounds", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _r, m_res) _res = m_res[] _res end - function transform_box(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _b::Union{GrapheneBox, Ref{_GrapheneBox}}) + function transform_box(instance::GrapheneMatrixLike, _b::GrapheneBoxLike) m_res = Ref{_GrapheneBox}() ret = ccall(("graphene_matrix_transform_box", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneBox}, Ptr{_GrapheneBox}), instance, _b, m_res) _res = m_res[] _res end - function transform_point(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _p::Union{GraphenePoint, Ref{_GraphenePoint}}) + function transform_point(instance::GrapheneMatrixLike, _p::GraphenePointLike) m_res = Ref{_GraphenePoint}() ret = ccall(("graphene_matrix_transform_point", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}), instance, _p, m_res) _res = m_res[] _res end - function transform_point3d(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _p::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function transform_point3d(instance::GrapheneMatrixLike, _p::GraphenePoint3DLike) m_res = Ref{_GraphenePoint3D}() ret = ccall(("graphene_matrix_transform_point3d", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _p, m_res) _res = m_res[] _res end - function transform_ray(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _r::Union{GrapheneRay, Ref{_GrapheneRay}}) + function transform_ray(instance::GrapheneMatrixLike, _r::GrapheneRayLike) m_res = Ref{_GrapheneRay}() ret = ccall(("graphene_matrix_transform_ray", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneRay}, Ptr{_GrapheneRay}), instance, _r, m_res) _res = m_res[] _res end - function transform_rect(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _r::Union{GrapheneRect, Ref{_GrapheneRect}}) + function transform_rect(instance::GrapheneMatrixLike, _r::GrapheneRectLike) m_res = Ref{_GrapheneQuad}() ret = ccall(("graphene_matrix_transform_rect", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneRect}, Ptr{_GrapheneQuad}), instance, _r, m_res) _res = m_res[] _res end - function transform_sphere(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _s::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function transform_sphere(instance::GrapheneMatrixLike, _s::GrapheneSphereLike) m_res = Ref{_GrapheneSphere}() ret = ccall(("graphene_matrix_transform_sphere", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneSphere}, Ptr{_GrapheneSphere}), instance, _s, m_res) _res = m_res[] _res end - function transform_vec3(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _v::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function transform_vec3(instance::GrapheneMatrixLike, _v::GrapheneVec3Like) m_res = Ref{_GrapheneVec3}() ret = ccall(("graphene_matrix_transform_vec3", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneVec3}, Ptr{_GrapheneVec3}), instance, _v, m_res) _res = m_res[] _res end - function transform_vec4(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _v::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function transform_vec4(instance::GrapheneMatrixLike, _v::GrapheneVec4Like) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_matrix_transform_vec4", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _v, m_res) _res = m_res[] _res end - function translate(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _pos::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function translate(instance::GrapheneMatrixLike, _pos::GraphenePoint3DLike) ret = ccall(("graphene_matrix_translate", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GraphenePoint3D}), instance, _pos) nothing end - function transpose(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function transpose(instance::GrapheneMatrixLike) m_res = Ref{_GrapheneMatrix}() ret = ccall(("graphene_matrix_transpose", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}), instance, m_res) _res = m_res[] _res end - function unproject_point3d(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _modelview::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function unproject_point3d(instance::GrapheneMatrixLike, _modelview::GrapheneMatrixLike, _point::GraphenePoint3DLike) m_res = Ref{_GraphenePoint3D}() ret = ccall(("graphene_matrix_unproject_point3d", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _modelview, _point, m_res) _res = m_res[] _res end - function untransform_bounds(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _r::Union{GrapheneRect, Ref{_GrapheneRect}}, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function untransform_bounds(instance::GrapheneMatrixLike, _r::GrapheneRectLike, _bounds::GrapheneRectLike) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_matrix_untransform_bounds", libgraphene), Nothing, (Ptr{_GrapheneMatrix}, Ptr{_GrapheneRect}, Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _r, _bounds, m_res) _res = m_res[] _res end - function untransform_point(instance::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _p::Union{GraphenePoint, Ref{_GraphenePoint}}, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function untransform_point(instance::GrapheneMatrixLike, _p::GraphenePointLike, _bounds::GrapheneRectLike) m_res = Ref{_GraphenePoint}() ret = ccall(("graphene_matrix_untransform_point", libgraphene), Cint, (Ptr{_GrapheneMatrix}, Ptr{_GraphenePoint}, Ptr{_GrapheneRect}, Ptr{_GraphenePoint}), instance, _p, _bounds, m_res) ret2 = convert(Bool, ret) @@ -656,71 +656,71 @@ $(Expr(:toplevel, quote end function Plane_alloc() ret = ccall(("graphene_plane_alloc", libgraphene), Ptr{_GraphenePlane}, ()) - ret2 = convert(Union{GraphenePlane, Ref{_GraphenePlane}}, ret, true) + ret2 = convert(GraphenePlaneLike, ret, true) ret2 end - function distance(instance::Union{GraphenePlane, Ref{_GraphenePlane}}, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function distance(instance::GraphenePlaneLike, _point::GraphenePoint3DLike) ret = ccall(("graphene_plane_distance", libgraphene), Float32, (Ptr{_GraphenePlane}, Ptr{_GraphenePoint3D}), instance, _point) ret end - function equal(instance::Union{GraphenePlane, Ref{_GraphenePlane}}, _b::Union{GraphenePlane, Ref{_GraphenePlane}}) + function equal(instance::GraphenePlaneLike, _b::GraphenePlaneLike) ret = ccall(("graphene_plane_equal", libgraphene), Cint, (Ptr{_GraphenePlane}, Ptr{_GraphenePlane}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GraphenePlane, Ref{_GraphenePlane}}) + function free(instance::GraphenePlaneLike) ret = ccall(("graphene_plane_free", libgraphene), Nothing, (Ptr{_GraphenePlane},), instance) nothing end - function get_constant(instance::Union{GraphenePlane, Ref{_GraphenePlane}}) + function get_constant(instance::GraphenePlaneLike) ret = ccall(("graphene_plane_get_constant", libgraphene), Float32, (Ptr{_GraphenePlane},), instance) ret end - function get_normal(instance::Union{GraphenePlane, Ref{_GraphenePlane}}) + function get_normal(instance::GraphenePlaneLike) m_normal = Ref{_GrapheneVec3}() ret = ccall(("graphene_plane_get_normal", libgraphene), Nothing, (Ptr{_GraphenePlane}, Ptr{_GrapheneVec3}), instance, m_normal) _normal = m_normal[] _normal end - function init(instance::Union{GraphenePlane, Ref{_GraphenePlane}}, _normal::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}}), _constant::Real) + function init(instance::GraphenePlaneLike, _normal::Maybe(GrapheneVec3Like), _constant::Real) _normal_maybe = nothing_to_null(_normal) ret = ccall(("graphene_plane_init", libgraphene), Ptr{_GraphenePlane}, (Ptr{_GraphenePlane}, Ptr{_GrapheneVec3}, Float32), instance, _normal_maybe, _constant) - ret2 = convert(Union{GraphenePlane, Ref{_GraphenePlane}}, ret, false) + ret2 = convert(GraphenePlaneLike, ret, false) ret2 end - function init_from_plane(instance::Union{GraphenePlane, Ref{_GraphenePlane}}, _src::Union{GraphenePlane, Ref{_GraphenePlane}}) + function init_from_plane(instance::GraphenePlaneLike, _src::GraphenePlaneLike) ret = ccall(("graphene_plane_init_from_plane", libgraphene), Ptr{_GraphenePlane}, (Ptr{_GraphenePlane}, Ptr{_GraphenePlane}), instance, _src) - ret2 = convert(Union{GraphenePlane, Ref{_GraphenePlane}}, ret, false) + ret2 = convert(GraphenePlaneLike, ret, false) ret2 end - function init_from_point(instance::Union{GraphenePlane, Ref{_GraphenePlane}}, _normal::Union{GrapheneVec3, Ref{_GrapheneVec3}}, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function init_from_point(instance::GraphenePlaneLike, _normal::GrapheneVec3Like, _point::GraphenePoint3DLike) ret = ccall(("graphene_plane_init_from_point", libgraphene), Ptr{_GraphenePlane}, (Ptr{_GraphenePlane}, Ptr{_GrapheneVec3}, Ptr{_GraphenePoint3D}), instance, _normal, _point) - ret2 = convert(Union{GraphenePlane, Ref{_GraphenePlane}}, ret, false) + ret2 = convert(GraphenePlaneLike, ret, false) ret2 end - function init_from_points(instance::Union{GraphenePlane, Ref{_GraphenePlane}}, _a::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _b::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _c::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function init_from_points(instance::GraphenePlaneLike, _a::GraphenePoint3DLike, _b::GraphenePoint3DLike, _c::GraphenePoint3DLike) ret = ccall(("graphene_plane_init_from_points", libgraphene), Ptr{_GraphenePlane}, (Ptr{_GraphenePlane}, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _a, _b, _c) - ret2 = convert(Union{GraphenePlane, Ref{_GraphenePlane}}, ret, false) + ret2 = convert(GraphenePlaneLike, ret, false) ret2 end - function init_from_vec4(instance::Union{GraphenePlane, Ref{_GraphenePlane}}, _src::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function init_from_vec4(instance::GraphenePlaneLike, _src::GrapheneVec4Like) ret = ccall(("graphene_plane_init_from_vec4", libgraphene), Ptr{_GraphenePlane}, (Ptr{_GraphenePlane}, Ptr{_GrapheneVec4}), instance, _src) - ret2 = convert(Union{GraphenePlane, Ref{_GraphenePlane}}, ret, false) + ret2 = convert(GraphenePlaneLike, ret, false) ret2 end - function negate(instance::Union{GraphenePlane, Ref{_GraphenePlane}}) + function negate(instance::GraphenePlaneLike) m_res = Ref{_GraphenePlane}() ret = ccall(("graphene_plane_negate", libgraphene), Nothing, (Ptr{_GraphenePlane}, Ptr{_GraphenePlane}), instance, m_res) _res = m_res[] _res end - function normalize(instance::Union{GraphenePlane, Ref{_GraphenePlane}}) + function normalize(instance::GraphenePlaneLike) m_res = Ref{_GraphenePlane}() ret = ccall(("graphene_plane_normalize", libgraphene), Nothing, (Ptr{_GraphenePlane}, Ptr{_GraphenePlane}), instance, m_res) _res = m_res[] _res end - function transform(instance::Union{GraphenePlane, Ref{_GraphenePlane}}, _matrix::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _normal_matrix::Maybe(Union{GrapheneMatrix, Ref{_GrapheneMatrix}})) + function transform(instance::GraphenePlaneLike, _matrix::GrapheneMatrixLike, _normal_matrix::Maybe(GrapheneMatrixLike)) _normal_matrix_maybe = nothing_to_null(_normal_matrix) m_res = Ref{_GraphenePlane}() ret = ccall(("graphene_plane_transform", libgraphene), Nothing, (Ptr{_GraphenePlane}, Ptr{_GrapheneMatrix}, Ptr{_GrapheneMatrix}, Ptr{_GraphenePlane}), instance, _matrix, _normal_matrix_maybe, m_res) @@ -729,10 +729,10 @@ $(Expr(:toplevel, quote end function Point_alloc() ret = ccall(("graphene_point_alloc", libgraphene), Ptr{_GraphenePoint}, ()) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, true) + ret2 = convert(GraphenePointLike, ret, true) ret2 end - function distance(instance::Union{GraphenePoint, Ref{_GraphenePoint}}, _b::Union{GraphenePoint, Ref{_GraphenePoint}}) + function distance(instance::GraphenePointLike, _b::GraphenePointLike) m_d_x = Ref{Float32}() m_d_y = Ref{Float32}() ret = ccall(("graphene_point_distance", libgraphene), Float32, (Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Ptr{Float32}, Ptr{Float32}), instance, _b, m_d_x, m_d_y) @@ -740,42 +740,42 @@ $(Expr(:toplevel, quote _d_y = m_d_y[] (ret, _d_x, _d_y) end - function equal(instance::Union{GraphenePoint, Ref{_GraphenePoint}}, _b::Union{GraphenePoint, Ref{_GraphenePoint}}) + function equal(instance::GraphenePointLike, _b::GraphenePointLike) ret = ccall(("graphene_point_equal", libgraphene), Cint, (Ptr{_GraphenePoint}, Ptr{_GraphenePoint}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GraphenePoint, Ref{_GraphenePoint}}) + function free(instance::GraphenePointLike) ret = ccall(("graphene_point_free", libgraphene), Nothing, (Ptr{_GraphenePoint},), instance) nothing end - function init(instance::Union{GraphenePoint, Ref{_GraphenePoint}}, _x::Real, _y::Real) + function init(instance::GraphenePointLike, _x::Real, _y::Real) ret = ccall(("graphene_point_init", libgraphene), Ptr{_GraphenePoint}, (Ptr{_GraphenePoint}, Float32, Float32), instance, _x, _y) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end - function init_from_point(instance::Union{GraphenePoint, Ref{_GraphenePoint}}, _src::Union{GraphenePoint, Ref{_GraphenePoint}}) + function init_from_point(instance::GraphenePointLike, _src::GraphenePointLike) ret = ccall(("graphene_point_init_from_point", libgraphene), Ptr{_GraphenePoint}, (Ptr{_GraphenePoint}, Ptr{_GraphenePoint}), instance, _src) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end - function init_from_vec2(instance::Union{GraphenePoint, Ref{_GraphenePoint}}, _src::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function init_from_vec2(instance::GraphenePointLike, _src::GrapheneVec2Like) ret = ccall(("graphene_point_init_from_vec2", libgraphene), Ptr{_GraphenePoint}, (Ptr{_GraphenePoint}, Ptr{_GrapheneVec2}), instance, _src) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end - function interpolate(instance::Union{GraphenePoint, Ref{_GraphenePoint}}, _b::Union{GraphenePoint, Ref{_GraphenePoint}}, _factor::Real) + function interpolate(instance::GraphenePointLike, _b::GraphenePointLike, _factor::Real) m_res = Ref{_GraphenePoint}() ret = ccall(("graphene_point_interpolate", libgraphene), Nothing, (Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Float64, Ptr{_GraphenePoint}), instance, _b, _factor, m_res) _res = m_res[] _res end - function near(instance::Union{GraphenePoint, Ref{_GraphenePoint}}, _b::Union{GraphenePoint, Ref{_GraphenePoint}}, _epsilon::Real) + function near(instance::GraphenePointLike, _b::GraphenePointLike, _epsilon::Real) ret = ccall(("graphene_point_near", libgraphene), Cint, (Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Float32), instance, _b, _epsilon) ret2 = convert(Bool, ret) ret2 end - function to_vec2(instance::Union{GraphenePoint, Ref{_GraphenePoint}}) + function to_vec2(instance::GraphenePointLike) m_v = Ref{_GrapheneVec2}() ret = ccall(("graphene_point_to_vec2", libgraphene), Nothing, (Ptr{_GraphenePoint}, Ptr{_GrapheneVec2}), instance, m_v) _v = m_v[] @@ -783,83 +783,83 @@ $(Expr(:toplevel, quote end function Point3D_alloc() ret = ccall(("graphene_point3d_alloc", libgraphene), Ptr{_GraphenePoint3D}, ()) - ret2 = convert(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, ret, true) + ret2 = convert(GraphenePoint3DLike, ret, true) ret2 end - function cross(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _b::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function cross(instance::GraphenePoint3DLike, _b::GraphenePoint3DLike) m_res = Ref{_GraphenePoint3D}() ret = ccall(("graphene_point3d_cross", libgraphene), Nothing, (Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _b, m_res) _res = m_res[] _res end - function distance(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _b::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function distance(instance::GraphenePoint3DLike, _b::GraphenePoint3DLike) m_delta = Ref{_GrapheneVec3}() ret = ccall(("graphene_point3d_distance", libgraphene), Float32, (Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}, Ptr{_GrapheneVec3}), instance, _b, m_delta) _delta = m_delta[] (ret, _delta) end - function dot(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _b::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function dot(instance::GraphenePoint3DLike, _b::GraphenePoint3DLike) ret = ccall(("graphene_point3d_dot", libgraphene), Float32, (Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _b) ret end - function equal(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _b::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function equal(instance::GraphenePoint3DLike, _b::GraphenePoint3DLike) ret = ccall(("graphene_point3d_equal", libgraphene), Cint, (Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function free(instance::GraphenePoint3DLike) ret = ccall(("graphene_point3d_free", libgraphene), Nothing, (Ptr{_GraphenePoint3D},), instance) nothing end - function init(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _x::Real, _y::Real, _z::Real) + function init(instance::GraphenePoint3DLike, _x::Real, _y::Real, _z::Real) ret = ccall(("graphene_point3d_init", libgraphene), Ptr{_GraphenePoint3D}, (Ptr{_GraphenePoint3D}, Float32, Float32, Float32), instance, _x, _y, _z) - ret2 = convert(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, ret, false) + ret2 = convert(GraphenePoint3DLike, ret, false) ret2 end - function init_from_point(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _src::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function init_from_point(instance::GraphenePoint3DLike, _src::GraphenePoint3DLike) ret = ccall(("graphene_point3d_init_from_point", libgraphene), Ptr{_GraphenePoint3D}, (Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _src) - ret2 = convert(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, ret, false) + ret2 = convert(GraphenePoint3DLike, ret, false) ret2 end - function init_from_vec3(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _v::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function init_from_vec3(instance::GraphenePoint3DLike, _v::GrapheneVec3Like) ret = ccall(("graphene_point3d_init_from_vec3", libgraphene), Ptr{_GraphenePoint3D}, (Ptr{_GraphenePoint3D}, Ptr{_GrapheneVec3}), instance, _v) - ret2 = convert(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, ret, false) + ret2 = convert(GraphenePoint3DLike, ret, false) ret2 end - function interpolate(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _b::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _factor::Real) + function interpolate(instance::GraphenePoint3DLike, _b::GraphenePoint3DLike, _factor::Real) m_res = Ref{_GraphenePoint3D}() ret = ccall(("graphene_point3d_interpolate", libgraphene), Nothing, (Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}, Float64, Ptr{_GraphenePoint3D}), instance, _b, _factor, m_res) _res = m_res[] _res end - function length(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function length(instance::GraphenePoint3DLike) ret = ccall(("graphene_point3d_length", libgraphene), Float32, (Ptr{_GraphenePoint3D},), instance) ret end - function near(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _b::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _epsilon::Real) + function near(instance::GraphenePoint3DLike, _b::GraphenePoint3DLike, _epsilon::Real) ret = ccall(("graphene_point3d_near", libgraphene), Cint, (Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}, Float32), instance, _b, _epsilon) ret2 = convert(Bool, ret) ret2 end - function normalize(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function normalize(instance::GraphenePoint3DLike) m_res = Ref{_GraphenePoint3D}() ret = ccall(("graphene_point3d_normalize", libgraphene), Nothing, (Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, m_res) _res = m_res[] _res end - function normalize_viewport(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _viewport::Union{GrapheneRect, Ref{_GrapheneRect}}, _z_near::Real, _z_far::Real) + function normalize_viewport(instance::GraphenePoint3DLike, _viewport::GrapheneRectLike, _z_near::Real, _z_far::Real) m_res = Ref{_GraphenePoint3D}() ret = ccall(("graphene_point3d_normalize_viewport", libgraphene), Nothing, (Ptr{_GraphenePoint3D}, Ptr{_GrapheneRect}, Float32, Float32, Ptr{_GraphenePoint3D}), instance, _viewport, _z_near, _z_far, m_res) _res = m_res[] _res end - function scale(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}, _factor::Real) + function scale(instance::GraphenePoint3DLike, _factor::Real) m_res = Ref{_GraphenePoint3D}() ret = ccall(("graphene_point3d_scale", libgraphene), Nothing, (Ptr{_GraphenePoint3D}, Float32, Ptr{_GraphenePoint3D}), instance, _factor, m_res) _res = m_res[] _res end - function to_vec3(instance::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function to_vec3(instance::GraphenePoint3DLike) m_v = Ref{_GrapheneVec3}() ret = ccall(("graphene_point3d_to_vec3", libgraphene), Nothing, (Ptr{_GraphenePoint3D}, Ptr{_GrapheneVec3}), instance, m_v) _v = m_v[] @@ -867,145 +867,145 @@ $(Expr(:toplevel, quote end function Quad_alloc() ret = ccall(("graphene_quad_alloc", libgraphene), Ptr{_GrapheneQuad}, ()) - ret2 = convert(Union{GrapheneQuad, Ref{_GrapheneQuad}}, ret, true) + ret2 = convert(GrapheneQuadLike, ret, true) ret2 end - function bounds(instance::Union{GrapheneQuad, Ref{_GrapheneQuad}}) + function bounds(instance::GrapheneQuadLike) m_r = Ref{_GrapheneRect}() ret = ccall(("graphene_quad_bounds", libgraphene), Nothing, (Ptr{_GrapheneQuad}, Ptr{_GrapheneRect}), instance, m_r) _r = m_r[] _r end - function contains(instance::Union{GrapheneQuad, Ref{_GrapheneQuad}}, _p::Union{GraphenePoint, Ref{_GraphenePoint}}) + function contains(instance::GrapheneQuadLike, _p::GraphenePointLike) ret = ccall(("graphene_quad_contains", libgraphene), Cint, (Ptr{_GrapheneQuad}, Ptr{_GraphenePoint}), instance, _p) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneQuad, Ref{_GrapheneQuad}}) + function free(instance::GrapheneQuadLike) ret = ccall(("graphene_quad_free", libgraphene), Nothing, (Ptr{_GrapheneQuad},), instance) nothing end - function get_point(instance::Union{GrapheneQuad, Ref{_GrapheneQuad}}, _index_::Integer) + function get_point(instance::GrapheneQuadLike, _index_::Integer) ret = ccall(("graphene_quad_get_point", libgraphene), Ptr{_GraphenePoint}, (Ptr{_GrapheneQuad}, UInt32), instance, _index_) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end - function init(instance::Union{GrapheneQuad, Ref{_GrapheneQuad}}, _p1::Union{GraphenePoint, Ref{_GraphenePoint}}, _p2::Union{GraphenePoint, Ref{_GraphenePoint}}, _p3::Union{GraphenePoint, Ref{_GraphenePoint}}, _p4::Union{GraphenePoint, Ref{_GraphenePoint}}) + function init(instance::GrapheneQuadLike, _p1::GraphenePointLike, _p2::GraphenePointLike, _p3::GraphenePointLike, _p4::GraphenePointLike) ret = ccall(("graphene_quad_init", libgraphene), Ptr{_GrapheneQuad}, (Ptr{_GrapheneQuad}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}), instance, _p1, _p2, _p3, _p4) - ret2 = convert(Union{GrapheneQuad, Ref{_GrapheneQuad}}, ret, false) + ret2 = convert(GrapheneQuadLike, ret, false) ret2 end - function init_from_points(instance::Union{GrapheneQuad, Ref{_GrapheneQuad}}, _points) + function init_from_points(instance::GrapheneQuadLike, _points) _points_arr = convert(Vector{_GraphenePoint}, _points) ret = ccall(("graphene_quad_init_from_points", libgraphene), Ptr{_GrapheneQuad}, (Ptr{_GrapheneQuad}, Ptr{_GraphenePoint}), instance, _points_arr) - ret2 = convert(Union{GrapheneQuad, Ref{_GrapheneQuad}}, ret, false) + ret2 = convert(GrapheneQuadLike, ret, false) ret2 end - function init_from_rect(instance::Union{GrapheneQuad, Ref{_GrapheneQuad}}, _r::Union{GrapheneRect, Ref{_GrapheneRect}}) + function init_from_rect(instance::GrapheneQuadLike, _r::GrapheneRectLike) ret = ccall(("graphene_quad_init_from_rect", libgraphene), Ptr{_GrapheneQuad}, (Ptr{_GrapheneQuad}, Ptr{_GrapheneRect}), instance, _r) - ret2 = convert(Union{GrapheneQuad, Ref{_GrapheneQuad}}, ret, false) + ret2 = convert(GrapheneQuadLike, ret, false) ret2 end function Quaternion_alloc() ret = ccall(("graphene_quaternion_alloc", libgraphene), Ptr{_GrapheneQuaternion}, ()) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, true) + ret2 = convert(GrapheneQuaternionLike, ret, true) ret2 end - function add(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _b::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function add(instance::GrapheneQuaternionLike, _b::GrapheneQuaternionLike) m_res = Ref{_GrapheneQuaternion}() ret = ccall(("graphene_quaternion_add", libgraphene), Nothing, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}), instance, _b, m_res) _res = m_res[] _res end - function dot(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _b::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function dot(instance::GrapheneQuaternionLike, _b::GrapheneQuaternionLike) ret = ccall(("graphene_quaternion_dot", libgraphene), Float32, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}), instance, _b) ret end - function equal(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _b::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function equal(instance::GrapheneQuaternionLike, _b::GrapheneQuaternionLike) ret = ccall(("graphene_quaternion_equal", libgraphene), Cint, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function free(instance::GrapheneQuaternionLike) ret = ccall(("graphene_quaternion_free", libgraphene), Nothing, (Ptr{_GrapheneQuaternion},), instance) nothing end - function init(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _x::Real, _y::Real, _z::Real, _w::Real) + function init(instance::GrapheneQuaternionLike, _x::Real, _y::Real, _z::Real, _w::Real) ret = ccall(("graphene_quaternion_init", libgraphene), Ptr{_GrapheneQuaternion}, (Ptr{_GrapheneQuaternion}, Float32, Float32, Float32, Float32), instance, _x, _y, _z, _w) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, false) + ret2 = convert(GrapheneQuaternionLike, ret, false) ret2 end - function init_from_angle_vec3(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _angle::Real, _axis::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function init_from_angle_vec3(instance::GrapheneQuaternionLike, _angle::Real, _axis::GrapheneVec3Like) ret = ccall(("graphene_quaternion_init_from_angle_vec3", libgraphene), Ptr{_GrapheneQuaternion}, (Ptr{_GrapheneQuaternion}, Float32, Ptr{_GrapheneVec3}), instance, _angle, _axis) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, false) + ret2 = convert(GrapheneQuaternionLike, ret, false) ret2 end - function init_from_angles(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _deg_x::Real, _deg_y::Real, _deg_z::Real) + function init_from_angles(instance::GrapheneQuaternionLike, _deg_x::Real, _deg_y::Real, _deg_z::Real) ret = ccall(("graphene_quaternion_init_from_angles", libgraphene), Ptr{_GrapheneQuaternion}, (Ptr{_GrapheneQuaternion}, Float32, Float32, Float32), instance, _deg_x, _deg_y, _deg_z) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, false) + ret2 = convert(GrapheneQuaternionLike, ret, false) ret2 end - function init_from_euler(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _e::Union{GrapheneEuler, Ref{_GrapheneEuler}}) + function init_from_euler(instance::GrapheneQuaternionLike, _e::GrapheneEulerLike) ret = ccall(("graphene_quaternion_init_from_euler", libgraphene), Ptr{_GrapheneQuaternion}, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneEuler}), instance, _e) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, false) + ret2 = convert(GrapheneQuaternionLike, ret, false) ret2 end - function init_from_matrix(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _m::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function init_from_matrix(instance::GrapheneQuaternionLike, _m::GrapheneMatrixLike) ret = ccall(("graphene_quaternion_init_from_matrix", libgraphene), Ptr{_GrapheneQuaternion}, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneMatrix}), instance, _m) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, false) + ret2 = convert(GrapheneQuaternionLike, ret, false) ret2 end - function init_from_quaternion(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _src::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function init_from_quaternion(instance::GrapheneQuaternionLike, _src::GrapheneQuaternionLike) ret = ccall(("graphene_quaternion_init_from_quaternion", libgraphene), Ptr{_GrapheneQuaternion}, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}), instance, _src) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, false) + ret2 = convert(GrapheneQuaternionLike, ret, false) ret2 end - function init_from_radians(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _rad_x::Real, _rad_y::Real, _rad_z::Real) + function init_from_radians(instance::GrapheneQuaternionLike, _rad_x::Real, _rad_y::Real, _rad_z::Real) ret = ccall(("graphene_quaternion_init_from_radians", libgraphene), Ptr{_GrapheneQuaternion}, (Ptr{_GrapheneQuaternion}, Float32, Float32, Float32), instance, _rad_x, _rad_y, _rad_z) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, false) + ret2 = convert(GrapheneQuaternionLike, ret, false) ret2 end - function init_from_vec4(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _src::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function init_from_vec4(instance::GrapheneQuaternionLike, _src::GrapheneVec4Like) ret = ccall(("graphene_quaternion_init_from_vec4", libgraphene), Ptr{_GrapheneQuaternion}, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneVec4}), instance, _src) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, false) + ret2 = convert(GrapheneQuaternionLike, ret, false) ret2 end - function init_identity(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function init_identity(instance::GrapheneQuaternionLike) ret = ccall(("graphene_quaternion_init_identity", libgraphene), Ptr{_GrapheneQuaternion}, (Ptr{_GrapheneQuaternion},), instance) - ret2 = convert(Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, ret, false) + ret2 = convert(GrapheneQuaternionLike, ret, false) ret2 end - function invert(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function invert(instance::GrapheneQuaternionLike) m_res = Ref{_GrapheneQuaternion}() ret = ccall(("graphene_quaternion_invert", libgraphene), Nothing, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}), instance, m_res) _res = m_res[] _res end - function multiply(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _b::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function multiply(instance::GrapheneQuaternionLike, _b::GrapheneQuaternionLike) m_res = Ref{_GrapheneQuaternion}() ret = ccall(("graphene_quaternion_multiply", libgraphene), Nothing, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}), instance, _b, m_res) _res = m_res[] _res end - function normalize(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function normalize(instance::GrapheneQuaternionLike) m_res = Ref{_GrapheneQuaternion}() ret = ccall(("graphene_quaternion_normalize", libgraphene), Nothing, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}), instance, m_res) _res = m_res[] _res end - function scale(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _factor::Real) + function scale(instance::GrapheneQuaternionLike, _factor::Real) m_res = Ref{_GrapheneQuaternion}() ret = ccall(("graphene_quaternion_scale", libgraphene), Nothing, (Ptr{_GrapheneQuaternion}, Float32, Ptr{_GrapheneQuaternion}), instance, _factor, m_res) _res = m_res[] _res end - function slerp(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _b::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}, _factor::Real) + function slerp(instance::GrapheneQuaternionLike, _b::GrapheneQuaternionLike, _factor::Real) m_res = Ref{_GrapheneQuaternion}() ret = ccall(("graphene_quaternion_slerp", libgraphene), Nothing, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneQuaternion}, Float32, Ptr{_GrapheneQuaternion}), instance, _b, _factor, m_res) _res = m_res[] _res end - function to_angle_vec3(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function to_angle_vec3(instance::GrapheneQuaternionLike) m_angle = Ref{Float32}() m_axis = Ref{_GrapheneVec3}() ret = ccall(("graphene_quaternion_to_angle_vec3", libgraphene), Nothing, (Ptr{_GrapheneQuaternion}, Ptr{Float32}, Ptr{_GrapheneVec3}), instance, m_angle, m_axis) @@ -1013,7 +1013,7 @@ $(Expr(:toplevel, quote _axis = m_axis[] (_angle, _axis) end - function to_angles(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function to_angles(instance::GrapheneQuaternionLike) m_deg_x = Ref{Float32}() m_deg_y = Ref{Float32}() m_deg_z = Ref{Float32}() @@ -1023,13 +1023,13 @@ $(Expr(:toplevel, quote _deg_z = m_deg_z[] (_deg_x, _deg_y, _deg_z) end - function to_matrix(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function to_matrix(instance::GrapheneQuaternionLike) m_m = Ref{_GrapheneMatrix}() ret = ccall(("graphene_quaternion_to_matrix", libgraphene), Nothing, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneMatrix}), instance, m_m) _m = m_m[] _m end - function to_radians(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function to_radians(instance::GrapheneQuaternionLike) m_rad_x = Ref{Float32}() m_rad_y = Ref{Float32}() m_rad_z = Ref{Float32}() @@ -1039,7 +1039,7 @@ $(Expr(:toplevel, quote _rad_z = m_rad_z[] (_rad_x, _rad_y, _rad_z) end - function to_vec4(instance::Union{GrapheneQuaternion, Ref{_GrapheneQuaternion}}) + function to_vec4(instance::GrapheneQuaternionLike) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_quaternion_to_vec4", libgraphene), Nothing, (Ptr{_GrapheneQuaternion}, Ptr{_GrapheneVec4}), instance, m_res) _res = m_res[] @@ -1047,255 +1047,255 @@ $(Expr(:toplevel, quote end function Ray_alloc() ret = ccall(("graphene_ray_alloc", libgraphene), Ptr{_GrapheneRay}, ()) - ret2 = convert(Union{GrapheneRay, Ref{_GrapheneRay}}, ret, true) + ret2 = convert(GrapheneRayLike, ret, true) ret2 end - function equal(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _b::Union{GrapheneRay, Ref{_GrapheneRay}}) + function equal(instance::GrapheneRayLike, _b::GrapheneRayLike) ret = ccall(("graphene_ray_equal", libgraphene), Cint, (Ptr{_GrapheneRay}, Ptr{_GrapheneRay}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneRay, Ref{_GrapheneRay}}) + function free(instance::GrapheneRayLike) ret = ccall(("graphene_ray_free", libgraphene), Nothing, (Ptr{_GrapheneRay},), instance) nothing end - function get_closest_point_to_point(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _p::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function get_closest_point_to_point(instance::GrapheneRayLike, _p::GraphenePoint3DLike) m_res = Ref{_GraphenePoint3D}() ret = ccall(("graphene_ray_get_closest_point_to_point", libgraphene), Nothing, (Ptr{_GrapheneRay}, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _p, m_res) _res = m_res[] _res end - function get_direction(instance::Union{GrapheneRay, Ref{_GrapheneRay}}) + function get_direction(instance::GrapheneRayLike) m_direction = Ref{_GrapheneVec3}() ret = ccall(("graphene_ray_get_direction", libgraphene), Nothing, (Ptr{_GrapheneRay}, Ptr{_GrapheneVec3}), instance, m_direction) _direction = m_direction[] _direction end - function get_distance_to_plane(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _p::Union{GraphenePlane, Ref{_GraphenePlane}}) + function get_distance_to_plane(instance::GrapheneRayLike, _p::GraphenePlaneLike) ret = ccall(("graphene_ray_get_distance_to_plane", libgraphene), Float32, (Ptr{_GrapheneRay}, Ptr{_GraphenePlane}), instance, _p) ret end - function get_distance_to_point(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _p::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function get_distance_to_point(instance::GrapheneRayLike, _p::GraphenePoint3DLike) ret = ccall(("graphene_ray_get_distance_to_point", libgraphene), Float32, (Ptr{_GrapheneRay}, Ptr{_GraphenePoint3D}), instance, _p) ret end - function get_origin(instance::Union{GrapheneRay, Ref{_GrapheneRay}}) + function get_origin(instance::GrapheneRayLike) m_origin = Ref{_GraphenePoint3D}() ret = ccall(("graphene_ray_get_origin", libgraphene), Nothing, (Ptr{_GrapheneRay}, Ptr{_GraphenePoint3D}), instance, m_origin) _origin = m_origin[] _origin end - function get_position_at(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _t::Real) + function get_position_at(instance::GrapheneRayLike, _t::Real) m_position = Ref{_GraphenePoint3D}() ret = ccall(("graphene_ray_get_position_at", libgraphene), Nothing, (Ptr{_GrapheneRay}, Float32, Ptr{_GraphenePoint3D}), instance, _t, m_position) _position = m_position[] _position end - function init(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _origin::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}), _direction::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}})) + function init(instance::GrapheneRayLike, _origin::Maybe(GraphenePoint3DLike), _direction::Maybe(GrapheneVec3Like)) _origin_maybe = nothing_to_null(_origin) _direction_maybe = nothing_to_null(_direction) ret = ccall(("graphene_ray_init", libgraphene), Ptr{_GrapheneRay}, (Ptr{_GrapheneRay}, Ptr{_GraphenePoint3D}, Ptr{_GrapheneVec3}), instance, _origin_maybe, _direction_maybe) - ret2 = convert(Union{GrapheneRay, Ref{_GrapheneRay}}, ret, false) + ret2 = convert(GrapheneRayLike, ret, false) ret2 end - function init_from_ray(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _src::Union{GrapheneRay, Ref{_GrapheneRay}}) + function init_from_ray(instance::GrapheneRayLike, _src::GrapheneRayLike) ret = ccall(("graphene_ray_init_from_ray", libgraphene), Ptr{_GrapheneRay}, (Ptr{_GrapheneRay}, Ptr{_GrapheneRay}), instance, _src) - ret2 = convert(Union{GrapheneRay, Ref{_GrapheneRay}}, ret, false) + ret2 = convert(GrapheneRayLike, ret, false) ret2 end - function init_from_vec3(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _origin::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}}), _direction::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}})) + function init_from_vec3(instance::GrapheneRayLike, _origin::Maybe(GrapheneVec3Like), _direction::Maybe(GrapheneVec3Like)) _origin_maybe = nothing_to_null(_origin) _direction_maybe = nothing_to_null(_direction) ret = ccall(("graphene_ray_init_from_vec3", libgraphene), Ptr{_GrapheneRay}, (Ptr{_GrapheneRay}, Ptr{_GrapheneVec3}, Ptr{_GrapheneVec3}), instance, _origin_maybe, _direction_maybe) - ret2 = convert(Union{GrapheneRay, Ref{_GrapheneRay}}, ret, false) + ret2 = convert(GrapheneRayLike, ret, false) ret2 end - function intersect_box(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _b::Union{GrapheneBox, Ref{_GrapheneBox}}) + function intersect_box(instance::GrapheneRayLike, _b::GrapheneBoxLike) m_t_out = Ref{Float32}() ret = ccall(("graphene_ray_intersect_box", libgraphene), UInt32, (Ptr{_GrapheneRay}, Ptr{_GrapheneBox}, Ptr{Float32}), instance, _b, m_t_out) ret2 = RayIntersectionKind(ret) _t_out = m_t_out[] (ret2, _t_out) end - function intersect_sphere(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _s::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function intersect_sphere(instance::GrapheneRayLike, _s::GrapheneSphereLike) m_t_out = Ref{Float32}() ret = ccall(("graphene_ray_intersect_sphere", libgraphene), UInt32, (Ptr{_GrapheneRay}, Ptr{_GrapheneSphere}, Ptr{Float32}), instance, _s, m_t_out) ret2 = RayIntersectionKind(ret) _t_out = m_t_out[] (ret2, _t_out) end - function intersect_triangle(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _t::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function intersect_triangle(instance::GrapheneRayLike, _t::GrapheneTriangleLike) m_t_out = Ref{Float32}() ret = ccall(("graphene_ray_intersect_triangle", libgraphene), UInt32, (Ptr{_GrapheneRay}, Ptr{_GrapheneTriangle}, Ptr{Float32}), instance, _t, m_t_out) ret2 = RayIntersectionKind(ret) _t_out = m_t_out[] (ret2, _t_out) end - function intersects_box(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _b::Union{GrapheneBox, Ref{_GrapheneBox}}) + function intersects_box(instance::GrapheneRayLike, _b::GrapheneBoxLike) ret = ccall(("graphene_ray_intersects_box", libgraphene), Cint, (Ptr{_GrapheneRay}, Ptr{_GrapheneBox}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function intersects_sphere(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _s::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function intersects_sphere(instance::GrapheneRayLike, _s::GrapheneSphereLike) ret = ccall(("graphene_ray_intersects_sphere", libgraphene), Cint, (Ptr{_GrapheneRay}, Ptr{_GrapheneSphere}), instance, _s) ret2 = convert(Bool, ret) ret2 end - function intersects_triangle(instance::Union{GrapheneRay, Ref{_GrapheneRay}}, _t::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function intersects_triangle(instance::GrapheneRayLike, _t::GrapheneTriangleLike) ret = ccall(("graphene_ray_intersects_triangle", libgraphene), Cint, (Ptr{_GrapheneRay}, Ptr{_GrapheneTriangle}), instance, _t) ret2 = convert(Bool, ret) ret2 end - function contains_point(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _p::Union{GraphenePoint, Ref{_GraphenePoint}}) + function contains_point(instance::GrapheneRectLike, _p::GraphenePointLike) ret = ccall(("graphene_rect_contains_point", libgraphene), Cint, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}), instance, _p) ret2 = convert(Bool, ret) ret2 end - function contains_rect(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _b::Union{GrapheneRect, Ref{_GrapheneRect}}) + function contains_rect(instance::GrapheneRectLike, _b::GrapheneRectLike) ret = ccall(("graphene_rect_contains_rect", libgraphene), Cint, (Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function equal(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _b::Union{GrapheneRect, Ref{_GrapheneRect}}) + function equal(instance::GrapheneRectLike, _b::GrapheneRectLike) ret = ccall(("graphene_rect_equal", libgraphene), Cint, (Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function expand(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _p::Union{GraphenePoint, Ref{_GraphenePoint}}) + function expand(instance::GrapheneRectLike, _p::GraphenePointLike) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_rect_expand", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Ptr{_GrapheneRect}), instance, _p, m_res) _res = m_res[] _res end - function free(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function free(instance::GrapheneRectLike) ret = ccall(("graphene_rect_free", libgraphene), Nothing, (Ptr{_GrapheneRect},), instance) nothing end - function get_area(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_area(instance::GrapheneRectLike) ret = ccall(("graphene_rect_get_area", libgraphene), Float32, (Ptr{_GrapheneRect},), instance) ret end - function get_bottom_left(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_bottom_left(instance::GrapheneRectLike) m_p = Ref{_GraphenePoint}() ret = ccall(("graphene_rect_get_bottom_left", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}), instance, m_p) _p = m_p[] _p end - function get_bottom_right(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_bottom_right(instance::GrapheneRectLike) m_p = Ref{_GraphenePoint}() ret = ccall(("graphene_rect_get_bottom_right", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}), instance, m_p) _p = m_p[] _p end - function get_center(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_center(instance::GrapheneRectLike) m_p = Ref{_GraphenePoint}() ret = ccall(("graphene_rect_get_center", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}), instance, m_p) _p = m_p[] _p end - function get_height(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_height(instance::GrapheneRectLike) ret = ccall(("graphene_rect_get_height", libgraphene), Float32, (Ptr{_GrapheneRect},), instance) ret end - function get_top_left(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_top_left(instance::GrapheneRectLike) m_p = Ref{_GraphenePoint}() ret = ccall(("graphene_rect_get_top_left", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}), instance, m_p) _p = m_p[] _p end - function get_top_right(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_top_right(instance::GrapheneRectLike) m_p = Ref{_GraphenePoint}() ret = ccall(("graphene_rect_get_top_right", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}), instance, m_p) _p = m_p[] _p end - function get_vertices(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_vertices(instance::GrapheneRectLike) m_vertices = Ref{Ptr{_GrapheneVec2}}() ret = ccall(("graphene_rect_get_vertices", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{Ptr{_GrapheneVec2}}), instance, m_vertices) _vertices = m_vertices[] _vertices end - function get_width(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_width(instance::GrapheneRectLike) ret = ccall(("graphene_rect_get_width", libgraphene), Float32, (Ptr{_GrapheneRect},), instance) ret end - function get_x(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_x(instance::GrapheneRectLike) ret = ccall(("graphene_rect_get_x", libgraphene), Float32, (Ptr{_GrapheneRect},), instance) ret end - function get_y(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function get_y(instance::GrapheneRectLike) ret = ccall(("graphene_rect_get_y", libgraphene), Float32, (Ptr{_GrapheneRect},), instance) ret end - function init(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _x::Real, _y::Real, _width::Real, _height::Real) + function init(instance::GrapheneRectLike, _x::Real, _y::Real, _width::Real, _height::Real) ret = ccall(("graphene_rect_init", libgraphene), Ptr{_GrapheneRect}, (Ptr{_GrapheneRect}, Float32, Float32, Float32, Float32), instance, _x, _y, _width, _height) - ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false) + ret2 = convert(GrapheneRectLike, ret, false) ret2 end - function init_from_rect(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _src::Union{GrapheneRect, Ref{_GrapheneRect}}) + function init_from_rect(instance::GrapheneRectLike, _src::GrapheneRectLike) ret = ccall(("graphene_rect_init_from_rect", libgraphene), Ptr{_GrapheneRect}, (Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _src) - ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false) + ret2 = convert(GrapheneRectLike, ret, false) ret2 end - function inset(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _d_x::Real, _d_y::Real) + function inset(instance::GrapheneRectLike, _d_x::Real, _d_y::Real) ret = ccall(("graphene_rect_inset", libgraphene), Ptr{_GrapheneRect}, (Ptr{_GrapheneRect}, Float32, Float32), instance, _d_x, _d_y) - ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false) + ret2 = convert(GrapheneRectLike, ret, false) ret2 end - function inset_r(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _d_x::Real, _d_y::Real) + function inset_r(instance::GrapheneRectLike, _d_x::Real, _d_y::Real) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_rect_inset_r", libgraphene), Nothing, (Ptr{_GrapheneRect}, Float32, Float32, Ptr{_GrapheneRect}), instance, _d_x, _d_y, m_res) _res = m_res[] _res end - function interpolate(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _b::Union{GrapheneRect, Ref{_GrapheneRect}}, _factor::Real) + function interpolate(instance::GrapheneRectLike, _b::GrapheneRectLike, _factor::Real) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_rect_interpolate", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GrapheneRect}, Float64, Ptr{_GrapheneRect}), instance, _b, _factor, m_res) _res = m_res[] _res end - function intersection(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _b::Union{GrapheneRect, Ref{_GrapheneRect}}) + function intersection(instance::GrapheneRectLike, _b::GrapheneRectLike) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_rect_intersection", libgraphene), Cint, (Ptr{_GrapheneRect}, Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _b, m_res) ret2 = convert(Bool, ret) _res = m_res[] (ret2, _res) end - function normalize(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function normalize(instance::GrapheneRectLike) ret = ccall(("graphene_rect_normalize", libgraphene), Ptr{_GrapheneRect}, (Ptr{_GrapheneRect},), instance) - ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false) + ret2 = convert(GrapheneRectLike, ret, false) ret2 end - function normalize_r(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function normalize_r(instance::GrapheneRectLike) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_rect_normalize_r", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, m_res) _res = m_res[] _res end - function offset(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _d_x::Real, _d_y::Real) + function offset(instance::GrapheneRectLike, _d_x::Real, _d_y::Real) ret = ccall(("graphene_rect_offset", libgraphene), Ptr{_GrapheneRect}, (Ptr{_GrapheneRect}, Float32, Float32), instance, _d_x, _d_y) - ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false) + ret2 = convert(GrapheneRectLike, ret, false) ret2 end - function offset_r(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _d_x::Real, _d_y::Real) + function offset_r(instance::GrapheneRectLike, _d_x::Real, _d_y::Real) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_rect_offset_r", libgraphene), Nothing, (Ptr{_GrapheneRect}, Float32, Float32, Ptr{_GrapheneRect}), instance, _d_x, _d_y, m_res) _res = m_res[] _res end - function round_extents(instance::Union{GrapheneRect, Ref{_GrapheneRect}}) + function round_extents(instance::GrapheneRectLike) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_rect_round_extents", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, m_res) _res = m_res[] _res end - function scale(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _s_h::Real, _s_v::Real) + function scale(instance::GrapheneRectLike, _s_h::Real, _s_v::Real) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_rect_scale", libgraphene), Nothing, (Ptr{_GrapheneRect}, Float32, Float32, Ptr{_GrapheneRect}), instance, _s_h, _s_v, m_res) _res = m_res[] _res end - function union(instance::Union{GrapheneRect, Ref{_GrapheneRect}}, _b::Union{GrapheneRect, Ref{_GrapheneRect}}) + function union(instance::GrapheneRectLike, _b::GrapheneRectLike) m_res = Ref{_GrapheneRect}() ret = ccall(("graphene_rect_union", libgraphene), Nothing, (Ptr{_GrapheneRect}, Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _b, m_res) _res = m_res[] @@ -1303,71 +1303,71 @@ $(Expr(:toplevel, quote end function Sphere_alloc() ret = ccall(("graphene_sphere_alloc", libgraphene), Ptr{_GrapheneSphere}, ()) - ret2 = convert(Union{GrapheneSphere, Ref{_GrapheneSphere}}, ret, true) + ret2 = convert(GrapheneSphereLike, ret, true) ret2 end - function contains_point(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function contains_point(instance::GrapheneSphereLike, _point::GraphenePoint3DLike) ret = ccall(("graphene_sphere_contains_point", libgraphene), Cint, (Ptr{_GrapheneSphere}, Ptr{_GraphenePoint3D}), instance, _point) ret2 = convert(Bool, ret) ret2 end - function distance(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function distance(instance::GrapheneSphereLike, _point::GraphenePoint3DLike) ret = ccall(("graphene_sphere_distance", libgraphene), Float32, (Ptr{_GrapheneSphere}, Ptr{_GraphenePoint3D}), instance, _point) ret end - function equal(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}, _b::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function equal(instance::GrapheneSphereLike, _b::GrapheneSphereLike) ret = ccall(("graphene_sphere_equal", libgraphene), Cint, (Ptr{_GrapheneSphere}, Ptr{_GrapheneSphere}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function free(instance::GrapheneSphereLike) ret = ccall(("graphene_sphere_free", libgraphene), Nothing, (Ptr{_GrapheneSphere},), instance) nothing end - function get_bounding_box(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function get_bounding_box(instance::GrapheneSphereLike) m_box = Ref{_GrapheneBox}() ret = ccall(("graphene_sphere_get_bounding_box", libgraphene), Nothing, (Ptr{_GrapheneSphere}, Ptr{_GrapheneBox}), instance, m_box) _box = m_box[] _box end - function get_center(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function get_center(instance::GrapheneSphereLike) m_center = Ref{_GraphenePoint3D}() ret = ccall(("graphene_sphere_get_center", libgraphene), Nothing, (Ptr{_GrapheneSphere}, Ptr{_GraphenePoint3D}), instance, m_center) _center = m_center[] _center end - function get_radius(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function get_radius(instance::GrapheneSphereLike) ret = ccall(("graphene_sphere_get_radius", libgraphene), Float32, (Ptr{_GrapheneSphere},), instance) ret end - function init(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}, _center::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}), _radius::Real) + function init(instance::GrapheneSphereLike, _center::Maybe(GraphenePoint3DLike), _radius::Real) _center_maybe = nothing_to_null(_center) ret = ccall(("graphene_sphere_init", libgraphene), Ptr{_GrapheneSphere}, (Ptr{_GrapheneSphere}, Ptr{_GraphenePoint3D}, Float32), instance, _center_maybe, _radius) - ret2 = convert(Union{GrapheneSphere, Ref{_GrapheneSphere}}, ret, false) + ret2 = convert(GrapheneSphereLike, ret, false) ret2 end - function init_from_points(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}, _points, _center::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}})) + function init_from_points(instance::GrapheneSphereLike, _points, _center::Maybe(GraphenePoint3DLike)) _points_arr = convert(Vector{_GraphenePoint3D}, _points) _center_maybe = nothing_to_null(_center) _n_points = length(_points) ret = ccall(("graphene_sphere_init_from_points", libgraphene), Ptr{_GrapheneSphere}, (Ptr{_GrapheneSphere}, UInt32, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _n_points, _points_arr, _center_maybe) - ret2 = convert(Union{GrapheneSphere, Ref{_GrapheneSphere}}, ret, false) + ret2 = convert(GrapheneSphereLike, ret, false) ret2 end - function init_from_vectors(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}, _vectors, _center::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}})) + function init_from_vectors(instance::GrapheneSphereLike, _vectors, _center::Maybe(GraphenePoint3DLike)) _vectors_arr = convert(Vector{_GrapheneVec3}, _vectors) _center_maybe = nothing_to_null(_center) _n_vectors = length(_vectors) ret = ccall(("graphene_sphere_init_from_vectors", libgraphene), Ptr{_GrapheneSphere}, (Ptr{_GrapheneSphere}, UInt32, Ptr{_GrapheneVec3}, Ptr{_GraphenePoint3D}), instance, _n_vectors, _vectors_arr, _center_maybe) - ret2 = convert(Union{GrapheneSphere, Ref{_GrapheneSphere}}, ret, false) + ret2 = convert(GrapheneSphereLike, ret, false) ret2 end - function is_empty(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}) + function is_empty(instance::GrapheneSphereLike) ret = ccall(("graphene_sphere_is_empty", libgraphene), Cint, (Ptr{_GrapheneSphere},), instance) ret2 = convert(Bool, ret) ret2 end - function translate(instance::Union{GrapheneSphere, Ref{_GrapheneSphere}}, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function translate(instance::GrapheneSphereLike, _point::GraphenePoint3DLike) m_res = Ref{_GrapheneSphere}() ret = ccall(("graphene_sphere_translate", libgraphene), Nothing, (Ptr{_GrapheneSphere}, Ptr{_GraphenePoint3D}, Ptr{_GrapheneSphere}), instance, _point, m_res) _res = m_res[] @@ -1375,28 +1375,28 @@ $(Expr(:toplevel, quote end function Triangle_alloc() ret = ccall(("graphene_triangle_alloc", libgraphene), Ptr{_GrapheneTriangle}, ()) - ret2 = convert(Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, ret, true) + ret2 = convert(GrapheneTriangleLike, ret, true) ret2 end - function contains_point(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, _p::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function contains_point(instance::GrapheneTriangleLike, _p::GraphenePoint3DLike) ret = ccall(("graphene_triangle_contains_point", libgraphene), Cint, (Ptr{_GrapheneTriangle}, Ptr{_GraphenePoint3D}), instance, _p) ret2 = convert(Bool, ret) ret2 end - function equal(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, _b::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function equal(instance::GrapheneTriangleLike, _b::GrapheneTriangleLike) ret = ccall(("graphene_triangle_equal", libgraphene), Cint, (Ptr{_GrapheneTriangle}, Ptr{_GrapheneTriangle}), instance, _b) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function free(instance::GrapheneTriangleLike) ret = ccall(("graphene_triangle_free", libgraphene), Nothing, (Ptr{_GrapheneTriangle},), instance) nothing end - function get_area(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function get_area(instance::GrapheneTriangleLike) ret = ccall(("graphene_triangle_get_area", libgraphene), Float32, (Ptr{_GrapheneTriangle},), instance) ret end - function get_barycoords(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, _p::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}})) + function get_barycoords(instance::GrapheneTriangleLike, _p::Maybe(GraphenePoint3DLike)) _p_maybe = nothing_to_null(_p) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_triangle_get_barycoords", libgraphene), Cint, (Ptr{_GrapheneTriangle}, Ptr{_GraphenePoint3D}, Ptr{_GrapheneVec2}), instance, _p_maybe, m_res) @@ -1404,31 +1404,31 @@ $(Expr(:toplevel, quote _res = m_res[] (ret2, _res) end - function get_bounding_box(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function get_bounding_box(instance::GrapheneTriangleLike) m_res = Ref{_GrapheneBox}() ret = ccall(("graphene_triangle_get_bounding_box", libgraphene), Nothing, (Ptr{_GrapheneTriangle}, Ptr{_GrapheneBox}), instance, m_res) _res = m_res[] _res end - function get_midpoint(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function get_midpoint(instance::GrapheneTriangleLike) m_res = Ref{_GraphenePoint3D}() ret = ccall(("graphene_triangle_get_midpoint", libgraphene), Nothing, (Ptr{_GrapheneTriangle}, Ptr{_GraphenePoint3D}), instance, m_res) _res = m_res[] _res end - function get_normal(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function get_normal(instance::GrapheneTriangleLike) m_res = Ref{_GrapheneVec3}() ret = ccall(("graphene_triangle_get_normal", libgraphene), Nothing, (Ptr{_GrapheneTriangle}, Ptr{_GrapheneVec3}), instance, m_res) _res = m_res[] _res end - function get_plane(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function get_plane(instance::GrapheneTriangleLike) m_res = Ref{_GraphenePlane}() ret = ccall(("graphene_triangle_get_plane", libgraphene), Nothing, (Ptr{_GrapheneTriangle}, Ptr{_GraphenePlane}), instance, m_res) _res = m_res[] _res end - function get_points(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function get_points(instance::GrapheneTriangleLike) m_a = Ref{_GraphenePoint3D}() m_b = Ref{_GraphenePoint3D}() m_c = Ref{_GraphenePoint3D}() @@ -1438,7 +1438,7 @@ $(Expr(:toplevel, quote _c = m_c[] (_a, _b, _c) end - function get_uv(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, _p::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}), _uv_a::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _uv_b::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _uv_c::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function get_uv(instance::GrapheneTriangleLike, _p::Maybe(GraphenePoint3DLike), _uv_a::GrapheneVec2Like, _uv_b::GrapheneVec2Like, _uv_c::GrapheneVec2Like) _p_maybe = nothing_to_null(_p) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_triangle_get_uv", libgraphene), Cint, (Ptr{_GrapheneTriangle}, Ptr{_GraphenePoint3D}, Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _p_maybe, _uv_a, _uv_b, _uv_c, m_res) @@ -1446,7 +1446,7 @@ $(Expr(:toplevel, quote _res = m_res[] (ret2, _res) end - function get_vertices(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}) + function get_vertices(instance::GrapheneTriangleLike) m_a = Ref{_GrapheneVec3}() m_b = Ref{_GrapheneVec3}() m_c = Ref{_GrapheneVec3}() @@ -1456,142 +1456,142 @@ $(Expr(:toplevel, quote _c = m_c[] (_a, _b, _c) end - function init_from_float(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, _a, _b, _c) + function init_from_float(instance::GrapheneTriangleLike, _a, _b, _c) _a_arr = convert(Vector{Float32}, _a) _b_arr = convert(Vector{Float32}, _b) _c_arr = convert(Vector{Float32}, _c) ret = ccall(("graphene_triangle_init_from_float", libgraphene), Ptr{_GrapheneTriangle}, (Ptr{_GrapheneTriangle}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}), instance, _a_arr, _b_arr, _c_arr) - ret2 = convert(Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, ret, false) + ret2 = convert(GrapheneTriangleLike, ret, false) ret2 end - function init_from_point3d(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, _a::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}), _b::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}}), _c::Maybe(Union{GraphenePoint3D, Ref{_GraphenePoint3D}})) + function init_from_point3d(instance::GrapheneTriangleLike, _a::Maybe(GraphenePoint3DLike), _b::Maybe(GraphenePoint3DLike), _c::Maybe(GraphenePoint3DLike)) _a_maybe = nothing_to_null(_a) _b_maybe = nothing_to_null(_b) _c_maybe = nothing_to_null(_c) ret = ccall(("graphene_triangle_init_from_point3d", libgraphene), Ptr{_GrapheneTriangle}, (Ptr{_GrapheneTriangle}, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}, Ptr{_GraphenePoint3D}), instance, _a_maybe, _b_maybe, _c_maybe) - ret2 = convert(Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, ret, false) + ret2 = convert(GrapheneTriangleLike, ret, false) ret2 end - function init_from_vec3(instance::Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, _a::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}}), _b::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}}), _c::Maybe(Union{GrapheneVec3, Ref{_GrapheneVec3}})) + function init_from_vec3(instance::GrapheneTriangleLike, _a::Maybe(GrapheneVec3Like), _b::Maybe(GrapheneVec3Like), _c::Maybe(GrapheneVec3Like)) _a_maybe = nothing_to_null(_a) _b_maybe = nothing_to_null(_b) _c_maybe = nothing_to_null(_c) ret = ccall(("graphene_triangle_init_from_vec3", libgraphene), Ptr{_GrapheneTriangle}, (Ptr{_GrapheneTriangle}, Ptr{_GrapheneVec3}, Ptr{_GrapheneVec3}, Ptr{_GrapheneVec3}), instance, _a_maybe, _b_maybe, _c_maybe) - ret2 = convert(Union{GrapheneTriangle, Ref{_GrapheneTriangle}}, ret, false) + ret2 = convert(GrapheneTriangleLike, ret, false) ret2 end function Vec2_alloc() ret = ccall(("graphene_vec2_alloc", libgraphene), Ptr{_GrapheneVec2}, ()) - ret2 = convert(Union{GrapheneVec2, Ref{_GrapheneVec2}}, ret, true) + ret2 = convert(GrapheneVec2Like, ret, true) ret2 end - function add(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _b::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function add(instance::GrapheneVec2Like, _b::GrapheneVec2Like) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_add", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _b, m_res) _res = m_res[] _res end - function divide(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _b::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function divide(instance::GrapheneVec2Like, _b::GrapheneVec2Like) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_divide", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _b, m_res) _res = m_res[] _res end - function dot(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _b::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function dot(instance::GrapheneVec2Like, _b::GrapheneVec2Like) ret = ccall(("graphene_vec2_dot", libgraphene), Float32, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _b) ret end - function equal(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _v2::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function equal(instance::GrapheneVec2Like, _v2::GrapheneVec2Like) ret = ccall(("graphene_vec2_equal", libgraphene), Cint, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _v2) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function free(instance::GrapheneVec2Like) ret = ccall(("graphene_vec2_free", libgraphene), Nothing, (Ptr{_GrapheneVec2},), instance) nothing end - function get_x(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function get_x(instance::GrapheneVec2Like) ret = ccall(("graphene_vec2_get_x", libgraphene), Float32, (Ptr{_GrapheneVec2},), instance) ret end - function get_y(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function get_y(instance::GrapheneVec2Like) ret = ccall(("graphene_vec2_get_y", libgraphene), Float32, (Ptr{_GrapheneVec2},), instance) ret end - function init(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _x::Real, _y::Real) + function init(instance::GrapheneVec2Like, _x::Real, _y::Real) ret = ccall(("graphene_vec2_init", libgraphene), Ptr{_GrapheneVec2}, (Ptr{_GrapheneVec2}, Float32, Float32), instance, _x, _y) - ret2 = convert(Union{GrapheneVec2, Ref{_GrapheneVec2}}, ret, false) + ret2 = convert(GrapheneVec2Like, ret, false) ret2 end - function init_from_float(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _src) + function init_from_float(instance::GrapheneVec2Like, _src) _src_arr = convert(Vector{Float32}, _src) ret = ccall(("graphene_vec2_init_from_float", libgraphene), Ptr{_GrapheneVec2}, (Ptr{_GrapheneVec2}, Ptr{Float32}), instance, _src_arr) - ret2 = convert(Union{GrapheneVec2, Ref{_GrapheneVec2}}, ret, false) + ret2 = convert(GrapheneVec2Like, ret, false) ret2 end - function init_from_vec2(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _src::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function init_from_vec2(instance::GrapheneVec2Like, _src::GrapheneVec2Like) ret = ccall(("graphene_vec2_init_from_vec2", libgraphene), Ptr{_GrapheneVec2}, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _src) - ret2 = convert(Union{GrapheneVec2, Ref{_GrapheneVec2}}, ret, false) + ret2 = convert(GrapheneVec2Like, ret, false) ret2 end - function interpolate(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _v2::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _factor::Real) + function interpolate(instance::GrapheneVec2Like, _v2::GrapheneVec2Like, _factor::Real) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_interpolate", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Float64, Ptr{_GrapheneVec2}), instance, _v2, _factor, m_res) _res = m_res[] _res end - function length(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function length(instance::GrapheneVec2Like) ret = ccall(("graphene_vec2_length", libgraphene), Float32, (Ptr{_GrapheneVec2},), instance) ret end - function max(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _b::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function max(instance::GrapheneVec2Like, _b::GrapheneVec2Like) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_max", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _b, m_res) _res = m_res[] _res end - function min(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _b::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function min(instance::GrapheneVec2Like, _b::GrapheneVec2Like) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_min", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _b, m_res) _res = m_res[] _res end - function multiply(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _b::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function multiply(instance::GrapheneVec2Like, _b::GrapheneVec2Like) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_multiply", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _b, m_res) _res = m_res[] _res end - function near(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _v2::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _epsilon::Real) + function near(instance::GrapheneVec2Like, _v2::GrapheneVec2Like, _epsilon::Real) ret = ccall(("graphene_vec2_near", libgraphene), Cint, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Float32), instance, _v2, _epsilon) ret2 = convert(Bool, ret) ret2 end - function negate(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function negate(instance::GrapheneVec2Like) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_negate", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, m_res) _res = m_res[] _res end - function normalize(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function normalize(instance::GrapheneVec2Like) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_normalize", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, m_res) _res = m_res[] _res end - function scale(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _factor::Real) + function scale(instance::GrapheneVec2Like, _factor::Real) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_scale", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Float32, Ptr{_GrapheneVec2}), instance, _factor, m_res) _res = m_res[] _res end - function subtract(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _b::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function subtract(instance::GrapheneVec2Like, _b::GrapheneVec2Like) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec2_subtract", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}, Ptr{_GrapheneVec2}), instance, _b, m_res) _res = m_res[] _res end - function to_float(instance::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function to_float(instance::GrapheneVec2Like) m_dest = Ref{Ptr{Float32}}() ret = ccall(("graphene_vec2_to_float", libgraphene), Nothing, (Ptr{_GrapheneVec2}, Ptr{Ptr{Float32}}), instance, m_dest) _dest = m_dest[] @@ -1599,146 +1599,146 @@ $(Expr(:toplevel, quote end function Vec4_alloc() ret = ccall(("graphene_vec4_alloc", libgraphene), Ptr{_GrapheneVec4}, ()) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, true) + ret2 = convert(GrapheneVec4Like, ret, true) ret2 end - function add(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _b::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function add(instance::GrapheneVec4Like, _b::GrapheneVec4Like) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_add", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _b, m_res) _res = m_res[] _res end - function divide(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _b::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function divide(instance::GrapheneVec4Like, _b::GrapheneVec4Like) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_divide", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _b, m_res) _res = m_res[] _res end - function dot(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _b::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function dot(instance::GrapheneVec4Like, _b::GrapheneVec4Like) ret = ccall(("graphene_vec4_dot", libgraphene), Float32, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _b) ret end - function equal(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _v2::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function equal(instance::GrapheneVec4Like, _v2::GrapheneVec4Like) ret = ccall(("graphene_vec4_equal", libgraphene), Cint, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _v2) ret2 = convert(Bool, ret) ret2 end - function free(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function free(instance::GrapheneVec4Like) ret = ccall(("graphene_vec4_free", libgraphene), Nothing, (Ptr{_GrapheneVec4},), instance) nothing end - function get_w(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function get_w(instance::GrapheneVec4Like) ret = ccall(("graphene_vec4_get_w", libgraphene), Float32, (Ptr{_GrapheneVec4},), instance) ret end - function get_x(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function get_x(instance::GrapheneVec4Like) ret = ccall(("graphene_vec4_get_x", libgraphene), Float32, (Ptr{_GrapheneVec4},), instance) ret end - function get_xy(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function get_xy(instance::GrapheneVec4Like) m_res = Ref{_GrapheneVec2}() ret = ccall(("graphene_vec4_get_xy", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec2}), instance, m_res) _res = m_res[] _res end - function get_xyz(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function get_xyz(instance::GrapheneVec4Like) m_res = Ref{_GrapheneVec3}() ret = ccall(("graphene_vec4_get_xyz", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec3}), instance, m_res) _res = m_res[] _res end - function get_y(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function get_y(instance::GrapheneVec4Like) ret = ccall(("graphene_vec4_get_y", libgraphene), Float32, (Ptr{_GrapheneVec4},), instance) ret end - function get_z(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function get_z(instance::GrapheneVec4Like) ret = ccall(("graphene_vec4_get_z", libgraphene), Float32, (Ptr{_GrapheneVec4},), instance) ret end - function init(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _x::Real, _y::Real, _z::Real, _w::Real) + function init(instance::GrapheneVec4Like, _x::Real, _y::Real, _z::Real, _w::Real) ret = ccall(("graphene_vec4_init", libgraphene), Ptr{_GrapheneVec4}, (Ptr{_GrapheneVec4}, Float32, Float32, Float32, Float32), instance, _x, _y, _z, _w) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end - function init_from_float(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _src) + function init_from_float(instance::GrapheneVec4Like, _src) _src_arr = convert(Vector{Float32}, _src) ret = ccall(("graphene_vec4_init_from_float", libgraphene), Ptr{_GrapheneVec4}, (Ptr{_GrapheneVec4}, Ptr{Float32}), instance, _src_arr) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end - function init_from_vec2(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _src::Union{GrapheneVec2, Ref{_GrapheneVec2}}, _z::Real, _w::Real) + function init_from_vec2(instance::GrapheneVec4Like, _src::GrapheneVec2Like, _z::Real, _w::Real) ret = ccall(("graphene_vec4_init_from_vec2", libgraphene), Ptr{_GrapheneVec4}, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec2}, Float32, Float32), instance, _src, _z, _w) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end - function init_from_vec3(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _src::Union{GrapheneVec3, Ref{_GrapheneVec3}}, _w::Real) + function init_from_vec3(instance::GrapheneVec4Like, _src::GrapheneVec3Like, _w::Real) ret = ccall(("graphene_vec4_init_from_vec3", libgraphene), Ptr{_GrapheneVec4}, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec3}, Float32), instance, _src, _w) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end - function init_from_vec4(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _src::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function init_from_vec4(instance::GrapheneVec4Like, _src::GrapheneVec4Like) ret = ccall(("graphene_vec4_init_from_vec4", libgraphene), Ptr{_GrapheneVec4}, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _src) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end - function interpolate(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _v2::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _factor::Real) + function interpolate(instance::GrapheneVec4Like, _v2::GrapheneVec4Like, _factor::Real) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_interpolate", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Float64, Ptr{_GrapheneVec4}), instance, _v2, _factor, m_res) _res = m_res[] _res end - function length(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function length(instance::GrapheneVec4Like) ret = ccall(("graphene_vec4_length", libgraphene), Float32, (Ptr{_GrapheneVec4},), instance) ret end - function max(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _b::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function max(instance::GrapheneVec4Like, _b::GrapheneVec4Like) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_max", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _b, m_res) _res = m_res[] _res end - function min(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _b::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function min(instance::GrapheneVec4Like, _b::GrapheneVec4Like) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_min", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _b, m_res) _res = m_res[] _res end - function multiply(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _b::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function multiply(instance::GrapheneVec4Like, _b::GrapheneVec4Like) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_multiply", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _b, m_res) _res = m_res[] _res end - function near(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _v2::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _epsilon::Real) + function near(instance::GrapheneVec4Like, _v2::GrapheneVec4Like, _epsilon::Real) ret = ccall(("graphene_vec4_near", libgraphene), Cint, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Float32), instance, _v2, _epsilon) ret2 = convert(Bool, ret) ret2 end - function negate(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function negate(instance::GrapheneVec4Like) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_negate", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, m_res) _res = m_res[] _res end - function normalize(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function normalize(instance::GrapheneVec4Like) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_normalize", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, m_res) _res = m_res[] _res end - function scale(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _factor::Real) + function scale(instance::GrapheneVec4Like, _factor::Real) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_scale", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Float32, Ptr{_GrapheneVec4}), instance, _factor, m_res) _res = m_res[] _res end - function subtract(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}, _b::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function subtract(instance::GrapheneVec4Like, _b::GrapheneVec4Like) m_res = Ref{_GrapheneVec4}() ret = ccall(("graphene_vec4_subtract", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}, Ptr{_GrapheneVec4}), instance, _b, m_res) _res = m_res[] _res end - function to_float(instance::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function to_float(instance::GrapheneVec4Like) m_dest = Ref{Ptr{Float32}}() ret = ccall(("graphene_vec4_to_float", libgraphene), Nothing, (Ptr{_GrapheneVec4}, Ptr{Ptr{Float32}}), instance, m_dest) _dest = m_dest[] diff --git a/src/gen/graphene_structs b/src/gen/graphene_structs index e7c2adba..baaf0466 100644 --- a/src/gen/graphene_structs +++ b/src/gen/graphene_structs @@ -18,6 +18,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneSimd4F}, p::Ptr{_GrapheneSimd4F}, owns = false) = begin GrapheneSimd4F(p, owns) end + const GrapheneSimd4FLike = Union{Ref{_GrapheneSimd4F}, GrapheneSimd4F} end end begin @@ -49,6 +50,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneVec3}, p::Ptr{_GrapheneVec3}, owns = false) = begin GrapheneVec3(p, owns) end + const GrapheneVec3Like = Union{Ref{_GrapheneVec3}, GrapheneVec3} end end begin @@ -68,6 +70,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneSimd4X4F}, p::Ptr{_GrapheneSimd4X4F}, owns = false) = begin GrapheneSimd4X4F(p, owns) end + const GrapheneSimd4X4FLike = Union{Ref{_GrapheneSimd4X4F}, GrapheneSimd4X4F} end end begin @@ -100,6 +103,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneSize}, p::Ptr{_GrapheneSize}, owns = false) = begin GrapheneSize(p, owns) end + const GrapheneSizeLike = Union{Ref{_GrapheneSize}, GrapheneSize} end end begin @@ -132,6 +136,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneBox}, p::Ptr{_GrapheneBox}, owns = false) = begin GrapheneBox(p, owns) end + const GrapheneBoxLike = Union{Ref{_GrapheneBox}, GrapheneBox} end end begin @@ -164,6 +169,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneEuler}, p::Ptr{_GrapheneEuler}, owns = false) = begin GrapheneEuler(p, owns) end + const GrapheneEulerLike = Union{Ref{_GrapheneEuler}, GrapheneEuler} end end begin @@ -185,6 +191,7 @@ $(Expr(:toplevel, quote push!(gboxed_types, GrapheneFrustum) end end + const GrapheneFrustumLike = GrapheneFrustum const _GrapheneFrustum = GrapheneFrustum end begin @@ -216,6 +223,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneMatrix}, p::Ptr{_GrapheneMatrix}, owns = false) = begin GrapheneMatrix(p, owns) end + const GrapheneMatrixLike = Union{Ref{_GrapheneMatrix}, GrapheneMatrix} end end begin @@ -248,6 +256,7 @@ $(Expr(:toplevel, quote convert(::Type{GraphenePlane}, p::Ptr{_GraphenePlane}, owns = false) = begin GraphenePlane(p, owns) end + const GraphenePlaneLike = Union{Ref{_GraphenePlane}, GraphenePlane} end end begin @@ -280,6 +289,7 @@ $(Expr(:toplevel, quote convert(::Type{GraphenePoint}, p::Ptr{_GraphenePoint}, owns = false) = begin GraphenePoint(p, owns) end + const GraphenePointLike = Union{Ref{_GraphenePoint}, GraphenePoint} end end begin @@ -313,6 +323,7 @@ $(Expr(:toplevel, quote convert(::Type{GraphenePoint3D}, p::Ptr{_GraphenePoint3D}, owns = false) = begin GraphenePoint3D(p, owns) end + const GraphenePoint3DLike = Union{Ref{_GraphenePoint3D}, GraphenePoint3D} end end begin @@ -334,6 +345,7 @@ $(Expr(:toplevel, quote push!(gboxed_types, GrapheneQuad) end end + const GrapheneQuadLike = GrapheneQuad const _GrapheneQuad = GrapheneQuad end begin @@ -368,6 +380,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneQuaternion}, p::Ptr{_GrapheneQuaternion}, owns = false) = begin GrapheneQuaternion(p, owns) end + const GrapheneQuaternionLike = Union{Ref{_GrapheneQuaternion}, GrapheneQuaternion} end end begin @@ -400,6 +413,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneRay}, p::Ptr{_GrapheneRay}, owns = false) = begin GrapheneRay(p, owns) end + const GrapheneRayLike = Union{Ref{_GrapheneRay}, GrapheneRay} end end begin @@ -432,6 +446,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneRect}, p::Ptr{_GrapheneRect}, owns = false) = begin GrapheneRect(p, owns) end + const GrapheneRectLike = Union{Ref{_GrapheneRect}, GrapheneRect} end end begin @@ -464,6 +479,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneSphere}, p::Ptr{_GrapheneSphere}, owns = false) = begin GrapheneSphere(p, owns) end + const GrapheneSphereLike = Union{Ref{_GrapheneSphere}, GrapheneSphere} end end begin @@ -497,6 +513,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneTriangle}, p::Ptr{_GrapheneTriangle}, owns = false) = begin GrapheneTriangle(p, owns) end + const GrapheneTriangleLike = Union{Ref{_GrapheneTriangle}, GrapheneTriangle} end end begin @@ -528,6 +545,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneVec2}, p::Ptr{_GrapheneVec2}, owns = false) = begin GrapheneVec2(p, owns) end + const GrapheneVec2Like = Union{Ref{_GrapheneVec2}, GrapheneVec2} end end begin @@ -559,6 +577,7 @@ $(Expr(:toplevel, quote convert(::Type{GrapheneVec4}, p::Ptr{_GrapheneVec4}, owns = false) = begin GrapheneVec4(p, owns) end + const GrapheneVec4Like = Union{Ref{_GrapheneVec4}, GrapheneVec4} end end gboxed_cache_init() = begin @@ -618,6 +637,6 @@ $(Expr(:toplevel, quote function GrapheneVec4() G_.Vec4_alloc() end - export GrapheneSimd4F, _GrapheneSimd4F, GrapheneVec3, _GrapheneVec3, GrapheneSimd4X4F, _GrapheneSimd4X4F, GrapheneSize, _GrapheneSize, GrapheneBox, _GrapheneBox, GrapheneEuler, _GrapheneEuler, GrapheneFrustum, _GrapheneFrustum, GrapheneMatrix, _GrapheneMatrix, GraphenePlane, _GraphenePlane, GraphenePoint, _GraphenePoint, GraphenePoint3D, _GraphenePoint3D, GrapheneQuad, _GrapheneQuad, GrapheneQuaternion, _GrapheneQuaternion, GrapheneRay, _GrapheneRay, GrapheneRect, _GrapheneRect, GrapheneSphere, _GrapheneSphere, GrapheneTriangle, _GrapheneTriangle, GrapheneVec2, _GrapheneVec2, GrapheneVec4, _GrapheneVec4 + export GrapheneSimd4F, _GrapheneSimd4F, GrapheneSimd4FLike, GrapheneVec3, _GrapheneVec3, GrapheneVec3Like, GrapheneSimd4X4F, _GrapheneSimd4X4F, GrapheneSimd4X4FLike, GrapheneSize, _GrapheneSize, GrapheneSizeLike, GrapheneBox, GrapheneBoxLike, _GrapheneBox, GrapheneEuler, GrapheneEulerLike, _GrapheneEuler, GrapheneFrustum, GrapheneFrustumLike, _GrapheneFrustum, GrapheneMatrix, GrapheneMatrixLike, _GrapheneMatrix, GraphenePlane, GraphenePlaneLike, _GraphenePlane, GraphenePoint, GraphenePointLike, _GraphenePoint, GraphenePoint3D, GraphenePoint3DLike, _GraphenePoint3D, GrapheneQuad, GrapheneQuadLike, _GrapheneQuad, GrapheneQuaternion, GrapheneQuaternionLike, _GrapheneQuaternion, GrapheneRay, GrapheneRayLike, _GrapheneRay, GrapheneRect, GrapheneRectLike, _GrapheneRect, GrapheneSphere, GrapheneSphereLike, _GrapheneSphere, GrapheneTriangle, GrapheneTriangleLike, _GrapheneTriangle, GrapheneVec2, GrapheneVec2Like, _GrapheneVec2, GrapheneVec4, GrapheneVec4Like, _GrapheneVec4 end)) end diff --git a/src/gen/gsk4_functions b/src/gen/gsk4_functions index 6c0d4eda..fae24a28 100644 --- a/src/gen/gsk4_functions +++ b/src/gen/gsk4_functions @@ -12,11 +12,11 @@ $(Expr(:toplevel, quote _out_transform = convert(GskTransform, _out_transform, true) (ret2, _out_transform) end - function value_set_render_node(_value::Union{GValue, Ref{_GValue}}, _node::GskRenderNode) + function value_set_render_node(_value::GValueLike, _node::GskRenderNode) ret = ccall(("gsk_value_set_render_node", libgtk4), Nothing, (Ptr{_GValue}, Ptr{GskRenderNode}), _value, _node) nothing end - function value_take_render_node(_value::Union{GValue, Ref{_GValue}}, _node::Maybe(GskRenderNode)) + function value_take_render_node(_value::GValueLike, _node::Maybe(GskRenderNode)) _node_maybe = nothing_to_null(_node) ret = ccall(("gsk_value_take_render_node", libgtk4), Nothing, (Ptr{_GValue}, Ptr{GskRenderNode}), _value, _node_maybe) nothing diff --git a/src/gen/gsk4_methods b/src/gen/gsk4_methods index 5f27e7d5..d45c000a 100644 --- a/src/gen/gsk4_methods +++ b/src/gen/gsk4_methods @@ -1,53 +1,53 @@ quote $(Expr(:toplevel, quote - function contains_point(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _point::Union{GraphenePoint, Ref{_GraphenePoint}}) + function contains_point(instance::GskRoundedRectLike, _point::GraphenePointLike) ret = ccall(("gsk_rounded_rect_contains_point", libgtk4), Cint, (Ptr{_GskRoundedRect}, Ptr{_GraphenePoint}), instance, _point) ret2 = convert(Bool, ret) ret2 end - function contains_rect(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _rect::Union{GrapheneRect, Ref{_GrapheneRect}}) + function contains_rect(instance::GskRoundedRectLike, _rect::GrapheneRectLike) ret = ccall(("gsk_rounded_rect_contains_rect", libgtk4), Cint, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}), instance, _rect) ret2 = convert(Bool, ret) ret2 end - function init(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _top_left::Union{GrapheneSize, Ref{_GrapheneSize}}, _top_right::Union{GrapheneSize, Ref{_GrapheneSize}}, _bottom_right::Union{GrapheneSize, Ref{_GrapheneSize}}, _bottom_left::Union{GrapheneSize, Ref{_GrapheneSize}}) + function init(instance::GskRoundedRectLike, _bounds::GrapheneRectLike, _top_left::GrapheneSizeLike, _top_right::GrapheneSizeLike, _bottom_right::GrapheneSizeLike, _bottom_left::GrapheneSizeLike) ret = ccall(("gsk_rounded_rect_init", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}, Ptr{_GrapheneSize}, Ptr{_GrapheneSize}, Ptr{_GrapheneSize}, Ptr{_GrapheneSize}), instance, _bounds, _top_left, _top_right, _bottom_right, _bottom_left) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end - function init_copy(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _src::Union{GskRoundedRect, Ref{_GskRoundedRect}}) + function init_copy(instance::GskRoundedRectLike, _src::GskRoundedRectLike) ret = ccall(("gsk_rounded_rect_init_copy", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Ptr{_GskRoundedRect}), instance, _src) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end - function init_from_rect(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _radius::Real) + function init_from_rect(instance::GskRoundedRectLike, _bounds::GrapheneRectLike, _radius::Real) ret = ccall(("gsk_rounded_rect_init_from_rect", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}, Float32), instance, _bounds, _radius) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end - function intersects_rect(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _rect::Union{GrapheneRect, Ref{_GrapheneRect}}) + function intersects_rect(instance::GskRoundedRectLike, _rect::GrapheneRectLike) ret = ccall(("gsk_rounded_rect_intersects_rect", libgtk4), Cint, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}), instance, _rect) ret2 = convert(Bool, ret) ret2 end - function is_rectilinear(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}) + function is_rectilinear(instance::GskRoundedRectLike) ret = ccall(("gsk_rounded_rect_is_rectilinear", libgtk4), Cint, (Ptr{_GskRoundedRect},), instance) ret2 = convert(Bool, ret) ret2 end - function normalize(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}) + function normalize(instance::GskRoundedRectLike) ret = ccall(("gsk_rounded_rect_normalize", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect},), instance) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end - function offset(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _dx::Real, _dy::Real) + function offset(instance::GskRoundedRectLike, _dx::Real, _dy::Real) ret = ccall(("gsk_rounded_rect_offset", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Float32, Float32), instance, _dx, _dy) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end - function shrink(instance::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _top::Real, _right::Real, _bottom::Real, _left::Real) + function shrink(instance::GskRoundedRectLike, _top::Real, _right::Real, _bottom::Real, _left::Real) ret = ccall(("gsk_rounded_rect_shrink", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Float32, Float32, Float32, Float32), instance, _top, _right, _bottom, _left) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end function ShaderArgsBuilder_new(_shader::GskGLShader, _initial_values::Maybe(GBytes)) @@ -77,15 +77,15 @@ $(Expr(:toplevel, quote ret = ccall(("gsk_shader_args_builder_set_uint", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, UInt32), instance, _idx, _value) nothing end - function set_vec2(instance::GskShaderArgsBuilder, _idx::Integer, _value::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function set_vec2(instance::GskShaderArgsBuilder, _idx::Integer, _value::GrapheneVec2Like) ret = ccall(("gsk_shader_args_builder_set_vec2", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, Ptr{_GrapheneVec2}), instance, _idx, _value) nothing end - function set_vec3(instance::GskShaderArgsBuilder, _idx::Integer, _value::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function set_vec3(instance::GskShaderArgsBuilder, _idx::Integer, _value::GrapheneVec3Like) ret = ccall(("gsk_shader_args_builder_set_vec3", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, Ptr{_GrapheneVec3}), instance, _idx, _value) nothing end - function set_vec4(instance::GskShaderArgsBuilder, _idx::Integer, _value::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function set_vec4(instance::GskShaderArgsBuilder, _idx::Integer, _value::GrapheneVec4Like) ret = ccall(("gsk_shader_args_builder_set_vec4", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, Ptr{_GrapheneVec4}), instance, _idx, _value) nothing end @@ -119,7 +119,7 @@ $(Expr(:toplevel, quote ret2 = convert_if_not_null(GskTransform, ret, true) ret2 end - function matrix(instance::GskTransform, _matrix::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function matrix(instance::GskTransform, _matrix::GrapheneMatrixLike) ret = ccall(("gsk_transform_matrix", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{_GrapheneMatrix}), instance, _matrix) ret2 = convert(GskTransform, ret, true) ret2 @@ -129,7 +129,7 @@ $(Expr(:toplevel, quote ret2 = convert(GskTransform, ret, true) ret2 end - function print(instance::GskTransform, _string::Union{GString, Ref{_GString}}) + function print(instance::GskTransform, _string::GStringLike) ret = ccall(("gsk_transform_print", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{_GString}), instance, _string) nothing end @@ -143,7 +143,7 @@ $(Expr(:toplevel, quote ret2 = convert_if_not_null(GskTransform, ret, true) ret2 end - function rotate_3d(instance::GskTransform, _angle::Real, _axis::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function rotate_3d(instance::GskTransform, _angle::Real, _axis::GrapheneVec3Like) ret = ccall(("gsk_transform_rotate_3d", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32, Ptr{_GrapheneVec3}), instance, _angle, _axis) ret2 = convert_if_not_null(GskTransform, ret, true) ret2 @@ -234,24 +234,24 @@ $(Expr(:toplevel, quote ret2 = convert_if_not_null(GskTransform, ret, true) ret2 end - function transform_bounds(instance::GskTransform, _rect::Union{GrapheneRect, Ref{_GrapheneRect}}) + function transform_bounds(instance::GskTransform, _rect::GrapheneRectLike) m_out_rect = Ref{_GrapheneRect}() ret = ccall(("gsk_transform_transform_bounds", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _rect, m_out_rect) _out_rect = m_out_rect[] _out_rect end - function transform_point(instance::GskTransform, _point::Union{GraphenePoint, Ref{_GraphenePoint}}) + function transform_point(instance::GskTransform, _point::GraphenePointLike) m_out_point = Ref{_GraphenePoint}() ret = ccall(("gsk_transform_transform_point", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}), instance, _point, m_out_point) _out_point = m_out_point[] _out_point end - function translate(instance::GskTransform, _point::Union{GraphenePoint, Ref{_GraphenePoint}}) + function translate(instance::GskTransform, _point::GraphenePointLike) ret = ccall(("gsk_transform_translate", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{_GraphenePoint}), instance, _point) ret2 = convert_if_not_null(GskTransform, ret, true) ret2 end - function translate_3d(instance::GskTransform, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function translate_3d(instance::GskTransform, _point::GraphenePoint3DLike) ret = ccall(("gsk_transform_translate_3d", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{_GraphenePoint3D}), instance, _point) ret2 = convert_if_not_null(GskTransform, ret, true) ret2 @@ -294,7 +294,7 @@ $(Expr(:toplevel, quote ret = ccall(("gsk_blur_node_get_radius", libgtk4), Float32, (Ptr{GskRenderNode},), instance) ret end - function BorderNode_new(_outline::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _border_width, _border_color) + function BorderNode_new(_outline::GskRoundedRectLike, _border_width, _border_color) _border_width_arr = convert(Vector{Float32}, _border_width) _border_color_arr = convert(Vector{_GdkRGBA}, _border_color) ret = ccall(("gsk_border_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GskRoundedRect}, Ptr{Float32}, Ptr{_GdkRGBA}), _outline, _border_width_arr, _border_color_arr) @@ -303,12 +303,12 @@ $(Expr(:toplevel, quote end function get_colors(instance::GskBorderNode) ret = ccall(("gsk_border_node_get_colors", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false) + ret2 = convert(GdkRGBALike, ret, false) ret2 end function get_outline(instance::GskBorderNode) ret = ccall(("gsk_border_node_get_outline", libgtk4), Ptr{_GskRoundedRect}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end function get_widths(instance::GskBorderNode) @@ -320,7 +320,7 @@ $(Expr(:toplevel, quote ret2 = GskBroadwayRendererLeaf(ret, true) ret2 end - function CairoNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function CairoNode_new(_bounds::GrapheneRectLike) ret = ccall(("gsk_cairo_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect},), _bounds) ret2 = convert(GskRenderNode, ret) ret2 @@ -340,7 +340,7 @@ $(Expr(:toplevel, quote ret2 = GskCairoRendererLeaf(ret, true) ret2 end - function ClipNode_new(_child::GskRenderNode, _clip::Union{GrapheneRect, Ref{_GrapheneRect}}) + function ClipNode_new(_child::GskRenderNode, _clip::GrapheneRectLike) ret = ccall(("gsk_clip_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{_GrapheneRect}), _child, _clip) ret2 = convert(GskRenderNode, ret) ret2 @@ -352,10 +352,10 @@ $(Expr(:toplevel, quote end function get_clip(instance::GskClipNode) ret = ccall(("gsk_clip_node_get_clip", libgtk4), Ptr{_GrapheneRect}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false) + ret2 = convert(GrapheneRectLike, ret, false) ret2 end - function ColorMatrixNode_new(_child::GskRenderNode, _color_matrix::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _color_offset::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function ColorMatrixNode_new(_child::GskRenderNode, _color_matrix::GrapheneMatrixLike, _color_offset::GrapheneVec4Like) ret = ccall(("gsk_color_matrix_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{_GrapheneMatrix}, Ptr{_GrapheneVec4}), _child, _color_matrix, _color_offset) ret2 = convert(GskRenderNode, ret) ret2 @@ -367,25 +367,25 @@ $(Expr(:toplevel, quote end function get_color_matrix(instance::GskColorMatrixNode) ret = ccall(("gsk_color_matrix_node_get_color_matrix", libgtk4), Ptr{_GrapheneMatrix}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false) + ret2 = convert(GrapheneMatrixLike, ret, false) ret2 end function get_color_offset(instance::GskColorMatrixNode) ret = ccall(("gsk_color_matrix_node_get_color_offset", libgtk4), Ptr{_GrapheneVec4}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false) + ret2 = convert(GrapheneVec4Like, ret, false) ret2 end - function ColorNode_new(_rgba::Union{GdkRGBA, Ref{_GdkRGBA}}, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function ColorNode_new(_rgba::GdkRGBALike, _bounds::GrapheneRectLike) ret = ccall(("gsk_color_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GdkRGBA}, Ptr{_GrapheneRect}), _rgba, _bounds) ret2 = convert(GskRenderNode, ret) ret2 end function get_color(instance::GskColorNode) ret = ccall(("gsk_color_node_get_color", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false) + ret2 = convert(GdkRGBALike, ret, false) ret2 end - function ConicGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _rotation::Real, _color_stops) + function ConicGradientNode_new(_bounds::GrapheneRectLike, _center::GraphenePointLike, _rotation::Real, _color_stops) _color_stops_arr = convert(Vector{_GskColorStop}, _color_stops) _n_color_stops = length(_color_stops) ret = ccall(("gsk_conic_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Float32, Ptr{_GskColorStop}, UInt64), _bounds, _center, _rotation, _color_stops_arr, _n_color_stops) @@ -398,7 +398,7 @@ $(Expr(:toplevel, quote end function get_center(instance::GskConicGradientNode) ret = ccall(("gsk_conic_gradient_node_get_center", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end function get_color_stops(instance::GskConicGradientNode) @@ -509,15 +509,15 @@ $(Expr(:toplevel, quote ret = ccall(("gsk_gl_shader_get_arg_uint", libgtk4), UInt32, (Ptr{GObject}, Ptr{GBytes}, Int32), instance, _args, _idx) ret end - function get_arg_vec2(instance::GskGLShader, _args::GBytes, _idx::Integer, _out_value::Union{GrapheneVec2, Ref{_GrapheneVec2}}) + function get_arg_vec2(instance::GskGLShader, _args::GBytes, _idx::Integer, _out_value::GrapheneVec2Like) ret = ccall(("gsk_gl_shader_get_arg_vec2", libgtk4), Nothing, (Ptr{GObject}, Ptr{GBytes}, Int32, Ptr{_GrapheneVec2}), instance, _args, _idx, _out_value) nothing end - function get_arg_vec3(instance::GskGLShader, _args::GBytes, _idx::Integer, _out_value::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function get_arg_vec3(instance::GskGLShader, _args::GBytes, _idx::Integer, _out_value::GrapheneVec3Like) ret = ccall(("gsk_gl_shader_get_arg_vec3", libgtk4), Nothing, (Ptr{GObject}, Ptr{GBytes}, Int32, Ptr{_GrapheneVec3}), instance, _args, _idx, _out_value) nothing end - function get_arg_vec4(instance::GskGLShader, _args::GBytes, _idx::Integer, _out_value::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function get_arg_vec4(instance::GskGLShader, _args::GBytes, _idx::Integer, _out_value::GrapheneVec4Like) ret = ccall(("gsk_gl_shader_get_arg_vec4", libgtk4), Nothing, (Ptr{GObject}, Ptr{GBytes}, Int32, Ptr{_GrapheneVec4}), instance, _args, _idx, _out_value) nothing end @@ -557,7 +557,7 @@ $(Expr(:toplevel, quote ret2 = GLUniformType(ret) ret2 end - function GLShaderNode_new(_shader::GskGLShader, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _args::GBytes, _children) + function GLShaderNode_new(_shader::GskGLShader, _bounds::GrapheneRectLike, _args::GBytes, _children) _children_arr = convert(Vector{Ptr{GskRenderNode}}, _children) _n_children = length(_children) ret = ccall(("gsk_gl_shader_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GObject}, Ptr{_GrapheneRect}, Ptr{GBytes}, Ptr{Ptr{GskRenderNode}}, UInt32), _shader, _bounds, _args, _children_arr, _n_children) @@ -583,7 +583,7 @@ $(Expr(:toplevel, quote ret2 = convert(GskGLShader, ret, false) ret2 end - function InsetShadowNode_new(_outline::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) + function InsetShadowNode_new(_outline::GskRoundedRectLike, _color::GdkRGBALike, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) ret = ccall(("gsk_inset_shadow_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GskRoundedRect}, Ptr{_GdkRGBA}, Float32, Float32, Float32, Float32), _outline, _color, _dx, _dy, _spread, _blur_radius) ret2 = convert(GskRenderNode, ret) ret2 @@ -594,7 +594,7 @@ $(Expr(:toplevel, quote end function get_color(instance::GskInsetShadowNode) ret = ccall(("gsk_inset_shadow_node_get_color", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false) + ret2 = convert(GdkRGBALike, ret, false) ret2 end function get_dx(instance::GskInsetShadowNode) @@ -607,14 +607,14 @@ $(Expr(:toplevel, quote end function get_outline(instance::GskInsetShadowNode) ret = ccall(("gsk_inset_shadow_node_get_outline", libgtk4), Ptr{_GskRoundedRect}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end function get_spread(instance::GskInsetShadowNode) ret = ccall(("gsk_inset_shadow_node_get_spread", libgtk4), Float32, (Ptr{GskRenderNode},), instance) ret end - function LinearGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _start::Union{GraphenePoint, Ref{_GraphenePoint}}, _end::Union{GraphenePoint, Ref{_GraphenePoint}}, _color_stops) + function LinearGradientNode_new(_bounds::GrapheneRectLike, _start::GraphenePointLike, _end::GraphenePointLike, _color_stops) _color_stops_arr = convert(Vector{_GskColorStop}, _color_stops) _n_color_stops = length(_color_stops) ret = ccall(("gsk_linear_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Ptr{_GskColorStop}, UInt64), _bounds, _start, _end, _color_stops_arr, _n_color_stops) @@ -630,7 +630,7 @@ $(Expr(:toplevel, quote end function get_end(instance::GskLinearGradientNode) ret = ccall(("gsk_linear_gradient_node_get_end", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end function get_n_color_stops(instance::GskLinearGradientNode) @@ -639,7 +639,7 @@ $(Expr(:toplevel, quote end function get_start(instance::GskLinearGradientNode) ret = ccall(("gsk_linear_gradient_node_get_start", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end function MaskNode_new(_source::GskRenderNode, _mask::GskRenderNode, _mask_mode) @@ -676,7 +676,7 @@ $(Expr(:toplevel, quote ret = ccall(("gsk_opacity_node_get_opacity", libgtk4), Float32, (Ptr{GskRenderNode},), instance) ret end - function OutsetShadowNode_new(_outline::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) + function OutsetShadowNode_new(_outline::GskRoundedRectLike, _color::GdkRGBALike, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) ret = ccall(("gsk_outset_shadow_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GskRoundedRect}, Ptr{_GdkRGBA}, Float32, Float32, Float32, Float32), _outline, _color, _dx, _dy, _spread, _blur_radius) ret2 = convert(GskRenderNode, ret) ret2 @@ -687,7 +687,7 @@ $(Expr(:toplevel, quote end function get_color(instance::GskOutsetShadowNode) ret = ccall(("gsk_outset_shadow_node_get_color", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false) + ret2 = convert(GdkRGBALike, ret, false) ret2 end function get_dx(instance::GskOutsetShadowNode) @@ -700,14 +700,14 @@ $(Expr(:toplevel, quote end function get_outline(instance::GskOutsetShadowNode) ret = ccall(("gsk_outset_shadow_node_get_outline", libgtk4), Ptr{_GskRoundedRect}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end function get_spread(instance::GskOutsetShadowNode) ret = ccall(("gsk_outset_shadow_node_get_spread", libgtk4), Float32, (Ptr{GskRenderNode},), instance) ret end - function RadialGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops) + function RadialGradientNode_new(_bounds::GrapheneRectLike, _center::GraphenePointLike, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops) _color_stops_arr = convert(Vector{_GskColorStop}, _color_stops) _n_color_stops = length(_color_stops) ret = ccall(("gsk_radial_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Float32, Float32, Float32, Float32, Ptr{_GskColorStop}, UInt64), _bounds, _center, _hradius, _vradius, _start, _end, _color_stops_arr, _n_color_stops) @@ -716,7 +716,7 @@ $(Expr(:toplevel, quote end function get_center(instance::GskRadialGradientNode) ret = ccall(("gsk_radial_gradient_node_get_center", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end function get_color_stops(instance::GskRadialGradientNode) @@ -825,7 +825,7 @@ $(Expr(:toplevel, quote ret = ccall(("gsk_renderer_render", libgtk4), Nothing, (Ptr{GObject}, Ptr{GskRenderNode}, Ptr{cairoRegion}), instance, _root, _region_maybe) nothing end - function render_texture(instance::GskRenderer, _root::GskRenderNode, _viewport::Maybe(Union{GrapheneRect, Ref{_GrapheneRect}})) + function render_texture(instance::GskRenderer, _root::GskRenderNode, _viewport::Maybe(GrapheneRectLike)) _viewport_maybe = nothing_to_null(_viewport) ret = ccall(("gsk_renderer_render_texture", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{GskRenderNode}, Ptr{_GrapheneRect}), instance, _root, _viewport_maybe) ret2 = convert(GdkTexture, ret, true) @@ -835,7 +835,7 @@ $(Expr(:toplevel, quote ret = ccall(("gsk_renderer_unrealize", libgtk4), Nothing, (Ptr{GObject},), instance) nothing end - function RepeatNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _child::GskRenderNode, _child_bounds::Maybe(Union{GrapheneRect, Ref{_GrapheneRect}})) + function RepeatNode_new(_bounds::GrapheneRectLike, _child::GskRenderNode, _child_bounds::Maybe(GrapheneRectLike)) _child_bounds_maybe = nothing_to_null(_child_bounds) ret = ccall(("gsk_repeat_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{GskRenderNode}, Ptr{_GrapheneRect}), _bounds, _child, _child_bounds_maybe) ret2 = convert(GskRenderNode, ret) @@ -848,24 +848,24 @@ $(Expr(:toplevel, quote end function get_child_bounds(instance::GskRepeatNode) ret = ccall(("gsk_repeat_node_get_child_bounds", libgtk4), Ptr{_GrapheneRect}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false) + ret2 = convert(GrapheneRectLike, ret, false) ret2 end - function RepeatingLinearGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _start::Union{GraphenePoint, Ref{_GraphenePoint}}, _end::Union{GraphenePoint, Ref{_GraphenePoint}}, _color_stops) + function RepeatingLinearGradientNode_new(_bounds::GrapheneRectLike, _start::GraphenePointLike, _end::GraphenePointLike, _color_stops) _color_stops_arr = convert(Vector{_GskColorStop}, _color_stops) _n_color_stops = length(_color_stops) ret = ccall(("gsk_repeating_linear_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Ptr{_GskColorStop}, UInt64), _bounds, _start, _end, _color_stops_arr, _n_color_stops) ret2 = convert(GskRenderNode, ret) ret2 end - function RepeatingRadialGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops) + function RepeatingRadialGradientNode_new(_bounds::GrapheneRectLike, _center::GraphenePointLike, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops) _color_stops_arr = convert(Vector{_GskColorStop}, _color_stops) _n_color_stops = length(_color_stops) ret = ccall(("gsk_repeating_radial_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Float32, Float32, Float32, Float32, Ptr{_GskColorStop}, UInt64), _bounds, _center, _hradius, _vradius, _start, _end, _color_stops_arr, _n_color_stops) ret2 = convert(GskRenderNode, ret) ret2 end - function RoundedClipNode_new(_child::GskRenderNode, _clip::Union{GskRoundedRect, Ref{_GskRoundedRect}}) + function RoundedClipNode_new(_child::GskRenderNode, _clip::GskRoundedRectLike) ret = ccall(("gsk_rounded_clip_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{_GskRoundedRect}), _child, _clip) ret2 = convert(GskRenderNode, ret) ret2 @@ -877,7 +877,7 @@ $(Expr(:toplevel, quote end function get_clip(instance::GskRoundedClipNode) ret = ccall(("gsk_rounded_clip_node_get_clip", libgtk4), Ptr{_GskRoundedRect}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GskRoundedRect, Ref{_GskRoundedRect}}, ret) + ret2 = convert(GskRoundedRectLike, ret) ret2 end function ShadowNode_new(_child::GskRenderNode, _shadows) @@ -898,17 +898,17 @@ $(Expr(:toplevel, quote end function get_shadow(instance::GskShadowNode, _i::Integer) ret = ccall(("gsk_shadow_node_get_shadow", libgtk4), Ptr{_GskShadow}, (Ptr{GskRenderNode}, UInt64), instance, _i) - ret2 = convert(Union{GskShadow, Ref{_GskShadow}}, ret) + ret2 = convert(GskShadowLike, ret) ret2 end - function TextNode_new(_font::PangoFont, _glyphs::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _offset::Union{GraphenePoint, Ref{_GraphenePoint}}) + function TextNode_new(_font::PangoFont, _glyphs::PangoGlyphStringLike, _color::GdkRGBALike, _offset::GraphenePointLike) ret = ccall(("gsk_text_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GObject}, Ptr{_PangoGlyphString}, Ptr{_GdkRGBA}, Ptr{_GraphenePoint}), _font, _glyphs, _color, _offset) ret2 = convert(GskRenderNode, ret) ret2 end function get_color(instance::GskTextNode) ret = ccall(("gsk_text_node_get_color", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false) + ret2 = convert(GdkRGBALike, ret, false) ret2 end function get_font(instance::GskTextNode) @@ -929,7 +929,7 @@ $(Expr(:toplevel, quote end function get_offset(instance::GskTextNode) ret = ccall(("gsk_text_node_get_offset", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance) - ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false) + ret2 = convert(GraphenePointLike, ret, false) ret2 end function has_color_glyphs(instance::GskTextNode) @@ -937,7 +937,7 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function TextureNode_new(_texture::GdkTexture, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function TextureNode_new(_texture::GdkTexture, _bounds::GrapheneRectLike) ret = ccall(("gsk_texture_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GObject}, Ptr{_GrapheneRect}), _texture, _bounds) ret2 = convert(GskRenderNode, ret) ret2 @@ -947,7 +947,7 @@ $(Expr(:toplevel, quote ret2 = convert(GdkTexture, ret, false) ret2 end - function TextureScaleNode_new(_texture::GdkTexture, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _filter) + function TextureScaleNode_new(_texture::GdkTexture, _bounds::GrapheneRectLike, _filter) ret = ccall(("gsk_texture_scale_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GObject}, Ptr{_GrapheneRect}, UInt32), _texture, _bounds, _filter) ret2 = convert(GskRenderNode, ret) ret2 diff --git a/src/gen/gsk4_structs b/src/gen/gsk4_structs index 6a3c51d4..3238e6a3 100644 --- a/src/gen/gsk4_structs +++ b/src/gen/gsk4_structs @@ -15,6 +15,7 @@ $(Expr(:toplevel, quote convert(::Type{GskColorStop}, p::Ptr{_GskColorStop}, owns = false) = begin GskColorStop(p, owns) end + const GskColorStopLike = Union{Ref{_GskColorStop}, GskColorStop} end end begin @@ -35,31 +36,36 @@ $(Expr(:toplevel, quote convert(::Type{GskParseLocation}, p::Ptr{_GskParseLocation}, owns = false) = begin GskParseLocation(p, owns) end + const GskParseLocationLike = Union{Ref{_GskParseLocation}, GskParseLocation} end end begin mutable struct GskRoundedRect handle::Ptr{GskRoundedRect} end + const GskRoundedRectLike = GskRoundedRect const _GskRoundedRect = GskRoundedRect end - mutable struct GskShaderArgsBuilder <: GBoxed - handle::Ptr{GskShaderArgsBuilder} - begin - (GLib.g_type(::Type{T}) where T <: GskShaderArgsBuilder) = begin - ccall(("gsk_shader_args_builder_get_type", libgtk4), GType, ()) - end - function GskShaderArgsBuilder(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GskShaderArgsBuilder <: GBoxed + handle::Ptr{GskShaderArgsBuilder} + begin + (GLib.g_type(::Type{T}) where T <: GskShaderArgsBuilder) = begin + ccall(("gsk_shader_args_builder_get_type", libgtk4), GType, ()) + end + function GskShaderArgsBuilder(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GskShaderArgsBuilder) end - push!(gboxed_types, GskShaderArgsBuilder) end + const GskShaderArgsBuilderLike = GskShaderArgsBuilder end begin struct _GskShadow @@ -78,25 +84,29 @@ $(Expr(:toplevel, quote convert(::Type{GskShadow}, p::Ptr{_GskShadow}, owns = false) = begin GskShadow(p, owns) end + const GskShadowLike = Union{Ref{_GskShadow}, GskShadow} end end - mutable struct GskTransform <: GBoxed - handle::Ptr{GskTransform} - begin - (GLib.g_type(::Type{T}) where T <: GskTransform) = begin - ccall(("gsk_transform_get_type", libgtk4), GType, ()) - end - function GskTransform(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GskTransform <: GBoxed + handle::Ptr{GskTransform} + begin + (GLib.g_type(::Type{T}) where T <: GskTransform) = begin + ccall(("gsk_transform_get_type", libgtk4), GType, ()) + end + function GskTransform(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GskTransform) end - push!(gboxed_types, GskTransform) end + const GskTransformLike = GskTransform end @doc "See the [GTK docs](https://docs.gtk.org/gsk4/struct.ColorStop.html)." GskColorStop @doc "See the [GTK docs](https://docs.gtk.org/gsk4/struct.ParseLocation.html)." GskParseLocation @@ -472,28 +482,28 @@ $(Expr(:toplevel, quote function GskBlurNode(_child::GskRenderNode, _radius::Real) G_.BlurNode_new(_child, _radius) end - function GskBorderNode(_outline::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _border_width, _border_color) + function GskBorderNode(_outline::GskRoundedRectLike, _border_width, _border_color) G_.BorderNode_new(_outline, _border_width, _border_color) end function GskBroadwayRenderer() G_.BroadwayRenderer_new() end - function GskCairoNode(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function GskCairoNode(_bounds::GrapheneRectLike) G_.CairoNode_new(_bounds) end function GskCairoRenderer() G_.CairoRenderer_new() end - function GskClipNode(_child::GskRenderNode, _clip::Union{GrapheneRect, Ref{_GrapheneRect}}) + function GskClipNode(_child::GskRenderNode, _clip::GrapheneRectLike) G_.ClipNode_new(_child, _clip) end - function GskColorMatrixNode(_child::GskRenderNode, _color_matrix::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _color_offset::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function GskColorMatrixNode(_child::GskRenderNode, _color_matrix::GrapheneMatrixLike, _color_offset::GrapheneVec4Like) G_.ColorMatrixNode_new(_child, _color_matrix, _color_offset) end - function GskColorNode(_rgba::Union{GdkRGBA, Ref{_GdkRGBA}}, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function GskColorNode(_rgba::GdkRGBALike, _bounds::GrapheneRectLike) G_.ColorNode_new(_rgba, _bounds) end - function GskConicGradientNode(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _rotation::Real, _color_stops) + function GskConicGradientNode(_bounds::GrapheneRectLike, _center::GraphenePointLike, _rotation::Real, _color_stops) G_.ConicGradientNode_new(_bounds, _center, _rotation, _color_stops) end function GskContainerNode(_children) @@ -518,13 +528,13 @@ $(Expr(:toplevel, quote GLib.setproperties!(obj; kwargs...) obj end - function GskGLShaderNode(_shader::GskGLShader, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _args::GBytes, _children) + function GskGLShaderNode(_shader::GskGLShader, _bounds::GrapheneRectLike, _args::GBytes, _children) G_.GLShaderNode_new(_shader, _bounds, _args, _children) end - function GskInsetShadowNode(_outline::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) + function GskInsetShadowNode(_outline::GskRoundedRectLike, _color::GdkRGBALike, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) G_.InsetShadowNode_new(_outline, _color, _dx, _dy, _spread, _blur_radius) end - function GskLinearGradientNode(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _start::Union{GraphenePoint, Ref{_GraphenePoint}}, _end::Union{GraphenePoint, Ref{_GraphenePoint}}, _color_stops) + function GskLinearGradientNode(_bounds::GrapheneRectLike, _start::GraphenePointLike, _end::GraphenePointLike, _color_stops) G_.LinearGradientNode_new(_bounds, _start, _end, _color_stops) end function GskMaskNode(_source::GskRenderNode, _mask::GskRenderNode, _mask_mode) @@ -533,10 +543,10 @@ $(Expr(:toplevel, quote function GskOpacityNode(_child::GskRenderNode, _opacity::Real) G_.OpacityNode_new(_child, _opacity) end - function GskOutsetShadowNode(_outline::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) + function GskOutsetShadowNode(_outline::GskRoundedRectLike, _color::GdkRGBALike, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) G_.OutsetShadowNode_new(_outline, _color, _dx, _dy, _spread, _blur_radius) end - function GskRadialGradientNode(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops) + function GskRadialGradientNode(_bounds::GrapheneRectLike, _center::GraphenePointLike, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops) G_.RadialGradientNode_new(_bounds, _center, _hradius, _vradius, _start, _end, _color_stops) end function GskRenderer(_surface::GdkSurface; kwargs...) @@ -544,28 +554,28 @@ $(Expr(:toplevel, quote GLib.setproperties!(obj; kwargs...) obj end - function GskRepeatNode(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _child::GskRenderNode, _child_bounds::Maybe(Union{GrapheneRect, Ref{_GrapheneRect}})) + function GskRepeatNode(_bounds::GrapheneRectLike, _child::GskRenderNode, _child_bounds::Maybe(GrapheneRectLike)) G_.RepeatNode_new(_bounds, _child, _child_bounds) end - function GskRepeatingLinearGradientNode(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _start::Union{GraphenePoint, Ref{_GraphenePoint}}, _end::Union{GraphenePoint, Ref{_GraphenePoint}}, _color_stops) + function GskRepeatingLinearGradientNode(_bounds::GrapheneRectLike, _start::GraphenePointLike, _end::GraphenePointLike, _color_stops) G_.RepeatingLinearGradientNode_new(_bounds, _start, _end, _color_stops) end - function GskRepeatingRadialGradientNode(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops) + function GskRepeatingRadialGradientNode(_bounds::GrapheneRectLike, _center::GraphenePointLike, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops) G_.RepeatingRadialGradientNode_new(_bounds, _center, _hradius, _vradius, _start, _end, _color_stops) end - function GskRoundedClipNode(_child::GskRenderNode, _clip::Union{GskRoundedRect, Ref{_GskRoundedRect}}) + function GskRoundedClipNode(_child::GskRenderNode, _clip::GskRoundedRectLike) G_.RoundedClipNode_new(_child, _clip) end function GskShadowNode(_child::GskRenderNode, _shadows) G_.ShadowNode_new(_child, _shadows) end - function GskTextNode(_font::PangoFont, _glyphs::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _offset::Union{GraphenePoint, Ref{_GraphenePoint}}) + function GskTextNode(_font::PangoFont, _glyphs::PangoGlyphStringLike, _color::GdkRGBALike, _offset::GraphenePointLike) G_.TextNode_new(_font, _glyphs, _color, _offset) end - function GskTextureNode(_texture::GdkTexture, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function GskTextureNode(_texture::GdkTexture, _bounds::GrapheneRectLike) G_.TextureNode_new(_texture, _bounds) end - function GskTextureScaleNode(_texture::GdkTexture, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _filter) + function GskTextureScaleNode(_texture::GdkTexture, _bounds::GrapheneRectLike, _filter) G_.TextureScaleNode_new(_texture, _bounds, _filter) end function GskTransformNode(_child::GskRenderNode, _transform::GskTransform) @@ -608,6 +618,6 @@ $(Expr(:toplevel, quote @doc "See the [GTK docs](https://docs.gtk.org/gsk4/class.TextureNode.html)." GskTextureNode @doc "See the [GTK docs](https://docs.gtk.org/gsk4/class.TextureScaleNode.html)." GskTextureScaleNode @doc "See the [GTK docs](https://docs.gtk.org/gsk4/class.TransformNode.html)." GskTransformNode - export GskColorStop, _GskColorStop, GskParseLocation, _GskParseLocation, GskRoundedRect, _GskRoundedRect, GskShaderArgsBuilder, GskShadow, _GskShadow, GskTransform, GskBlendNode, GskBlendNodeLeaf, GskBlurNode, GskBlurNodeLeaf, GskBorderNode, GskBorderNodeLeaf, GskBroadwayRenderer, GskBroadwayRendererLeaf, GskCairoNode, GskCairoNodeLeaf, GskCairoRenderer, GskCairoRendererLeaf, GskClipNode, GskClipNodeLeaf, GskColorMatrixNode, GskColorMatrixNodeLeaf, GskColorNode, GskColorNodeLeaf, GskConicGradientNode, GskConicGradientNodeLeaf, GskContainerNode, GskContainerNodeLeaf, GskCrossFadeNode, GskCrossFadeNodeLeaf, GskDebugNode, GskDebugNodeLeaf, GskGLRenderer, GskGLRendererLeaf, GskGLShader, GskGLShaderLeaf, GskGLShaderNode, GskGLShaderNodeLeaf, GskInsetShadowNode, GskInsetShadowNodeLeaf, GskLinearGradientNode, GskLinearGradientNodeLeaf, GskMaskNode, GskMaskNodeLeaf, GskNglRenderer, GskNglRendererLeaf, GskOpacityNode, GskOpacityNodeLeaf, GskOutsetShadowNode, GskOutsetShadowNodeLeaf, GskRadialGradientNode, GskRadialGradientNodeLeaf, GskRenderNode, GskRenderer, GskRepeatNode, GskRepeatNodeLeaf, GskRepeatingLinearGradientNode, GskRepeatingLinearGradientNodeLeaf, GskRepeatingRadialGradientNode, GskRepeatingRadialGradientNodeLeaf, GskRoundedClipNode, GskRoundedClipNodeLeaf, GskShadowNode, GskShadowNodeLeaf, GskTextNode, GskTextNodeLeaf, GskTextureNode, GskTextureNodeLeaf, GskTextureScaleNode, GskTextureScaleNodeLeaf, GskTransformNode, GskTransformNodeLeaf + export GskColorStop, GskColorStopLike, _GskColorStop, GskParseLocation, GskParseLocationLike, _GskParseLocation, GskRoundedRect, GskRoundedRectLike, _GskRoundedRect, GskShaderArgsBuilder, GskShadow, GskShadowLike, _GskShadow, GskTransform, GskBlendNode, GskBlendNodeLeaf, GskBlurNode, GskBlurNodeLeaf, GskBorderNode, GskBorderNodeLeaf, GskBroadwayRenderer, GskBroadwayRendererLeaf, GskCairoNode, GskCairoNodeLeaf, GskCairoRenderer, GskCairoRendererLeaf, GskClipNode, GskClipNodeLeaf, GskColorMatrixNode, GskColorMatrixNodeLeaf, GskColorNode, GskColorNodeLeaf, GskConicGradientNode, GskConicGradientNodeLeaf, GskContainerNode, GskContainerNodeLeaf, GskCrossFadeNode, GskCrossFadeNodeLeaf, GskDebugNode, GskDebugNodeLeaf, GskGLRenderer, GskGLRendererLeaf, GskGLShader, GskGLShaderLeaf, GskGLShaderNode, GskGLShaderNodeLeaf, GskInsetShadowNode, GskInsetShadowNodeLeaf, GskLinearGradientNode, GskLinearGradientNodeLeaf, GskMaskNode, GskMaskNodeLeaf, GskNglRenderer, GskNglRendererLeaf, GskOpacityNode, GskOpacityNodeLeaf, GskOutsetShadowNode, GskOutsetShadowNodeLeaf, GskRadialGradientNode, GskRadialGradientNodeLeaf, GskRenderNode, GskRenderer, GskRepeatNode, GskRepeatNodeLeaf, GskRepeatingLinearGradientNode, GskRepeatingLinearGradientNodeLeaf, GskRepeatingRadialGradientNode, GskRepeatingRadialGradientNodeLeaf, GskRoundedClipNode, GskRoundedClipNodeLeaf, GskShadowNode, GskShadowNodeLeaf, GskTextNode, GskTextNodeLeaf, GskTextureNode, GskTextureNodeLeaf, GskTextureScaleNode, GskTextureScaleNodeLeaf, GskTransformNode, GskTransformNodeLeaf end)) end diff --git a/src/gen/gtk4_functions b/src/gen/gtk4_functions index 00643c1d..abd9bda0 100644 --- a/src/gen/gtk4_functions +++ b/src/gen/gtk4_functions @@ -42,15 +42,15 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function accessible_property_init_value(_property, _value::Union{GValue, Ref{_GValue}}) + function accessible_property_init_value(_property, _value::GValueLike) ret = ccall(("gtk_accessible_property_init_value", libgtk4), Nothing, (UInt32, Ptr{_GValue}), _property, _value) nothing end - function accessible_relation_init_value(_relation, _value::Union{GValue, Ref{_GValue}}) + function accessible_relation_init_value(_relation, _value::GValueLike) ret = ccall(("gtk_accessible_relation_init_value", libgtk4), Nothing, (UInt32, Ptr{_GValue}), _relation, _value) nothing end - function accessible_state_init_value(_state, _value::Union{GValue, Ref{_GValue}}) + function accessible_state_init_value(_state, _value::GValueLike) ret = ccall(("gtk_accessible_state_init_value", libgtk4), Nothing, (UInt32, Ptr{_GValue}), _state, _value) nothing end @@ -116,12 +116,12 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_distribute_natural_allocation", libgtk4), Int32, (Int32, UInt32, Ptr{_GtkRequestedSize}), _extra_space, _n_requested_sizes, _sizes_arr) ret end - function editable_delegate_get_property(_object::GObject, _prop_id::Integer, _value::Union{GValue, Ref{_GValue}}, _pspec::GParam) + function editable_delegate_get_property(_object::GObject, _prop_id::Integer, _value::GValueLike, _pspec::GParam) ret = ccall(("gtk_editable_delegate_get_property", libgtk4), Cint, (Ptr{GObject}, UInt32, Ptr{_GValue}, Ptr{GParam}), _object, _prop_id, _value, _pspec) ret2 = convert(Bool, ret) ret2 end - function editable_delegate_set_property(_object::GObject, _prop_id::Integer, _value::Union{GValue, Ref{_GValue}}, _pspec::GParam) + function editable_delegate_set_property(_object::GObject, _prop_id::Integer, _value::GValueLike, _pspec::GParam) ret = ccall(("gtk_editable_delegate_set_property", libgtk4), Cint, (Ptr{GObject}, UInt32, Ptr{_GValue}, Ptr{GParam}), _object, _prop_id, _value, _pspec) ret2 = convert(Bool, ret) ret2 @@ -364,7 +364,7 @@ $(Expr(:toplevel, quote ret2 = convert(GdkContentProvider, ret, true) ret2 end - function tree_get_row_drag_data(_value::Union{GValue, Ref{_GValue}}) + function tree_get_row_drag_data(_value::GValueLike) m_tree_model = Ref{Ptr{GObject}}() m_path = Ref{Ptr{GtkTreePath}}() ret = ccall(("gtk_tree_get_row_drag_data", libgtk4), Cint, (Ptr{_GValue}, Ptr{Ptr{GObject}}, Ptr{Ptr{GtkTreePath}}), _value, m_tree_model, m_path) diff --git a/src/gen/gtk4_methods b/src/gen/gtk4_methods index 37e6635f..0be2dfd8 100644 --- a/src/gen/gtk4_methods +++ b/src/gen/gtk4_methods @@ -2,19 +2,19 @@ quote $(Expr(:toplevel, quote function Border_new() ret = ccall(("gtk_border_new", libgtk4), Ptr{_GtkBorder}, ()) - ret2 = convert(Union{GtkBorder, Ref{_GtkBorder}}, ret, true) + ret2 = convert(GtkBorderLike, ret, true) ret2 end - function copy(instance::Union{GtkBorder, Ref{_GtkBorder}}) + function copy(instance::GtkBorderLike) ret = ccall(("gtk_border_copy", libgtk4), Ptr{_GtkBorder}, (Ptr{_GtkBorder},), instance) - ret2 = convert(Union{GtkBorder, Ref{_GtkBorder}}, ret, true) + ret2 = convert(GtkBorderLike, ret, true) ret2 end - function free(instance::Union{GtkBorder, Ref{_GtkBorder}}) + function free(instance::GtkBorderLike) ret = ccall(("gtk_border_free", libgtk4), Nothing, (Ptr{_GtkBorder},), instance) nothing end - function evaluate(instance::GtkExpressionWatch, _value::Union{GValue, Ref{_GValue}}) + function evaluate(instance::GtkExpressionWatch, _value::GValueLike) ret = ccall(("gtk_expression_watch_evaluate", libgtk4), Cint, (Ptr{GtkExpressionWatch}, Ptr{_GValue}), instance, _value) ret2 = convert(Bool, ret) ret2 @@ -287,15 +287,15 @@ $(Expr(:toplevel, quote end function Requisition_new() ret = ccall(("gtk_requisition_new", libgtk4), Ptr{_GtkRequisition}, ()) - ret2 = convert(Union{GtkRequisition, Ref{_GtkRequisition}}, ret, true) + ret2 = convert(GtkRequisitionLike, ret, true) ret2 end - function copy(instance::Union{GtkRequisition, Ref{_GtkRequisition}}) + function copy(instance::GtkRequisitionLike) ret = ccall(("gtk_requisition_copy", libgtk4), Ptr{_GtkRequisition}, (Ptr{_GtkRequisition},), instance) - ret2 = convert(Union{GtkRequisition, Ref{_GtkRequisition}}, ret, true) + ret2 = convert(GtkRequisitionLike, ret, true) ret2 end - function free(instance::Union{GtkRequisition, Ref{_GtkRequisition}}) + function free(instance::GtkRequisitionLike) ret = ccall(("gtk_requisition_free", libgtk4), Nothing, (Ptr{_GtkRequisition},), instance) nothing end @@ -331,12 +331,473 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_scroll_info_unref", libgtk4), Nothing, (Ptr{GtkScrollInfo},), instance) nothing end - function copy(instance::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function assign(instance::GtkTextIterLike, _other::GtkTextIterLike) + ret = ccall(("gtk_text_iter_assign", libgtk4), Nothing, (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _other) + nothing + end + function backward_char(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_backward_char", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function backward_chars(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_backward_chars", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function backward_cursor_position(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_backward_cursor_position", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function backward_cursor_positions(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_backward_cursor_positions", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function backward_find_char(instance::GtkTextIterLike, _pred::Function, _limit::Maybe(GtkTextIterLike)) + begin + _pred_cfunc = @cfunction(GtkTextCharPredicate, Cint, (Nothing, Ref{Function})) + begin + ref = Ref{Any}(_pred) + _pred_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref))) + end + end + _limit_maybe = nothing_to_null(_limit) + ret = ccall(("gtk_text_iter_backward_find_char", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{_GtkTextIter}), instance, _pred_cfunc, _pred_closure, _limit_maybe) + ret2 = convert(Bool, ret) + ret2 + end + function backward_line(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_backward_line", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function backward_lines(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_backward_lines", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function backward_search(instance::GtkTextIterLike, _str::Union{AbstractString, Symbol}, _flags, _limit::Maybe(GtkTextIterLike)) + m_match_start = Ref{_GtkTextIter}() + m_match_end = Ref{_GtkTextIter}() + _limit_maybe = nothing_to_null(_limit) + ret = ccall(("gtk_text_iter_backward_search", libgtk4), Cint, (Ptr{_GtkTextIter}, Cstring, UInt32, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _str, _flags, m_match_start, m_match_end, _limit_maybe) + ret2 = convert(Bool, ret) + _match_start = m_match_start[] + _match_end = m_match_end[] + (ret2, _match_start, _match_end) + end + function backward_sentence_start(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_backward_sentence_start", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function backward_sentence_starts(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_backward_sentence_starts", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function backward_to_tag_toggle(instance::GtkTextIterLike, _tag::Maybe(GtkTextTag)) + _tag_maybe = nothing_to_null(_tag) + ret = ccall(("gtk_text_iter_backward_to_tag_toggle", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{GObject}), instance, _tag_maybe) + ret2 = convert(Bool, ret) + ret2 + end + function backward_visible_cursor_position(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_backward_visible_cursor_position", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function backward_visible_cursor_positions(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_backward_visible_cursor_positions", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function backward_visible_line(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_backward_visible_line", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function backward_visible_lines(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_backward_visible_lines", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function backward_visible_word_start(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_backward_visible_word_start", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function backward_visible_word_starts(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_backward_visible_word_starts", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function backward_word_start(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_backward_word_start", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function backward_word_starts(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_backward_word_starts", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function can_insert(instance::GtkTextIterLike, _default_editability::Bool) + ret = ccall(("gtk_text_iter_can_insert", libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), instance, _default_editability) + ret2 = convert(Bool, ret) + ret2 + end + function compare(instance::GtkTextIterLike, _rhs::GtkTextIterLike) + ret = ccall(("gtk_text_iter_compare", libgtk4), Int32, (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _rhs) + ret + end + function copy(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_copy", libgtk4), Ptr{_GtkTextIter}, (Ptr{_GtkTextIter},), instance) + ret2 = convert(GtkTextIterLike, ret, true) + ret2 + end + function editable(instance::GtkTextIterLike, _default_setting::Bool) + ret = ccall(("gtk_text_iter_editable", libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), instance, _default_setting) + ret2 = convert(Bool, ret) + ret2 + end + function ends_line(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_ends_line", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function ends_sentence(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_ends_sentence", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function ends_tag(instance::GtkTextIterLike, _tag::Maybe(GtkTextTag)) + _tag_maybe = nothing_to_null(_tag) + ret = ccall(("gtk_text_iter_ends_tag", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{GObject}), instance, _tag_maybe) + ret2 = convert(Bool, ret) + ret2 + end + function ends_word(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_ends_word", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function equal(instance::GtkTextIterLike, _rhs::GtkTextIterLike) + ret = ccall(("gtk_text_iter_equal", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _rhs) + ret2 = convert(Bool, ret) + ret2 + end + function forward_char(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_char", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function forward_chars(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_forward_chars", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function forward_cursor_position(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_cursor_position", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function forward_cursor_positions(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_forward_cursor_positions", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function forward_find_char(instance::GtkTextIterLike, _pred::Function, _limit::Maybe(GtkTextIterLike)) + begin + _pred_cfunc = @cfunction(GtkTextCharPredicate, Cint, (Nothing, Ref{Function})) + begin + ref = Ref{Any}(_pred) + _pred_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref))) + end + end + _limit_maybe = nothing_to_null(_limit) + ret = ccall(("gtk_text_iter_forward_find_char", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{_GtkTextIter}), instance, _pred_cfunc, _pred_closure, _limit_maybe) + ret2 = convert(Bool, ret) + ret2 + end + function forward_line(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_line", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function forward_lines(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_forward_lines", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function forward_search(instance::GtkTextIterLike, _str::Union{AbstractString, Symbol}, _flags, _limit::Maybe(GtkTextIterLike)) + m_match_start = Ref{_GtkTextIter}() + m_match_end = Ref{_GtkTextIter}() + _limit_maybe = nothing_to_null(_limit) + ret = ccall(("gtk_text_iter_forward_search", libgtk4), Cint, (Ptr{_GtkTextIter}, Cstring, UInt32, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _str, _flags, m_match_start, m_match_end, _limit_maybe) + ret2 = convert(Bool, ret) + _match_start = m_match_start[] + _match_end = m_match_end[] + (ret2, _match_start, _match_end) + end + function forward_sentence_end(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_sentence_end", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function forward_sentence_ends(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_forward_sentence_ends", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function forward_to_end(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_to_end", libgtk4), Nothing, (Ptr{_GtkTextIter},), instance) + nothing + end + function forward_to_line_end(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_to_line_end", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function forward_to_tag_toggle(instance::GtkTextIterLike, _tag::Maybe(GtkTextTag)) + _tag_maybe = nothing_to_null(_tag) + ret = ccall(("gtk_text_iter_forward_to_tag_toggle", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{GObject}), instance, _tag_maybe) + ret2 = convert(Bool, ret) + ret2 + end + function forward_visible_cursor_position(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_visible_cursor_position", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function forward_visible_cursor_positions(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_forward_visible_cursor_positions", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function forward_visible_line(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_visible_line", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function forward_visible_lines(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_forward_visible_lines", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function forward_visible_word_end(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_visible_word_end", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function forward_visible_word_ends(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_forward_visible_word_ends", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function forward_word_end(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_forward_word_end", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function forward_word_ends(instance::GtkTextIterLike, _count::Integer) + ret = ccall(("gtk_text_iter_forward_word_ends", libgtk4), Cint, (Ptr{_GtkTextIter}, Int32), instance, _count) + ret2 = convert(Bool, ret) + ret2 + end + function free(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_free", libgtk4), Nothing, (Ptr{_GtkTextIter},), instance) + nothing + end + function get_buffer(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_buffer", libgtk4), Ptr{GObject}, (Ptr{_GtkTextIter},), instance) + ret2 = convert(GtkTextBuffer, ret, false) + ret2 + end + function get_bytes_in_line(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_bytes_in_line", libgtk4), Int32, (Ptr{_GtkTextIter},), instance) + ret + end + function get_char(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_char", libgtk4), Nothing, (Ptr{_GtkTextIter},), instance) + nothing + end + function get_chars_in_line(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_chars_in_line", libgtk4), Int32, (Ptr{_GtkTextIter},), instance) + ret + end + function get_child_anchor(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_child_anchor", libgtk4), Ptr{GObject}, (Ptr{_GtkTextIter},), instance) + ret2 = convert_if_not_null(GtkTextChildAnchor, ret, false) + ret2 + end + function get_language(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_language", libgtk4), Ptr{PangoLanguage}, (Ptr{_GtkTextIter},), instance) + ret2 = convert(PangoLanguage, ret, true) + ret2 + end + function get_line(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_line", libgtk4), Int32, (Ptr{_GtkTextIter},), instance) + ret + end + function get_line_index(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_line_index", libgtk4), Int32, (Ptr{_GtkTextIter},), instance) + ret + end + function get_line_offset(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_line_offset", libgtk4), Int32, (Ptr{_GtkTextIter},), instance) + ret + end + function get_marks(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_marks", libgtk4), Ptr{GLib._GSList{Ptr{GObject}}}, (Ptr{_GtkTextIter},), instance) + ret2 = GLib.GList(ret, false) + ret2 + end + function get_offset(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_offset", libgtk4), Int32, (Ptr{_GtkTextIter},), instance) + ret + end + function get_paintable(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_paintable", libgtk4), Ptr{GObject}, (Ptr{_GtkTextIter},), instance) + ret2 = GLib.find_leaf_type_if_not_null(ret, false) + ret2 + end + function get_slice(instance::GtkTextIterLike, _end::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_slice", libgtk4), Cstring, (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _end) + ret2 = string_or_nothing(ret, true) + ret2 + end + function get_tags(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_tags", libgtk4), Ptr{GLib._GSList{Ptr{GObject}}}, (Ptr{_GtkTextIter},), instance) + ret2 = GLib.GList(ret, false) + ret2 + end + function get_text(instance::GtkTextIterLike, _end::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_text", libgtk4), Cstring, (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _end) + ret2 = string_or_nothing(ret, true) + ret2 + end + function get_toggled_tags(instance::GtkTextIterLike, _toggled_on::Bool) + ret = ccall(("gtk_text_iter_get_toggled_tags", libgtk4), Ptr{GLib._GSList{Ptr{GObject}}}, (Ptr{_GtkTextIter}, Cint), instance, _toggled_on) + ret2 = GLib.GList(ret, false) + ret2 + end + function get_visible_line_index(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_visible_line_index", libgtk4), Int32, (Ptr{_GtkTextIter},), instance) + ret + end + function get_visible_line_offset(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_visible_line_offset", libgtk4), Int32, (Ptr{_GtkTextIter},), instance) + ret + end + function get_visible_slice(instance::GtkTextIterLike, _end::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_visible_slice", libgtk4), Cstring, (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _end) + ret2 = string_or_nothing(ret, true) + ret2 + end + function get_visible_text(instance::GtkTextIterLike, _end::GtkTextIterLike) + ret = ccall(("gtk_text_iter_get_visible_text", libgtk4), Cstring, (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _end) + ret2 = string_or_nothing(ret, true) + ret2 + end + function has_tag(instance::GtkTextIterLike, _tag::GtkTextTag) + ret = ccall(("gtk_text_iter_has_tag", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{GObject}), instance, _tag) + ret2 = convert(Bool, ret) + ret2 + end + function in_range(instance::GtkTextIterLike, _start::GtkTextIterLike, _end::GtkTextIterLike) + ret = ccall(("gtk_text_iter_in_range", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _start, _end) + ret2 = convert(Bool, ret) + ret2 + end + function inside_sentence(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_inside_sentence", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function inside_word(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_inside_word", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function is_cursor_position(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_is_cursor_position", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function is_end(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_is_end", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function is_start(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_is_start", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function order(instance::GtkTextIterLike, _second::GtkTextIterLike) + ret = ccall(("gtk_text_iter_order", libgtk4), Nothing, (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _second) + nothing + end + function set_line(instance::GtkTextIterLike, _line_number::Integer) + ret = ccall(("gtk_text_iter_set_line", libgtk4), Nothing, (Ptr{_GtkTextIter}, Int32), instance, _line_number) + nothing + end + function set_line_index(instance::GtkTextIterLike, _byte_on_line::Integer) + ret = ccall(("gtk_text_iter_set_line_index", libgtk4), Nothing, (Ptr{_GtkTextIter}, Int32), instance, _byte_on_line) + nothing + end + function set_line_offset(instance::GtkTextIterLike, _char_on_line::Integer) + ret = ccall(("gtk_text_iter_set_line_offset", libgtk4), Nothing, (Ptr{_GtkTextIter}, Int32), instance, _char_on_line) + nothing + end + function set_offset(instance::GtkTextIterLike, _char_offset::Integer) + ret = ccall(("gtk_text_iter_set_offset", libgtk4), Nothing, (Ptr{_GtkTextIter}, Int32), instance, _char_offset) + nothing + end + function set_visible_line_index(instance::GtkTextIterLike, _byte_on_line::Integer) + ret = ccall(("gtk_text_iter_set_visible_line_index", libgtk4), Nothing, (Ptr{_GtkTextIter}, Int32), instance, _byte_on_line) + nothing + end + function set_visible_line_offset(instance::GtkTextIterLike, _char_on_line::Integer) + ret = ccall(("gtk_text_iter_set_visible_line_offset", libgtk4), Nothing, (Ptr{_GtkTextIter}, Int32), instance, _char_on_line) + nothing + end + function starts_line(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_starts_line", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function starts_sentence(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_starts_sentence", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function starts_tag(instance::GtkTextIterLike, _tag::Maybe(GtkTextTag)) + _tag_maybe = nothing_to_null(_tag) + ret = ccall(("gtk_text_iter_starts_tag", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{GObject}), instance, _tag_maybe) + ret2 = convert(Bool, ret) + ret2 + end + function starts_word(instance::GtkTextIterLike) + ret = ccall(("gtk_text_iter_starts_word", libgtk4), Cint, (Ptr{_GtkTextIter},), instance) + ret2 = convert(Bool, ret) + ret2 + end + function toggles_tag(instance::GtkTextIterLike, _tag::Maybe(GtkTextTag)) + _tag_maybe = nothing_to_null(_tag) + ret = ccall(("gtk_text_iter_toggles_tag", libgtk4), Cint, (Ptr{_GtkTextIter}, Ptr{GObject}), instance, _tag_maybe) + ret2 = convert(Bool, ret) + ret2 + end + function copy(instance::GtkTreeIterLike) ret = ccall(("gtk_tree_iter_copy", libgtk4), Ptr{_GtkTreeIter}, (Ptr{_GtkTreeIter},), instance) - ret2 = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, ret, true) + ret2 = convert(GtkTreeIterLike, ret, true) ret2 end - function free(instance::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function free(instance::GtkTreeIterLike) ret = ccall(("gtk_tree_iter_free", libgtk4), Nothing, (Ptr{_GtkTreeIter},), instance) nothing end @@ -2519,7 +2980,7 @@ $(Expr(:toplevel, quote function get_buildable_id(instance::GtkCalendar) get_buildable_id(GtkBuildable(instance)) end - function activate(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _cell_area::Union{GdkRectangle, Ref{_GdkRectangle}}, _flags, _edit_only::Bool) + function activate(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _cell_area::GdkRectangleLike, _flags, _edit_only::Bool) ret = ccall(("gtk_cell_area_activate", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{_GdkRectangle}, UInt32, Cint), instance, _context, _widget, _cell_area, _flags, _edit_only) ret2 = convert(Bool, ret) ret2 @@ -2532,7 +2993,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_cell_area_add_focus_sibling", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}), instance, _renderer, _sibling) nothing end - function apply_attributes(instance::GtkCellArea, _tree_model::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _is_expander::Bool, _is_expanded::Bool) + function apply_attributes(instance::GtkCellArea, _tree_model::GtkTreeModel, _iter::GtkTreeIterLike, _is_expander::Bool, _is_expanded::Bool) ret = ccall(("gtk_cell_area_apply_attributes", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GtkTreeIter}, Cint, Cint), instance, _tree_model, _iter, _is_expander, _is_expanded) nothing end @@ -2548,11 +3009,11 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_cell_area_attribute_get_column", libgtk4), Int32, (Ptr{GObject}, Ptr{GObject}, Cstring), instance, _renderer, _attribute) ret end - function cell_get_property(instance::GtkCellArea, _renderer::GtkCellRenderer, _property_name::Union{AbstractString, Symbol}, _value::Union{GValue, Ref{_GValue}}) + function cell_get_property(instance::GtkCellArea, _renderer::GtkCellRenderer, _property_name::Union{AbstractString, Symbol}, _value::GValueLike) ret = ccall(("gtk_cell_area_cell_get_property", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Cstring, Ptr{_GValue}), instance, _renderer, _property_name, _value) nothing end - function cell_set_property(instance::GtkCellArea, _renderer::GtkCellRenderer, _property_name::Union{AbstractString, Symbol}, _value::Union{GValue, Ref{_GValue}}) + function cell_set_property(instance::GtkCellArea, _renderer::GtkCellRenderer, _property_name::Union{AbstractString, Symbol}, _value::GValueLike) ret = ccall(("gtk_cell_area_cell_set_property", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Cstring, Ptr{_GValue}), instance, _renderer, _property_name, _value) nothing end @@ -2582,7 +3043,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_cell_area_foreach", libgtk4), Nothing, (Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _callback_cfunc, _callback_closure) nothing end - function foreach_alloc(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _cell_area::Union{GdkRectangle, Ref{_GdkRectangle}}, _background_area::Union{GdkRectangle, Ref{_GdkRectangle}}, _callback::Function) + function foreach_alloc(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _cell_area::GdkRectangleLike, _background_area::GdkRectangleLike, _callback::Function) begin _callback_cfunc = @cfunction(GtkCellAllocCallback, Cint, (Ptr{GObject}, Ptr{_GdkRectangle}, Ptr{_GdkRectangle}, Ref{Function})) begin @@ -2593,13 +3054,13 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_cell_area_foreach_alloc", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{_GdkRectangle}, Ptr{_GdkRectangle}, Ptr{Cvoid}, Ptr{Nothing}), instance, _context, _widget, _cell_area, _background_area, _callback_cfunc, _callback_closure) nothing end - function get_cell_allocation(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _renderer::GtkCellRenderer, _cell_area::Union{GdkRectangle, Ref{_GdkRectangle}}) + function get_cell_allocation(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _renderer::GtkCellRenderer, _cell_area::GdkRectangleLike) m_allocation = Ref{_GdkRectangle}() ret = ccall(("gtk_cell_area_get_cell_allocation", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{_GdkRectangle}, Ptr{_GdkRectangle}), instance, _context, _widget, _renderer, _cell_area, m_allocation) _allocation = m_allocation[] _allocation end - function get_cell_at_position(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _cell_area::Union{GdkRectangle, Ref{_GdkRectangle}}, _x::Integer, _y::Integer) + function get_cell_at_position(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _cell_area::GdkRectangleLike, _x::Integer, _y::Integer) m_alloc_area = Ref{_GdkRectangle}() ret = ccall(("gtk_cell_area_get_cell_at_position", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{_GdkRectangle}, Int32, Int32, Ptr{_GdkRectangle}), instance, _context, _widget, _cell_area, _x, _y, m_alloc_area) ret2 = convert(GtkCellRenderer, ret, false) @@ -2678,7 +3139,7 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function inner_cell_area(instance::GtkCellArea, _widget::GtkWidget, _cell_area::Union{GdkRectangle, Ref{_GdkRectangle}}) + function inner_cell_area(instance::GtkCellArea, _widget::GtkWidget, _cell_area::GdkRectangleLike) m_inner_area = Ref{_GdkRectangle}() ret = ccall(("gtk_cell_area_inner_cell_area", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GdkRectangle}, Ptr{_GdkRectangle}), instance, _widget, _cell_area, m_inner_area) _inner_area = m_inner_area[] @@ -2715,7 +3176,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_cell_area_set_focus_cell", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _renderer_maybe) nothing end - function snapshot(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _snapshot::GtkSnapshot, _background_area::Union{GdkRectangle, Ref{_GdkRectangle}}, _cell_area::Union{GdkRectangle, Ref{_GdkRectangle}}, _flags, _paint_focus::Bool) + function snapshot(instance::GtkCellArea, _context::GtkCellAreaContext, _widget::GtkWidget, _snapshot::GtkSnapshot, _background_area::GdkRectangleLike, _cell_area::GdkRectangleLike, _flags, _paint_focus::Bool) ret = ccall(("gtk_cell_area_snapshot", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{_GdkRectangle}, Ptr{_GdkRectangle}, UInt32, Cint), instance, _context, _widget, _snapshot, _background_area, _cell_area, _flags, _paint_focus) nothing end @@ -3392,7 +3853,7 @@ $(Expr(:toplevel, quote ret2 = GtkColorButtonLeaf(ret, false) ret2 end - function ColorButton_new_with_rgba(_rgba::Union{GdkRGBA, Ref{_GdkRGBA}}) + function ColorButton_new_with_rgba(_rgba::GdkRGBALike) ret = ccall(("gtk_color_button_new_with_rgba", libgtk4), Ptr{GObject}, (Ptr{_GdkRGBA},), _rgba) ret2 = GtkColorButtonLeaf(ret, false) ret2 @@ -3472,7 +3933,7 @@ $(Expr(:toplevel, quote function get_use_alpha(instance::GtkColorButton) get_use_alpha(GtkColorChooser(instance)) end - function set_rgba(instance::GtkColorButton, _color::Union{GdkRGBA, Ref{_GdkRGBA}}) + function set_rgba(instance::GtkColorButton, _color::GdkRGBALike) set_rgba(GtkColorChooser(instance), _color) end function set_use_alpha(instance::GtkColorButton, _use_alpha::Bool) @@ -3542,7 +4003,7 @@ $(Expr(:toplevel, quote function get_use_alpha(instance::GtkColorChooserDialog) get_use_alpha(GtkColorChooser(instance)) end - function set_rgba(instance::GtkColorChooserDialog, _color::Union{GdkRGBA, Ref{_GdkRGBA}}) + function set_rgba(instance::GtkColorChooserDialog, _color::GdkRGBALike) set_rgba(GtkColorChooser(instance), _color) end function set_use_alpha(instance::GtkColorChooserDialog, _use_alpha::Bool) @@ -3634,7 +4095,7 @@ $(Expr(:toplevel, quote function get_use_alpha(instance::GtkColorChooserWidget) get_use_alpha(GtkColorChooser(instance)) end - function set_rgba(instance::GtkColorChooserWidget, _color::Union{GdkRGBA, Ref{_GdkRGBA}}) + function set_rgba(instance::GtkColorChooserWidget, _color::GdkRGBALike) set_rgba(GtkColorChooser(instance), _color) end function set_use_alpha(instance::GtkColorChooserWidget, _use_alpha::Bool) @@ -3645,7 +4106,7 @@ $(Expr(:toplevel, quote ret2 = GtkColorDialogLeaf(ret, true) ret2 end - function choose_rgba(instance::GtkColorDialog, _parent::Maybe(GtkWindow), _initial_color::Maybe(Union{GdkRGBA, Ref{_GdkRGBA}}), _cancellable::Maybe(GCancellable), _callback::Maybe(Function)) + function choose_rgba(instance::GtkColorDialog, _parent::Maybe(GtkWindow), _initial_color::Maybe(GdkRGBALike), _cancellable::Maybe(GCancellable), _callback::Maybe(Function)) _parent_maybe = nothing_to_null(_parent) _initial_color_maybe = nothing_to_null(_initial_color) _cancellable_maybe = nothing_to_null(_cancellable) @@ -3711,14 +4172,14 @@ $(Expr(:toplevel, quote end function get_rgba(instance::GtkColorDialogButton) ret = ccall(("gtk_color_dialog_button_get_rgba", libgtk4), Ptr{_GdkRGBA}, (Ptr{GObject},), instance) - ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false) + ret2 = convert(GdkRGBALike, ret, false) ret2 end function set_dialog(instance::GtkColorDialogButton, _dialog::GtkColorDialog) ret = ccall(("gtk_color_dialog_button_set_dialog", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _dialog) nothing end - function set_rgba(instance::GtkColorDialogButton, _color::Union{GdkRGBA, Ref{_GdkRGBA}}) + function set_rgba(instance::GtkColorDialogButton, _color::GdkRGBALike) ret = ccall(("gtk_color_dialog_button_set_rgba", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GdkRGBA}), instance, _color) nothing end @@ -4283,7 +4744,7 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function set_active_iter(instance::GtkComboBox, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function set_active_iter(instance::GtkComboBox, _iter::Maybe(GtkTreeIterLike)) _iter_maybe = nothing_to_null(_iter) ret = ccall(("gtk_combo_box_set_active_iter", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter_maybe) nothing @@ -4532,14 +4993,14 @@ $(Expr(:toplevel, quote function set_cell_data_func(instance::GtkComboBoxText, _cell::GtkCellRenderer, _func::Maybe(Function), _destroy::Function) set_cell_data_func(GtkCellLayout(instance), _cell, _func, _destroy) end - function ConstantExpression_new_for_value(_value::Union{GValue, Ref{_GValue}}) + function ConstantExpression_new_for_value(_value::GValueLike) ret = ccall(("gtk_constant_expression_new_for_value", libgtk4), Ptr{GtkExpression}, (Ptr{_GValue},), _value) ret2 = convert(GtkExpression, ret) ret2 end function get_value(instance::GtkConstantExpression) ret = ccall(("gtk_constant_expression_get_value", libgtk4), Ptr{_GValue}, (Ptr{GtkExpression},), instance) - ret2 = convert(Union{GValue, Ref{_GValue}}, ret, false) + ret2 = convert(GValueLike, ret, false) ret2 end function Constraint_new(_target::Maybe(GtkConstraintTarget), _target_attribute, _relation, _source::Maybe(GtkConstraintTarget), _source_attribute, _multiplier::Real, _constant::Real, _strength::Integer) @@ -4942,7 +5403,7 @@ $(Expr(:toplevel, quote function items_changed(instance::GtkDirectoryList, _position::Integer, _removed::Integer, _added::Integer) items_changed(GListModel(instance), _position, _removed, _added) end - function create_widget_for_value(_value::Union{GValue, Ref{_GValue}}) + function create_widget_for_value(_value::GValueLike) ret = ccall(("gtk_drag_icon_create_widget_for_value", libgtk4), Ptr{GObject}, (Ptr{_GValue},), _value) ret2 = convert_if_not_null(GtkWidget, ret, true) ret2 @@ -6475,7 +6936,7 @@ $(Expr(:toplevel, quote ret2 = convert(GtkExpressionWatch, ret, false) ret2 end - function evaluate(instance::GtkExpression, _this_::Maybe(GObject), _value::Union{GValue, Ref{_GValue}}) + function evaluate(instance::GtkExpression, _this_::Maybe(GObject), _value::GValueLike) _this__maybe = nothing_to_null(_this_) ret = ccall(("gtk_expression_evaluate", libgtk4), Cint, (Ptr{GtkExpression}, Ptr{GObject}, Ptr{_GValue}), instance, _this__maybe, _value) ret2 = convert(Bool, ret) @@ -9386,7 +9847,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_im_context_set_client_widget", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _widget_maybe) nothing end - function set_cursor_location(instance::GtkIMContext, _area::Union{GdkRectangle, Ref{_GdkRectangle}}) + function set_cursor_location(instance::GtkIMContext, _area::GdkRectangleLike) ret = ccall(("gtk_im_context_set_cursor_location", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GdkRectangle}), instance, _area) nothing end @@ -11468,14 +11929,14 @@ $(Expr(:toplevel, quote _iter = m_iter[] _iter end - function insert_after(instance::GtkListStore, _sibling::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function insert_after(instance::GtkListStore, _sibling::Maybe(GtkTreeIterLike)) m_iter = Ref{_GtkTreeIter}() _sibling_maybe = nothing_to_null(_sibling) ret = ccall(("gtk_list_store_insert_after", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_iter, _sibling_maybe) _iter = m_iter[] _iter end - function insert_before(instance::GtkListStore, _sibling::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function insert_before(instance::GtkListStore, _sibling::Maybe(GtkTreeIterLike)) m_iter = Ref{_GtkTreeIter}() _sibling_maybe = nothing_to_null(_sibling) ret = ccall(("gtk_list_store_insert_before", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_iter, _sibling_maybe) @@ -11492,17 +11953,17 @@ $(Expr(:toplevel, quote _iter = m_iter[] _iter end - function iter_is_valid(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_is_valid(instance::GtkListStore, _iter::GtkTreeIterLike) ret = ccall(("gtk_list_store_iter_is_valid", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 end - function move_after(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _position::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function move_after(instance::GtkListStore, _iter::GtkTreeIterLike, _position::Maybe(GtkTreeIterLike)) _position_maybe = nothing_to_null(_position) ret = ccall(("gtk_list_store_move_after", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, _iter, _position_maybe) nothing end - function move_before(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _position::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function move_before(instance::GtkListStore, _iter::GtkTreeIterLike, _position::Maybe(GtkTreeIterLike)) _position_maybe = nothing_to_null(_position) ret = ccall(("gtk_list_store_move_before", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, _iter, _position_maybe) nothing @@ -11513,7 +11974,7 @@ $(Expr(:toplevel, quote _iter = m_iter[] _iter end - function remove(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function remove(instance::GtkListStore, _iter::GtkTreeIterLike) ret = ccall(("gtk_list_store_remove", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 @@ -11529,11 +11990,11 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_list_store_set_column_types", libgtk4), Nothing, (Ptr{GObject}, Int32, Ptr{UInt64}), instance, _n_columns, _types_arr) nothing end - function set_value(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _column::Integer, _value::Union{GValue, Ref{_GValue}}) + function set_value(instance::GtkListStore, _iter::GtkTreeIterLike, _column::Integer, _value::GValueLike) ret = ccall(("gtk_list_store_set_value", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Int32, Ptr{_GValue}), instance, _iter, _column, _value) nothing end - function set(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _columns, _values) + function set(instance::GtkListStore, _iter::GtkTreeIterLike, _columns, _values) _columns_arr = convert(Vector{Int32}, _columns) _values_arr = convert(Vector{_GValue}, _values) _n_values = length(_columns) @@ -11541,17 +12002,17 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_list_store_set_valuesv", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{Int32}, Ptr{_GValue}, Int32), instance, _iter, _columns_arr, _values_arr, _n_values) nothing end - function swap(instance::GtkListStore, _a::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _b::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function swap(instance::GtkListStore, _a::GtkTreeIterLike, _b::GtkTreeIterLike) ret = ccall(("gtk_list_store_swap", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, _a, _b) nothing end function get_buildable_id(instance::GtkListStore) get_buildable_id(GtkBuildable(instance)) end - function drag_data_received(instance::GtkListStore, _dest::GtkTreePath, _value::Union{GValue, Ref{_GValue}}) + function drag_data_received(instance::GtkListStore, _dest::GtkTreePath, _value::GValueLike) drag_data_received(GtkTreeDragDest(instance), _dest, _value) end - function row_drop_possible(instance::GtkListStore, _dest_path::GtkTreePath, _value::Union{GValue, Ref{_GValue}}) + function row_drop_possible(instance::GtkListStore, _dest_path::GtkTreePath, _value::GValueLike) row_drop_possible(GtkTreeDragDest(instance), _dest_path, _value) end function drag_data_delete(instance::GtkListStore, _path::GtkTreePath) @@ -11587,55 +12048,55 @@ $(Expr(:toplevel, quote function get_n_columns(instance::GtkListStore) get_n_columns(GtkTreeModel(instance)) end - function get_path(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_path(instance::GtkListStore, _iter::GtkTreeIterLike) get_path(GtkTreeModel(instance), _iter) end - function get_string_from_iter(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_string_from_iter(instance::GtkListStore, _iter::GtkTreeIterLike) get_string_from_iter(GtkTreeModel(instance), _iter) end - function get_value(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _column::Integer) + function get_value(instance::GtkListStore, _iter::GtkTreeIterLike, _column::Integer) get_value(GtkTreeModel(instance), _iter, _column) end - function iter_children(instance::GtkListStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_children(instance::GtkListStore, _parent::Maybe(GtkTreeIterLike)) iter_children(GtkTreeModel(instance), _parent) end - function iter_has_child(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_has_child(instance::GtkListStore, _iter::GtkTreeIterLike) iter_has_child(GtkTreeModel(instance), _iter) end - function iter_n_children(instance::GtkListStore, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_n_children(instance::GtkListStore, _iter::Maybe(GtkTreeIterLike)) iter_n_children(GtkTreeModel(instance), _iter) end - function iter_next(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_next(instance::GtkListStore, _iter::GtkTreeIterLike) iter_next(GtkTreeModel(instance), _iter) end - function iter_nth_child(instance::GtkListStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _n::Integer) + function iter_nth_child(instance::GtkListStore, _parent::Maybe(GtkTreeIterLike), _n::Integer) iter_nth_child(GtkTreeModel(instance), _parent, _n) end - function iter_parent(instance::GtkListStore, _child::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_parent(instance::GtkListStore, _child::GtkTreeIterLike) iter_parent(GtkTreeModel(instance), _child) end - function iter_previous(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_previous(instance::GtkListStore, _iter::GtkTreeIterLike) iter_previous(GtkTreeModel(instance), _iter) end - function ref_node(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function ref_node(instance::GtkListStore, _iter::GtkTreeIterLike) ref_node(GtkTreeModel(instance), _iter) end - function row_changed(instance::GtkListStore, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_changed(instance::GtkListStore, _path::GtkTreePath, _iter::GtkTreeIterLike) row_changed(GtkTreeModel(instance), _path, _iter) end function row_deleted(instance::GtkListStore, _path::GtkTreePath) row_deleted(GtkTreeModel(instance), _path) end - function row_has_child_toggled(instance::GtkListStore, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_has_child_toggled(instance::GtkListStore, _path::GtkTreePath, _iter::GtkTreeIterLike) row_has_child_toggled(GtkTreeModel(instance), _path, _iter) end - function row_inserted(instance::GtkListStore, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_inserted(instance::GtkListStore, _path::GtkTreePath, _iter::GtkTreeIterLike) row_inserted(GtkTreeModel(instance), _path, _iter) end - function rows_reordered(instance::GtkListStore, _path::GtkTreePath, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _new_order) + function rows_reordered(instance::GtkListStore, _path::GtkTreePath, _iter::Maybe(GtkTreeIterLike), _new_order) rows_reordered(GtkTreeModel(instance), _path, _iter, _new_order) end - function unref_node(instance::GtkListStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function unref_node(instance::GtkListStore, _iter::GtkTreeIterLike) unref_node(GtkTreeModel(instance), _iter) end function get_sort_column_id(instance::GtkListStore) @@ -13870,7 +14331,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_popover_set_offset", libgtk4), Nothing, (Ptr{GObject}, Int32, Int32), instance, _x_offset, _y_offset) nothing end - function set_pointing_to(instance::GtkPopover, _rect::Maybe(Union{GdkRectangle, Ref{_GdkRectangle}})) + function set_pointing_to(instance::GtkPopover, _rect::Maybe(GdkRectangleLike)) _rect_maybe = nothing_to_null(_rect) ret = ccall(("gtk_popover_set_pointing_to", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GdkRectangle}), instance, _rect_maybe) nothing @@ -15726,7 +16187,7 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function print(instance::GtkShortcutAction, _string::Union{GString, Ref{_GString}}) + function print(instance::GtkShortcutAction, _string::GStringLike) ret = ccall(("gtk_shortcut_action_print", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GString}), instance, _string) nothing end @@ -15876,11 +16337,11 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_shortcut_trigger_hash", libgtk4), UInt32, (Ptr{GObject},), instance) ret end - function print(instance::GtkShortcutTrigger, _string::Union{GString, Ref{_GString}}) + function print(instance::GtkShortcutTrigger, _string::GStringLike) ret = ccall(("gtk_shortcut_trigger_print", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GString}), instance, _string) nothing end - function print_label(instance::GtkShortcutTrigger, _display::GdkDisplay, _string::Union{GString, Ref{_GString}}) + function print_label(instance::GtkShortcutTrigger, _display::GdkDisplay, _string::GStringLike) ret = ccall(("gtk_shortcut_trigger_print_label", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{_GString}), instance, _display, _string) ret2 = convert(Bool, ret) ret2 @@ -16336,68 +16797,68 @@ $(Expr(:toplevel, quote ret2 = GtkSnapshotLeaf(ret, true) ret2 end - function append_border(instance::GtkSnapshot, _outline::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _border_width, _border_color) + function append_border(instance::GtkSnapshot, _outline::GskRoundedRectLike, _border_width, _border_color) _border_width_arr = convert(Vector{Float32}, _border_width) _border_color_arr = convert(Vector{_GdkRGBA}, _border_color) ret = ccall(("gtk_snapshot_append_border", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GskRoundedRect}, Ptr{Float32}, Ptr{_GdkRGBA}), instance, _outline, _border_width_arr, _border_color_arr) nothing end - function append_cairo(instance::GtkSnapshot, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function append_cairo(instance::GtkSnapshot, _bounds::GrapheneRectLike) ret = ccall(("gtk_snapshot_append_cairo", libgtk4), Ptr{cairoContext}, (Ptr{GObject}, Ptr{_GrapheneRect}), instance, _bounds) ret2 = convert(cairoContext, ret, true) ret2 end - function append_color(instance::GtkSnapshot, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function append_color(instance::GtkSnapshot, _color::GdkRGBALike, _bounds::GrapheneRectLike) ret = ccall(("gtk_snapshot_append_color", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GdkRGBA}, Ptr{_GrapheneRect}), instance, _color, _bounds) nothing end - function append_conic_gradient(instance::GtkSnapshot, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _rotation::Real, _stops) + function append_conic_gradient(instance::GtkSnapshot, _bounds::GrapheneRectLike, _center::GraphenePointLike, _rotation::Real, _stops) _stops_arr = convert(Vector{_GskColorStop}, _stops) _n_stops = length(_stops) ret = ccall(("gtk_snapshot_append_conic_gradient", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Float32, Ptr{_GskColorStop}, UInt64), instance, _bounds, _center, _rotation, _stops_arr, _n_stops) nothing end - function append_inset_shadow(instance::GtkSnapshot, _outline::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) + function append_inset_shadow(instance::GtkSnapshot, _outline::GskRoundedRectLike, _color::GdkRGBALike, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) ret = ccall(("gtk_snapshot_append_inset_shadow", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GskRoundedRect}, Ptr{_GdkRGBA}, Float32, Float32, Float32, Float32), instance, _outline, _color, _dx, _dy, _spread, _blur_radius) nothing end - function append_layout(instance::GtkSnapshot, _layout::PangoLayout, _color::Union{GdkRGBA, Ref{_GdkRGBA}}) + function append_layout(instance::GtkSnapshot, _layout::PangoLayout, _color::GdkRGBALike) ret = ccall(("gtk_snapshot_append_layout", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GdkRGBA}), instance, _layout, _color) nothing end - function append_linear_gradient(instance::GtkSnapshot, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _start_point::Union{GraphenePoint, Ref{_GraphenePoint}}, _end_point::Union{GraphenePoint, Ref{_GraphenePoint}}, _stops) + function append_linear_gradient(instance::GtkSnapshot, _bounds::GrapheneRectLike, _start_point::GraphenePointLike, _end_point::GraphenePointLike, _stops) _stops_arr = convert(Vector{_GskColorStop}, _stops) _n_stops = length(_stops) ret = ccall(("gtk_snapshot_append_linear_gradient", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Ptr{_GskColorStop}, UInt64), instance, _bounds, _start_point, _end_point, _stops_arr, _n_stops) nothing end - function append_outset_shadow(instance::GtkSnapshot, _outline::Union{GskRoundedRect, Ref{_GskRoundedRect}}, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) + function append_outset_shadow(instance::GtkSnapshot, _outline::GskRoundedRectLike, _color::GdkRGBALike, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real) ret = ccall(("gtk_snapshot_append_outset_shadow", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GskRoundedRect}, Ptr{_GdkRGBA}, Float32, Float32, Float32, Float32), instance, _outline, _color, _dx, _dy, _spread, _blur_radius) nothing end - function append_radial_gradient(instance::GtkSnapshot, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _stops) + function append_radial_gradient(instance::GtkSnapshot, _bounds::GrapheneRectLike, _center::GraphenePointLike, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _stops) _stops_arr = convert(Vector{_GskColorStop}, _stops) _n_stops = length(_stops) ret = ccall(("gtk_snapshot_append_radial_gradient", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Float32, Float32, Float32, Float32, Ptr{_GskColorStop}, UInt64), instance, _bounds, _center, _hradius, _vradius, _start, _end, _stops_arr, _n_stops) nothing end - function append_repeating_linear_gradient(instance::GtkSnapshot, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _start_point::Union{GraphenePoint, Ref{_GraphenePoint}}, _end_point::Union{GraphenePoint, Ref{_GraphenePoint}}, _stops) + function append_repeating_linear_gradient(instance::GtkSnapshot, _bounds::GrapheneRectLike, _start_point::GraphenePointLike, _end_point::GraphenePointLike, _stops) _stops_arr = convert(Vector{_GskColorStop}, _stops) _n_stops = length(_stops) ret = ccall(("gtk_snapshot_append_repeating_linear_gradient", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Ptr{_GskColorStop}, UInt64), instance, _bounds, _start_point, _end_point, _stops_arr, _n_stops) nothing end - function append_repeating_radial_gradient(instance::GtkSnapshot, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _stops) + function append_repeating_radial_gradient(instance::GtkSnapshot, _bounds::GrapheneRectLike, _center::GraphenePointLike, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _stops) _stops_arr = convert(Vector{_GskColorStop}, _stops) _n_stops = length(_stops) ret = ccall(("gtk_snapshot_append_repeating_radial_gradient", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Float32, Float32, Float32, Float32, Ptr{_GskColorStop}, UInt64), instance, _bounds, _center, _hradius, _vradius, _start, _end, _stops_arr, _n_stops) nothing end - function append_scaled_texture(instance::GtkSnapshot, _texture::GdkTexture, _filter, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function append_scaled_texture(instance::GtkSnapshot, _texture::GdkTexture, _filter, _bounds::GrapheneRectLike) ret = ccall(("gtk_snapshot_append_scaled_texture", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{_GrapheneRect}), instance, _texture, _filter, _bounds) nothing end - function append_texture(instance::GtkSnapshot, _texture::GdkTexture, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function append_texture(instance::GtkSnapshot, _texture::GdkTexture, _bounds::GrapheneRectLike) ret = ccall(("gtk_snapshot_append_texture", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GrapheneRect}), instance, _texture, _bounds) nothing end @@ -16421,11 +16882,11 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_snapshot_push_blur", libgtk4), Nothing, (Ptr{GObject}, Float64), instance, _radius) nothing end - function push_clip(instance::GtkSnapshot, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}) + function push_clip(instance::GtkSnapshot, _bounds::GrapheneRectLike) ret = ccall(("gtk_snapshot_push_clip", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GrapheneRect}), instance, _bounds) nothing end - function push_color_matrix(instance::GtkSnapshot, _color_matrix::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _color_offset::Union{GrapheneVec4, Ref{_GrapheneVec4}}) + function push_color_matrix(instance::GtkSnapshot, _color_matrix::GrapheneMatrixLike, _color_offset::GrapheneVec4Like) ret = ccall(("gtk_snapshot_push_color_matrix", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GrapheneMatrix}, Ptr{_GrapheneVec4}), instance, _color_matrix, _color_offset) nothing end @@ -16433,7 +16894,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_snapshot_push_cross_fade", libgtk4), Nothing, (Ptr{GObject}, Float64), instance, _progress) nothing end - function push_gl_shader(instance::GtkSnapshot, _shader::GskGLShader, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _take_args::GBytes) + function push_gl_shader(instance::GtkSnapshot, _shader::GskGLShader, _bounds::GrapheneRectLike, _take_args::GBytes) ret = ccall(("gtk_snapshot_push_gl_shader", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GrapheneRect}, Ptr{GBytes}), instance, _shader, _bounds, _take_args) nothing end @@ -16445,12 +16906,12 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_snapshot_push_opacity", libgtk4), Nothing, (Ptr{GObject}, Float64), instance, _opacity) nothing end - function push_repeat(instance::GtkSnapshot, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _child_bounds::Maybe(Union{GrapheneRect, Ref{_GrapheneRect}})) + function push_repeat(instance::GtkSnapshot, _bounds::GrapheneRectLike, _child_bounds::Maybe(GrapheneRectLike)) _child_bounds_maybe = nothing_to_null(_child_bounds) ret = ccall(("gtk_snapshot_push_repeat", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _bounds, _child_bounds_maybe) nothing end - function push_rounded_clip(instance::GtkSnapshot, _bounds::Union{GskRoundedRect, Ref{_GskRoundedRect}}) + function push_rounded_clip(instance::GtkSnapshot, _bounds::GskRoundedRectLike) ret = ccall(("gtk_snapshot_push_rounded_clip", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GskRoundedRect}), instance, _bounds) nothing end @@ -16488,7 +16949,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_snapshot_rotate", libgtk4), Nothing, (Ptr{GObject}, Float32), instance, _angle) nothing end - function rotate_3d(instance::GtkSnapshot, _angle::Real, _axis::Union{GrapheneVec3, Ref{_GrapheneVec3}}) + function rotate_3d(instance::GtkSnapshot, _angle::Real, _axis::GrapheneVec3Like) ret = ccall(("gtk_snapshot_rotate_3d", libgtk4), Nothing, (Ptr{GObject}, Float32, Ptr{_GrapheneVec3}), instance, _angle, _axis) nothing end @@ -16509,7 +16970,7 @@ $(Expr(:toplevel, quote ret2 = convert(GskRenderNode, ret) ret2 end - function to_paintable(instance::GtkSnapshot, _size::Maybe(Union{GrapheneSize, Ref{_GrapheneSize}})) + function to_paintable(instance::GtkSnapshot, _size::Maybe(GrapheneSizeLike)) _size_maybe = nothing_to_null(_size) ret = ccall(("gtk_snapshot_to_paintable", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{_GrapheneSize}), instance, _size_maybe) ret2 = GLib.find_leaf_type_if_not_null(ret, true) @@ -16520,15 +16981,15 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_snapshot_transform", libgtk4), Nothing, (Ptr{GObject}, Ptr{GskTransform}), instance, _transform_maybe) nothing end - function transform_matrix(instance::GtkSnapshot, _matrix::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}) + function transform_matrix(instance::GtkSnapshot, _matrix::GrapheneMatrixLike) ret = ccall(("gtk_snapshot_transform_matrix", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GrapheneMatrix}), instance, _matrix) nothing end - function translate(instance::GtkSnapshot, _point::Union{GraphenePoint, Ref{_GraphenePoint}}) + function translate(instance::GtkSnapshot, _point::GraphenePointLike) ret = ccall(("gtk_snapshot_translate", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GraphenePoint}), instance, _point) nothing end - function translate_3d(instance::GtkSnapshot, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}}) + function translate_3d(instance::GtkSnapshot, _point::GraphenePoint3DLike) ret = ccall(("gtk_snapshot_translate_3d", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GraphenePoint3D}), instance, _point) nothing end @@ -18031,7 +18492,7 @@ $(Expr(:toplevel, quote ret2 = GtkTextBufferLeaf(ret, true) ret2 end - function add_mark(instance::GtkTextBuffer, _mark::GtkTextMark, _where::Union{GtkTextIter, Ref{_GtkTextIter}}) + function add_mark(instance::GtkTextBuffer, _mark::GtkTextMark, _where::GtkTextIterLike) ret = ccall(("gtk_text_buffer_add_mark", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GtkTextIter}), instance, _mark, _where) nothing end @@ -18039,15 +18500,15 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_buffer_add_selection_clipboard", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _clipboard) nothing end - function apply_tag(instance::GtkTextBuffer, _tag::GtkTextTag, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}) + function apply_tag(instance::GtkTextBuffer, _tag::GtkTextTag, _start::GtkTextIterLike, _end::GtkTextIterLike) ret = ccall(("gtk_text_buffer_apply_tag", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _tag, _start, _end) nothing end - function apply_tag_by_name(instance::GtkTextBuffer, _name::Union{AbstractString, Symbol}, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}) + function apply_tag_by_name(instance::GtkTextBuffer, _name::Union{AbstractString, Symbol}, _start::GtkTextIterLike, _end::GtkTextIterLike) ret = ccall(("gtk_text_buffer_apply_tag_by_name", libgtk4), Nothing, (Ptr{GObject}, Cstring, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _name, _start, _end) nothing end - function backspace(instance::GtkTextBuffer, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _interactive::Bool, _default_editable::Bool) + function backspace(instance::GtkTextBuffer, _iter::GtkTextIterLike, _interactive::Bool, _default_editable::Bool) ret = ccall(("gtk_text_buffer_backspace", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}, Cint, Cint), instance, _iter, _interactive, _default_editable) ret2 = convert(Bool, ret) ret2 @@ -18064,12 +18525,12 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_buffer_copy_clipboard", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _clipboard) nothing end - function create_child_anchor(instance::GtkTextBuffer, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}) + function create_child_anchor(instance::GtkTextBuffer, _iter::GtkTextIterLike) ret = ccall(("gtk_text_buffer_create_child_anchor", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{_GtkTextIter}), instance, _iter) ret2 = convert(GtkTextChildAnchor, ret, false) ret2 end - function create_mark(instance::GtkTextBuffer, _mark_name::Maybe(Union{AbstractString, Symbol}), _where::Union{GtkTextIter, Ref{_GtkTextIter}}, _left_gravity::Bool) + function create_mark(instance::GtkTextBuffer, _mark_name::Maybe(Union{AbstractString, Symbol}), _where::GtkTextIterLike, _left_gravity::Bool) _mark_name_maybe = nothing_to_null(_mark_name) ret = ccall(("gtk_text_buffer_create_mark", libgtk4), Ptr{GObject}, (Ptr{GObject}, Cstring, Ptr{_GtkTextIter}, Cint), instance, _mark_name_maybe, _where, _left_gravity) ret2 = convert(GtkTextMark, ret, false) @@ -18079,11 +18540,11 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_buffer_cut_clipboard", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Cint), instance, _clipboard, _default_editable) nothing end - function delete(instance::GtkTextBuffer, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}) + function delete(instance::GtkTextBuffer, _start::GtkTextIterLike, _end::GtkTextIterLike) ret = ccall(("gtk_text_buffer_delete", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _start, _end) nothing end - function delete_interactive(instance::GtkTextBuffer, _start_iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _end_iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _default_editable::Bool) + function delete_interactive(instance::GtkTextBuffer, _start_iter::GtkTextIterLike, _end_iter::GtkTextIterLike, _default_editable::Bool) ret = ccall(("gtk_text_buffer_delete_interactive", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Cint), instance, _start_iter, _end_iter, _default_editable) ret2 = convert(Bool, ret) ret2 @@ -18228,7 +18689,7 @@ $(Expr(:toplevel, quote ret2 = convert(GdkContentProvider, ret, true) ret2 end - function get_slice(instance::GtkTextBuffer, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}, _include_hidden_chars::Bool) + function get_slice(instance::GtkTextBuffer, _start::GtkTextIterLike, _end::GtkTextIterLike, _include_hidden_chars::Bool) ret = ccall(("gtk_text_buffer_get_slice", libgtk4), Cstring, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Cint), instance, _start, _end, _include_hidden_chars) ret2 = string_or_nothing(ret, true) ret2 @@ -18244,12 +18705,12 @@ $(Expr(:toplevel, quote ret2 = convert(GtkTextTagTable, ret, false) ret2 end - function get_text(instance::GtkTextBuffer, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}, _include_hidden_chars::Bool) + function get_text(instance::GtkTextBuffer, _start::GtkTextIterLike, _end::GtkTextIterLike, _include_hidden_chars::Bool) ret = ccall(("gtk_text_buffer_get_text", libgtk4), Cstring, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Cint), instance, _start, _end, _include_hidden_chars) ret2 = string_or_nothing(ret, true) ret2 end - function insert(instance::GtkTextBuffer, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _text::Union{AbstractString, Symbol}, _len::Integer) + function insert(instance::GtkTextBuffer, _iter::GtkTextIterLike, _text::Union{AbstractString, Symbol}, _len::Integer) ret = ccall(("gtk_text_buffer_insert", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Cstring, Int32), instance, _iter, _text, _len) nothing end @@ -18257,11 +18718,11 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_buffer_insert_at_cursor", libgtk4), Nothing, (Ptr{GObject}, Cstring, Int32), instance, _text, _len) nothing end - function insert_child_anchor(instance::GtkTextBuffer, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _anchor::GtkTextChildAnchor) + function insert_child_anchor(instance::GtkTextBuffer, _iter::GtkTextIterLike, _anchor::GtkTextChildAnchor) ret = ccall(("gtk_text_buffer_insert_child_anchor", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{GObject}), instance, _iter, _anchor) nothing end - function insert_interactive(instance::GtkTextBuffer, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _text::Union{AbstractString, Symbol}, _len::Integer, _default_editable::Bool) + function insert_interactive(instance::GtkTextBuffer, _iter::GtkTextIterLike, _text::Union{AbstractString, Symbol}, _len::Integer, _default_editable::Bool) ret = ccall(("gtk_text_buffer_insert_interactive", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}, Cstring, Int32, Cint), instance, _iter, _text, _len, _default_editable) ret2 = convert(Bool, ret) ret2 @@ -18271,37 +18732,37 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function insert_markup(instance::GtkTextBuffer, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _markup::Union{AbstractString, Symbol}, _len::Integer) + function insert_markup(instance::GtkTextBuffer, _iter::GtkTextIterLike, _markup::Union{AbstractString, Symbol}, _len::Integer) ret = ccall(("gtk_text_buffer_insert_markup", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Cstring, Int32), instance, _iter, _markup, _len) nothing end - function insert_paintable(instance::GtkTextBuffer, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _paintable::GdkPaintable) + function insert_paintable(instance::GtkTextBuffer, _iter::GtkTextIterLike, _paintable::GdkPaintable) ret = ccall(("gtk_text_buffer_insert_paintable", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{GObject}), instance, _iter, _paintable) nothing end - function insert_range(instance::GtkTextBuffer, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}) + function insert_range(instance::GtkTextBuffer, _iter::GtkTextIterLike, _start::GtkTextIterLike, _end::GtkTextIterLike) ret = ccall(("gtk_text_buffer_insert_range", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _iter, _start, _end) nothing end - function insert_range_interactive(instance::GtkTextBuffer, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}, _default_editable::Bool) + function insert_range_interactive(instance::GtkTextBuffer, _iter::GtkTextIterLike, _start::GtkTextIterLike, _end::GtkTextIterLike, _default_editable::Bool) ret = ccall(("gtk_text_buffer_insert_range_interactive", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Cint), instance, _iter, _start, _end, _default_editable) ret2 = convert(Bool, ret) ret2 end - function move_mark(instance::GtkTextBuffer, _mark::GtkTextMark, _where::Union{GtkTextIter, Ref{_GtkTextIter}}) + function move_mark(instance::GtkTextBuffer, _mark::GtkTextMark, _where::GtkTextIterLike) ret = ccall(("gtk_text_buffer_move_mark", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GtkTextIter}), instance, _mark, _where) nothing end - function move_mark_by_name(instance::GtkTextBuffer, _name::Union{AbstractString, Symbol}, _where::Union{GtkTextIter, Ref{_GtkTextIter}}) + function move_mark_by_name(instance::GtkTextBuffer, _name::Union{AbstractString, Symbol}, _where::GtkTextIterLike) ret = ccall(("gtk_text_buffer_move_mark_by_name", libgtk4), Nothing, (Ptr{GObject}, Cstring, Ptr{_GtkTextIter}), instance, _name, _where) nothing end - function paste_clipboard(instance::GtkTextBuffer, _clipboard::GdkClipboard, _override_location::Maybe(Union{GtkTextIter, Ref{_GtkTextIter}}), _default_editable::Bool) + function paste_clipboard(instance::GtkTextBuffer, _clipboard::GdkClipboard, _override_location::Maybe(GtkTextIterLike), _default_editable::Bool) _override_location_maybe = nothing_to_null(_override_location) ret = ccall(("gtk_text_buffer_paste_clipboard", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GtkTextIter}, Cint), instance, _clipboard, _override_location_maybe, _default_editable) nothing end - function place_cursor(instance::GtkTextBuffer, _where::Union{GtkTextIter, Ref{_GtkTextIter}}) + function place_cursor(instance::GtkTextBuffer, _where::GtkTextIterLike) ret = ccall(("gtk_text_buffer_place_cursor", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}), instance, _where) nothing end @@ -18309,7 +18770,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_buffer_redo", libgtk4), Nothing, (Ptr{GObject},), instance) nothing end - function remove_all_tags(instance::GtkTextBuffer, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}) + function remove_all_tags(instance::GtkTextBuffer, _start::GtkTextIterLike, _end::GtkTextIterLike) ret = ccall(("gtk_text_buffer_remove_all_tags", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _start, _end) nothing end @@ -18317,15 +18778,15 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_buffer_remove_selection_clipboard", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _clipboard) nothing end - function remove_tag(instance::GtkTextBuffer, _tag::GtkTextTag, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}) + function remove_tag(instance::GtkTextBuffer, _tag::GtkTextTag, _start::GtkTextIterLike, _end::GtkTextIterLike) ret = ccall(("gtk_text_buffer_remove_tag", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _tag, _start, _end) nothing end - function remove_tag_by_name(instance::GtkTextBuffer, _name::Union{AbstractString, Symbol}, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}}) + function remove_tag_by_name(instance::GtkTextBuffer, _name::Union{AbstractString, Symbol}, _start::GtkTextIterLike, _end::GtkTextIterLike) ret = ccall(("gtk_text_buffer_remove_tag_by_name", libgtk4), Nothing, (Ptr{GObject}, Cstring, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _name, _start, _end) nothing end - function select_range(instance::GtkTextBuffer, _ins::Union{GtkTextIter, Ref{_GtkTextIter}}, _bound::Union{GtkTextIter, Ref{_GtkTextIter}}) + function select_range(instance::GtkTextBuffer, _ins::GtkTextIterLike, _bound::GtkTextIterLike) ret = ccall(("gtk_text_buffer_select_range", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _ins, _bound) nothing end @@ -18483,12 +18944,12 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_view_add_overlay", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Int32, Int32), instance, _child, _xpos, _ypos) nothing end - function backward_display_line(instance::GtkTextView, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}) + function backward_display_line(instance::GtkTextView, _iter::GtkTextIterLike) ret = ccall(("gtk_text_view_backward_display_line", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 end - function backward_display_line_start(instance::GtkTextView, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}) + function backward_display_line_start(instance::GtkTextView, _iter::GtkTextIterLike) ret = ccall(("gtk_text_view_backward_display_line_start", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 @@ -18501,12 +18962,12 @@ $(Expr(:toplevel, quote _window_y = m_window_y[] (_window_x, _window_y) end - function forward_display_line(instance::GtkTextView, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}) + function forward_display_line(instance::GtkTextView, _iter::GtkTextIterLike) ret = ccall(("gtk_text_view_forward_display_line", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 end - function forward_display_line_end(instance::GtkTextView, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}) + function forward_display_line_end(instance::GtkTextView, _iter::GtkTextIterLike) ret = ccall(("gtk_text_view_forward_display_line_end", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 @@ -18525,7 +18986,7 @@ $(Expr(:toplevel, quote ret2 = convert(GtkTextBuffer, ret, false) ret2 end - function get_cursor_locations(instance::GtkTextView, _iter::Maybe(Union{GtkTextIter, Ref{_GtkTextIter}})) + function get_cursor_locations(instance::GtkTextView, _iter::Maybe(GtkTextIterLike)) _iter_maybe = nothing_to_null(_iter) m_strong = Ref{_GdkRectangle}() m_weak = Ref{_GdkRectangle}() @@ -18584,7 +19045,7 @@ $(Expr(:toplevel, quote _trailing = m_trailing[] (ret2, _iter, _trailing) end - function get_iter_location(instance::GtkTextView, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}) + function get_iter_location(instance::GtkTextView, _iter::GtkTextIterLike) m_location = Ref{_GdkRectangle}() ret = ccall(("gtk_text_view_get_iter_location", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{_GdkRectangle}), instance, _iter, m_location) _location = m_location[] @@ -18607,7 +19068,7 @@ $(Expr(:toplevel, quote _line_top = m_line_top[] (_target_iter, _line_top) end - function get_line_yrange(instance::GtkTextView, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}) + function get_line_yrange(instance::GtkTextView, _iter::GtkTextIterLike) m_y = Ref{Int32}() m_height = Ref{Int32}() ret = ccall(("gtk_text_view_get_line_yrange", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTextIter}, Ptr{Int32}, Ptr{Int32}), instance, _iter, m_y, m_height) @@ -18680,7 +19141,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_view_move_overlay", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Int32, Int32), instance, _child, _xpos, _ypos) nothing end - function move_visually(instance::GtkTextView, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _count::Integer) + function move_visually(instance::GtkTextView, _iter::GtkTextIterLike, _count::Integer) ret = ccall(("gtk_text_view_move_visually", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}, Int32), instance, _iter, _count) ret2 = convert(Bool, ret) ret2 @@ -18706,7 +19167,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_view_scroll_mark_onscreen", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _mark) nothing end - function scroll_to_iter(instance::GtkTextView, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}, _within_margin::Real, _use_align::Bool, _xalign::Real, _yalign::Real) + function scroll_to_iter(instance::GtkTextView, _iter::GtkTextIterLike, _within_margin::Real, _use_align::Bool, _xalign::Real, _yalign::Real) ret = ccall(("gtk_text_view_scroll_to_iter", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}, Float64, Cint, Float64, Float64), instance, _iter, _within_margin, _use_align, _xalign, _yalign) ret2 = convert(Bool, ret) ret2 @@ -18802,7 +19263,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_text_view_set_wrap_mode", libgtk4), Nothing, (Ptr{GObject}, UInt32), instance, _wrap_mode) nothing end - function starts_display_line(instance::GtkTextView, _iter::Union{GtkTextIter, Ref{_GtkTextIter}}) + function starts_display_line(instance::GtkTextView, _iter::GtkTextIterLike) ret = ccall(("gtk_text_view_starts_display_line", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTextIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 @@ -19016,7 +19477,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tooltip_set_text", libgtk4), Nothing, (Ptr{GObject}, Cstring), instance, _text_maybe) nothing end - function set_tip_area(instance::GtkTooltip, _rect::Union{GdkRectangle, Ref{_GdkRectangle}}) + function set_tip_area(instance::GtkTooltip, _rect::GdkRectangleLike) ret = ccall(("gtk_tooltip_set_tip_area", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GdkRectangle}), instance, _rect) nothing end @@ -19236,7 +19697,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tree_model_filter_clear_cache", libgtk4), Nothing, (Ptr{GObject},), instance) nothing end - function convert_child_iter_to_iter(instance::GtkTreeModelFilter, _child_iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function convert_child_iter_to_iter(instance::GtkTreeModelFilter, _child_iter::GtkTreeIterLike) m_filter_iter = Ref{_GtkTreeIter}() ret = ccall(("gtk_tree_model_filter_convert_child_iter_to_iter", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_filter_iter, _child_iter) ret2 = convert(Bool, ret) @@ -19248,7 +19709,7 @@ $(Expr(:toplevel, quote ret2 = convert_if_not_null(GtkTreePath, ret, true) ret2 end - function convert_iter_to_child_iter(instance::GtkTreeModelFilter, _filter_iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function convert_iter_to_child_iter(instance::GtkTreeModelFilter, _filter_iter::GtkTreeIterLike) m_child_iter = Ref{_GtkTreeIter}() ret = ccall(("gtk_tree_model_filter_convert_iter_to_child_iter", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_child_iter, _filter_iter) _child_iter = m_child_iter[] @@ -19308,55 +19769,55 @@ $(Expr(:toplevel, quote function get_n_columns(instance::GtkTreeModelFilter) get_n_columns(GtkTreeModel(instance)) end - function get_path(instance::GtkTreeModelFilter, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_path(instance::GtkTreeModelFilter, _iter::GtkTreeIterLike) get_path(GtkTreeModel(instance), _iter) end - function get_string_from_iter(instance::GtkTreeModelFilter, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_string_from_iter(instance::GtkTreeModelFilter, _iter::GtkTreeIterLike) get_string_from_iter(GtkTreeModel(instance), _iter) end - function get_value(instance::GtkTreeModelFilter, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _column::Integer) + function get_value(instance::GtkTreeModelFilter, _iter::GtkTreeIterLike, _column::Integer) get_value(GtkTreeModel(instance), _iter, _column) end - function iter_children(instance::GtkTreeModelFilter, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_children(instance::GtkTreeModelFilter, _parent::Maybe(GtkTreeIterLike)) iter_children(GtkTreeModel(instance), _parent) end - function iter_has_child(instance::GtkTreeModelFilter, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_has_child(instance::GtkTreeModelFilter, _iter::GtkTreeIterLike) iter_has_child(GtkTreeModel(instance), _iter) end - function iter_n_children(instance::GtkTreeModelFilter, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_n_children(instance::GtkTreeModelFilter, _iter::Maybe(GtkTreeIterLike)) iter_n_children(GtkTreeModel(instance), _iter) end - function iter_next(instance::GtkTreeModelFilter, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_next(instance::GtkTreeModelFilter, _iter::GtkTreeIterLike) iter_next(GtkTreeModel(instance), _iter) end - function iter_nth_child(instance::GtkTreeModelFilter, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _n::Integer) + function iter_nth_child(instance::GtkTreeModelFilter, _parent::Maybe(GtkTreeIterLike), _n::Integer) iter_nth_child(GtkTreeModel(instance), _parent, _n) end - function iter_parent(instance::GtkTreeModelFilter, _child::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_parent(instance::GtkTreeModelFilter, _child::GtkTreeIterLike) iter_parent(GtkTreeModel(instance), _child) end - function iter_previous(instance::GtkTreeModelFilter, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_previous(instance::GtkTreeModelFilter, _iter::GtkTreeIterLike) iter_previous(GtkTreeModel(instance), _iter) end - function ref_node(instance::GtkTreeModelFilter, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function ref_node(instance::GtkTreeModelFilter, _iter::GtkTreeIterLike) ref_node(GtkTreeModel(instance), _iter) end - function row_changed(instance::GtkTreeModelFilter, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_changed(instance::GtkTreeModelFilter, _path::GtkTreePath, _iter::GtkTreeIterLike) row_changed(GtkTreeModel(instance), _path, _iter) end function row_deleted(instance::GtkTreeModelFilter, _path::GtkTreePath) row_deleted(GtkTreeModel(instance), _path) end - function row_has_child_toggled(instance::GtkTreeModelFilter, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_has_child_toggled(instance::GtkTreeModelFilter, _path::GtkTreePath, _iter::GtkTreeIterLike) row_has_child_toggled(GtkTreeModel(instance), _path, _iter) end - function row_inserted(instance::GtkTreeModelFilter, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_inserted(instance::GtkTreeModelFilter, _path::GtkTreePath, _iter::GtkTreeIterLike) row_inserted(GtkTreeModel(instance), _path, _iter) end - function rows_reordered(instance::GtkTreeModelFilter, _path::GtkTreePath, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _new_order) + function rows_reordered(instance::GtkTreeModelFilter, _path::GtkTreePath, _iter::Maybe(GtkTreeIterLike), _new_order) rows_reordered(GtkTreeModel(instance), _path, _iter, _new_order) end - function unref_node(instance::GtkTreeModelFilter, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function unref_node(instance::GtkTreeModelFilter, _iter::GtkTreeIterLike) unref_node(GtkTreeModel(instance), _iter) end function TreeModelSort_new_with_model(_child_model::GtkTreeModel) @@ -19368,7 +19829,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tree_model_sort_clear_cache", libgtk4), Nothing, (Ptr{GObject},), instance) nothing end - function convert_child_iter_to_iter(instance::GtkTreeModelSort, _child_iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function convert_child_iter_to_iter(instance::GtkTreeModelSort, _child_iter::GtkTreeIterLike) m_sort_iter = Ref{_GtkTreeIter}() ret = ccall(("gtk_tree_model_sort_convert_child_iter_to_iter", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_sort_iter, _child_iter) ret2 = convert(Bool, ret) @@ -19380,7 +19841,7 @@ $(Expr(:toplevel, quote ret2 = convert_if_not_null(GtkTreePath, ret, true) ret2 end - function convert_iter_to_child_iter(instance::GtkTreeModelSort, _sorted_iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function convert_iter_to_child_iter(instance::GtkTreeModelSort, _sorted_iter::GtkTreeIterLike) m_child_iter = Ref{_GtkTreeIter}() ret = ccall(("gtk_tree_model_sort_convert_iter_to_child_iter", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_child_iter, _sorted_iter) _child_iter = m_child_iter[] @@ -19399,7 +19860,7 @@ $(Expr(:toplevel, quote end ret2 end - function iter_is_valid(instance::GtkTreeModelSort, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_is_valid(instance::GtkTreeModelSort, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_sort_iter_is_valid", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 @@ -19441,55 +19902,55 @@ $(Expr(:toplevel, quote function get_n_columns(instance::GtkTreeModelSort) get_n_columns(GtkTreeModel(instance)) end - function get_path(instance::GtkTreeModelSort, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_path(instance::GtkTreeModelSort, _iter::GtkTreeIterLike) get_path(GtkTreeModel(instance), _iter) end - function get_string_from_iter(instance::GtkTreeModelSort, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_string_from_iter(instance::GtkTreeModelSort, _iter::GtkTreeIterLike) get_string_from_iter(GtkTreeModel(instance), _iter) end - function get_value(instance::GtkTreeModelSort, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _column::Integer) + function get_value(instance::GtkTreeModelSort, _iter::GtkTreeIterLike, _column::Integer) get_value(GtkTreeModel(instance), _iter, _column) end - function iter_children(instance::GtkTreeModelSort, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_children(instance::GtkTreeModelSort, _parent::Maybe(GtkTreeIterLike)) iter_children(GtkTreeModel(instance), _parent) end - function iter_has_child(instance::GtkTreeModelSort, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_has_child(instance::GtkTreeModelSort, _iter::GtkTreeIterLike) iter_has_child(GtkTreeModel(instance), _iter) end - function iter_n_children(instance::GtkTreeModelSort, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_n_children(instance::GtkTreeModelSort, _iter::Maybe(GtkTreeIterLike)) iter_n_children(GtkTreeModel(instance), _iter) end - function iter_next(instance::GtkTreeModelSort, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_next(instance::GtkTreeModelSort, _iter::GtkTreeIterLike) iter_next(GtkTreeModel(instance), _iter) end - function iter_nth_child(instance::GtkTreeModelSort, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _n::Integer) + function iter_nth_child(instance::GtkTreeModelSort, _parent::Maybe(GtkTreeIterLike), _n::Integer) iter_nth_child(GtkTreeModel(instance), _parent, _n) end - function iter_parent(instance::GtkTreeModelSort, _child::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_parent(instance::GtkTreeModelSort, _child::GtkTreeIterLike) iter_parent(GtkTreeModel(instance), _child) end - function iter_previous(instance::GtkTreeModelSort, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_previous(instance::GtkTreeModelSort, _iter::GtkTreeIterLike) iter_previous(GtkTreeModel(instance), _iter) end - function ref_node(instance::GtkTreeModelSort, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function ref_node(instance::GtkTreeModelSort, _iter::GtkTreeIterLike) ref_node(GtkTreeModel(instance), _iter) end - function row_changed(instance::GtkTreeModelSort, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_changed(instance::GtkTreeModelSort, _path::GtkTreePath, _iter::GtkTreeIterLike) row_changed(GtkTreeModel(instance), _path, _iter) end function row_deleted(instance::GtkTreeModelSort, _path::GtkTreePath) row_deleted(GtkTreeModel(instance), _path) end - function row_has_child_toggled(instance::GtkTreeModelSort, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_has_child_toggled(instance::GtkTreeModelSort, _path::GtkTreePath, _iter::GtkTreeIterLike) row_has_child_toggled(GtkTreeModel(instance), _path, _iter) end - function row_inserted(instance::GtkTreeModelSort, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_inserted(instance::GtkTreeModelSort, _path::GtkTreePath, _iter::GtkTreeIterLike) row_inserted(GtkTreeModel(instance), _path, _iter) end - function rows_reordered(instance::GtkTreeModelSort, _path::GtkTreePath, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _new_order) + function rows_reordered(instance::GtkTreeModelSort, _path::GtkTreePath, _iter::Maybe(GtkTreeIterLike), _new_order) rows_reordered(GtkTreeModel(instance), _path, _iter, _new_order) end - function unref_node(instance::GtkTreeModelSort, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function unref_node(instance::GtkTreeModelSort, _iter::GtkTreeIterLike) unref_node(GtkTreeModel(instance), _iter) end function get_sort_column_id(instance::GtkTreeModelSort) @@ -19548,7 +20009,7 @@ $(Expr(:toplevel, quote ret2 = convert(GtkTreeView, ret, false) ret2 end - function iter_is_selected(instance::GtkTreeSelection, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_is_selected(instance::GtkTreeSelection, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_selection_iter_is_selected", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 @@ -19562,7 +20023,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tree_selection_select_all", libgtk4), Nothing, (Ptr{GObject},), instance) nothing end - function select_iter(instance::GtkTreeSelection, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function select_iter(instance::GtkTreeSelection, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_selection_select_iter", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) nothing end @@ -19593,7 +20054,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tree_selection_unselect_all", libgtk4), Nothing, (Ptr{GObject},), instance) nothing end - function unselect_iter(instance::GtkTreeSelection, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function unselect_iter(instance::GtkTreeSelection, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_selection_unselect_iter", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) nothing end @@ -19612,7 +20073,7 @@ $(Expr(:toplevel, quote ret2 = GtkTreeStoreLeaf(ret, true) ret2 end - function append(instance::GtkTreeStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function append(instance::GtkTreeStore, _parent::Maybe(GtkTreeIterLike)) m_iter = Ref{_GtkTreeIter}() _parent_maybe = nothing_to_null(_parent) ret = ccall(("gtk_tree_store_append", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_iter, _parent_maybe) @@ -19623,14 +20084,14 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tree_store_clear", libgtk4), Nothing, (Ptr{GObject},), instance) nothing end - function insert(instance::GtkTreeStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _position::Integer) + function insert(instance::GtkTreeStore, _parent::Maybe(GtkTreeIterLike), _position::Integer) m_iter = Ref{_GtkTreeIter}() _parent_maybe = nothing_to_null(_parent) ret = ccall(("gtk_tree_store_insert", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}, Int32), instance, m_iter, _parent_maybe, _position) _iter = m_iter[] _iter end - function insert_after(instance::GtkTreeStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _sibling::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function insert_after(instance::GtkTreeStore, _parent::Maybe(GtkTreeIterLike), _sibling::Maybe(GtkTreeIterLike)) m_iter = Ref{_GtkTreeIter}() _parent_maybe = nothing_to_null(_parent) _sibling_maybe = nothing_to_null(_sibling) @@ -19638,7 +20099,7 @@ $(Expr(:toplevel, quote _iter = m_iter[] _iter end - function insert_before(instance::GtkTreeStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _sibling::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function insert_before(instance::GtkTreeStore, _parent::Maybe(GtkTreeIterLike), _sibling::Maybe(GtkTreeIterLike)) m_iter = Ref{_GtkTreeIter}() _parent_maybe = nothing_to_null(_parent) _sibling_maybe = nothing_to_null(_sibling) @@ -19646,7 +20107,7 @@ $(Expr(:toplevel, quote _iter = m_iter[] _iter end - function insert_with_values(instance::GtkTreeStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _position::Integer, _columns, _values) + function insert_with_values(instance::GtkTreeStore, _parent::Maybe(GtkTreeIterLike), _position::Integer, _columns, _values) m_iter = Ref{_GtkTreeIter}() _parent_maybe = nothing_to_null(_parent) _columns_arr = convert(Vector{Int32}, _columns) @@ -19657,38 +20118,38 @@ $(Expr(:toplevel, quote _iter = m_iter[] _iter end - function is_ancestor(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _descendant::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function is_ancestor(instance::GtkTreeStore, _iter::GtkTreeIterLike, _descendant::GtkTreeIterLike) ret = ccall(("gtk_tree_store_is_ancestor", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, _iter, _descendant) ret2 = convert(Bool, ret) ret2 end - function iter_depth(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_depth(instance::GtkTreeStore, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_store_iter_depth", libgtk4), Int32, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret end - function iter_is_valid(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_is_valid(instance::GtkTreeStore, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_store_iter_is_valid", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 end - function move_after(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _position::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function move_after(instance::GtkTreeStore, _iter::GtkTreeIterLike, _position::Maybe(GtkTreeIterLike)) _position_maybe = nothing_to_null(_position) ret = ccall(("gtk_tree_store_move_after", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, _iter, _position_maybe) nothing end - function move_before(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _position::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function move_before(instance::GtkTreeStore, _iter::GtkTreeIterLike, _position::Maybe(GtkTreeIterLike)) _position_maybe = nothing_to_null(_position) ret = ccall(("gtk_tree_store_move_before", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, _iter, _position_maybe) nothing end - function prepend(instance::GtkTreeStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function prepend(instance::GtkTreeStore, _parent::Maybe(GtkTreeIterLike)) m_iter = Ref{_GtkTreeIter}() _parent_maybe = nothing_to_null(_parent) ret = ccall(("gtk_tree_store_prepend", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_iter, _parent_maybe) _iter = m_iter[] _iter end - function remove(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function remove(instance::GtkTreeStore, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_store_remove", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 @@ -19699,11 +20160,11 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tree_store_set_column_types", libgtk4), Nothing, (Ptr{GObject}, Int32, Ptr{UInt64}), instance, _n_columns, _types_arr) nothing end - function set_value(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _column::Integer, _value::Union{GValue, Ref{_GValue}}) + function set_value(instance::GtkTreeStore, _iter::GtkTreeIterLike, _column::Integer, _value::GValueLike) ret = ccall(("gtk_tree_store_set_value", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Int32, Ptr{_GValue}), instance, _iter, _column, _value) nothing end - function set(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _columns, _values) + function set(instance::GtkTreeStore, _iter::GtkTreeIterLike, _columns, _values) _columns_arr = convert(Vector{Int32}, _columns) _values_arr = convert(Vector{_GValue}, _values) _n_values = length(_columns) @@ -19711,17 +20172,17 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tree_store_set_valuesv", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{Int32}, Ptr{_GValue}, Int32), instance, _iter, _columns_arr, _values_arr, _n_values) nothing end - function swap(instance::GtkTreeStore, _a::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _b::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function swap(instance::GtkTreeStore, _a::GtkTreeIterLike, _b::GtkTreeIterLike) ret = ccall(("gtk_tree_store_swap", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, _a, _b) nothing end function get_buildable_id(instance::GtkTreeStore) get_buildable_id(GtkBuildable(instance)) end - function drag_data_received(instance::GtkTreeStore, _dest::GtkTreePath, _value::Union{GValue, Ref{_GValue}}) + function drag_data_received(instance::GtkTreeStore, _dest::GtkTreePath, _value::GValueLike) drag_data_received(GtkTreeDragDest(instance), _dest, _value) end - function row_drop_possible(instance::GtkTreeStore, _dest_path::GtkTreePath, _value::Union{GValue, Ref{_GValue}}) + function row_drop_possible(instance::GtkTreeStore, _dest_path::GtkTreePath, _value::GValueLike) row_drop_possible(GtkTreeDragDest(instance), _dest_path, _value) end function drag_data_delete(instance::GtkTreeStore, _path::GtkTreePath) @@ -19757,55 +20218,55 @@ $(Expr(:toplevel, quote function get_n_columns(instance::GtkTreeStore) get_n_columns(GtkTreeModel(instance)) end - function get_path(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_path(instance::GtkTreeStore, _iter::GtkTreeIterLike) get_path(GtkTreeModel(instance), _iter) end - function get_string_from_iter(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_string_from_iter(instance::GtkTreeStore, _iter::GtkTreeIterLike) get_string_from_iter(GtkTreeModel(instance), _iter) end - function get_value(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _column::Integer) + function get_value(instance::GtkTreeStore, _iter::GtkTreeIterLike, _column::Integer) get_value(GtkTreeModel(instance), _iter, _column) end - function iter_children(instance::GtkTreeStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_children(instance::GtkTreeStore, _parent::Maybe(GtkTreeIterLike)) iter_children(GtkTreeModel(instance), _parent) end - function iter_has_child(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_has_child(instance::GtkTreeStore, _iter::GtkTreeIterLike) iter_has_child(GtkTreeModel(instance), _iter) end - function iter_n_children(instance::GtkTreeStore, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_n_children(instance::GtkTreeStore, _iter::Maybe(GtkTreeIterLike)) iter_n_children(GtkTreeModel(instance), _iter) end - function iter_next(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_next(instance::GtkTreeStore, _iter::GtkTreeIterLike) iter_next(GtkTreeModel(instance), _iter) end - function iter_nth_child(instance::GtkTreeStore, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _n::Integer) + function iter_nth_child(instance::GtkTreeStore, _parent::Maybe(GtkTreeIterLike), _n::Integer) iter_nth_child(GtkTreeModel(instance), _parent, _n) end - function iter_parent(instance::GtkTreeStore, _child::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_parent(instance::GtkTreeStore, _child::GtkTreeIterLike) iter_parent(GtkTreeModel(instance), _child) end - function iter_previous(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_previous(instance::GtkTreeStore, _iter::GtkTreeIterLike) iter_previous(GtkTreeModel(instance), _iter) end - function ref_node(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function ref_node(instance::GtkTreeStore, _iter::GtkTreeIterLike) ref_node(GtkTreeModel(instance), _iter) end - function row_changed(instance::GtkTreeStore, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_changed(instance::GtkTreeStore, _path::GtkTreePath, _iter::GtkTreeIterLike) row_changed(GtkTreeModel(instance), _path, _iter) end function row_deleted(instance::GtkTreeStore, _path::GtkTreePath) row_deleted(GtkTreeModel(instance), _path) end - function row_has_child_toggled(instance::GtkTreeStore, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_has_child_toggled(instance::GtkTreeStore, _path::GtkTreePath, _iter::GtkTreeIterLike) row_has_child_toggled(GtkTreeModel(instance), _path, _iter) end - function row_inserted(instance::GtkTreeStore, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_inserted(instance::GtkTreeStore, _path::GtkTreePath, _iter::GtkTreeIterLike) row_inserted(GtkTreeModel(instance), _path, _iter) end - function rows_reordered(instance::GtkTreeStore, _path::GtkTreePath, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _new_order) + function rows_reordered(instance::GtkTreeStore, _path::GtkTreePath, _iter::Maybe(GtkTreeIterLike), _new_order) rows_reordered(GtkTreeModel(instance), _path, _iter, _new_order) end - function unref_node(instance::GtkTreeStore, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function unref_node(instance::GtkTreeStore, _iter::GtkTreeIterLike) unref_node(GtkTreeModel(instance), _iter) end function get_sort_column_id(instance::GtkTreeStore) @@ -20414,7 +20875,7 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function cell_set_cell_data(instance::GtkTreeViewColumn, _tree_model::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _is_expander::Bool, _is_expanded::Bool) + function cell_set_cell_data(instance::GtkTreeViewColumn, _tree_model::GtkTreeModel, _iter::GtkTreeIterLike, _is_expander::Bool, _is_expanded::Bool) ret = ccall(("gtk_tree_view_column_cell_set_cell_data", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_GtkTreeIter}, Cint, Cint), instance, _tree_model, _iter, _is_expander, _is_expanded) nothing end @@ -21004,7 +21465,7 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function compute_point(instance::GtkWidget, _target::GtkWidget, _point::Union{GraphenePoint, Ref{_GraphenePoint}}) + function compute_point(instance::GtkWidget, _target::GtkWidget, _point::GraphenePointLike) m_out_point = Ref{_GraphenePoint}() ret = ccall(("gtk_widget_compute_point", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}), instance, _target, _point, m_out_point) ret2 = convert(Bool, ret) @@ -21691,7 +22152,7 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_widget_show", libgtk4), Nothing, (Ptr{GObject},), instance) nothing end - function size_allocate(instance::GtkWidget, _allocation::Union{GdkRectangle, Ref{_GdkRectangle}}, _baseline::Integer) + function size_allocate(instance::GtkWidget, _allocation::GdkRectangleLike, _baseline::Integer) ret = ccall(("gtk_widget_size_allocate", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GdkRectangle}, Int32), instance, _allocation, _baseline) nothing end @@ -22525,7 +22986,7 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function set_rgba(instance::GtkColorChooser, _color::Union{GdkRGBA, Ref{_GdkRGBA}}) + function set_rgba(instance::GtkColorChooser, _color::GdkRGBALike) ret = ccall(("gtk_color_chooser_set_rgba", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GdkRGBA}), instance, _color) nothing end @@ -22533,12 +22994,12 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_color_chooser_set_use_alpha", libgtk4), Nothing, (Ptr{GObject}, Cint), instance, _use_alpha) nothing end - function delegate_get_property(_object::GObject, _prop_id::Integer, _value::Union{GValue, Ref{_GValue}}, _pspec::GParam) + function delegate_get_property(_object::GObject, _prop_id::Integer, _value::GValueLike, _pspec::GParam) ret = ccall(("gtk_editable_delegate_get_property", libgtk4), Cint, (Ptr{GObject}, UInt32, Ptr{_GValue}, Ptr{GParam}), _object, _prop_id, _value, _pspec) ret2 = convert(Bool, ret) ret2 end - function delegate_set_property(_object::GObject, _prop_id::Integer, _value::Union{GValue, Ref{_GValue}}, _pspec::GParam) + function delegate_set_property(_object::GObject, _prop_id::Integer, _value::GValueLike, _pspec::GParam) ret = ccall(("gtk_editable_delegate_set_property", libgtk4), Cint, (Ptr{GObject}, UInt32, Ptr{_GValue}, Ptr{GParam}), _object, _prop_id, _value, _pspec) ret2 = convert(Bool, ret) ret2 @@ -23043,12 +23504,12 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_symbolic_paintable_snapshot_symbolic", libgtk4), Nothing, (Ptr{GObject}, Ptr{GObject}, Float64, Float64, Ptr{_GdkRGBA}, UInt64), instance, _snapshot, _width, _height, _colors_arr, _n_colors) nothing end - function drag_data_received(instance::GtkTreeDragDest, _dest::GtkTreePath, _value::Union{GValue, Ref{_GValue}}) + function drag_data_received(instance::GtkTreeDragDest, _dest::GtkTreePath, _value::GValueLike) ret = ccall(("gtk_tree_drag_dest_drag_data_received", libgtk4), Cint, (Ptr{GObject}, Ptr{GtkTreePath}, Ptr{_GValue}), instance, _dest, _value) ret2 = convert(Bool, ret) ret2 end - function row_drop_possible(instance::GtkTreeDragDest, _dest_path::GtkTreePath, _value::Union{GValue, Ref{_GValue}}) + function row_drop_possible(instance::GtkTreeDragDest, _dest_path::GtkTreePath, _value::GValueLike) ret = ccall(("gtk_tree_drag_dest_row_drop_possible", libgtk4), Cint, (Ptr{GObject}, Ptr{GtkTreePath}, Ptr{_GValue}), instance, _dest_path, _value) ret2 = convert(Bool, ret) ret2 @@ -23122,23 +23583,23 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tree_model_get_n_columns", libgtk4), Int32, (Ptr{GObject},), instance) ret end - function get_path(instance::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_path(instance::GtkTreeModel, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_get_path", libgtk4), Ptr{GtkTreePath}, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(GtkTreePath, ret, true) ret2 end - function get_string_from_iter(instance::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function get_string_from_iter(instance::GtkTreeModel, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_get_string_from_iter", libgtk4), Cstring, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = string_or_nothing(ret, true) ret2 end - function get_value(instance::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}, _column::Integer) + function get_value(instance::GtkTreeModel, _iter::GtkTreeIterLike, _column::Integer) m_value = Ref{_GValue}() ret = ccall(("gtk_tree_model_get_value", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}, Int32, Ptr{_GValue}), instance, _iter, _column, m_value) _value = m_value[] _value end - function iter_children(instance::GtkTreeModel, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_children(instance::GtkTreeModel, _parent::Maybe(GtkTreeIterLike)) m_iter = Ref{_GtkTreeIter}() _parent_maybe = nothing_to_null(_parent) ret = ccall(("gtk_tree_model_iter_children", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_iter, _parent_maybe) @@ -23146,22 +23607,22 @@ $(Expr(:toplevel, quote _iter = m_iter[] (ret2, _iter) end - function iter_has_child(instance::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_has_child(instance::GtkTreeModel, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_iter_has_child", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 end - function iter_n_children(instance::GtkTreeModel, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}})) + function iter_n_children(instance::GtkTreeModel, _iter::Maybe(GtkTreeIterLike)) _iter_maybe = nothing_to_null(_iter) ret = ccall(("gtk_tree_model_iter_n_children", libgtk4), Int32, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter_maybe) ret end - function iter_next(instance::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_next(instance::GtkTreeModel, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_iter_next", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 end - function iter_nth_child(instance::GtkTreeModel, _parent::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _n::Integer) + function iter_nth_child(instance::GtkTreeModel, _parent::Maybe(GtkTreeIterLike), _n::Integer) m_iter = Ref{_GtkTreeIter}() _parent_maybe = nothing_to_null(_parent) ret = ccall(("gtk_tree_model_iter_nth_child", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}, Int32), instance, m_iter, _parent_maybe, _n) @@ -23169,23 +23630,23 @@ $(Expr(:toplevel, quote _iter = m_iter[] (ret2, _iter) end - function iter_parent(instance::GtkTreeModel, _child::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_parent(instance::GtkTreeModel, _child::GtkTreeIterLike) m_iter = Ref{_GtkTreeIter}() ret = ccall(("gtk_tree_model_iter_parent", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}, Ptr{_GtkTreeIter}), instance, m_iter, _child) ret2 = convert(Bool, ret) _iter = m_iter[] (ret2, _iter) end - function iter_previous(instance::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function iter_previous(instance::GtkTreeModel, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_iter_previous", libgtk4), Cint, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) ret2 = convert(Bool, ret) ret2 end - function ref_node(instance::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function ref_node(instance::GtkTreeModel, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_ref_node", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) nothing end - function row_changed(instance::GtkTreeModel, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_changed(instance::GtkTreeModel, _path::GtkTreePath, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_row_changed", libgtk4), Nothing, (Ptr{GObject}, Ptr{GtkTreePath}, Ptr{_GtkTreeIter}), instance, _path, _iter) nothing end @@ -23193,22 +23654,22 @@ $(Expr(:toplevel, quote ret = ccall(("gtk_tree_model_row_deleted", libgtk4), Nothing, (Ptr{GObject}, Ptr{GtkTreePath}), instance, _path) nothing end - function row_has_child_toggled(instance::GtkTreeModel, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_has_child_toggled(instance::GtkTreeModel, _path::GtkTreePath, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_row_has_child_toggled", libgtk4), Nothing, (Ptr{GObject}, Ptr{GtkTreePath}, Ptr{_GtkTreeIter}), instance, _path, _iter) nothing end - function row_inserted(instance::GtkTreeModel, _path::GtkTreePath, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function row_inserted(instance::GtkTreeModel, _path::GtkTreePath, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_row_inserted", libgtk4), Nothing, (Ptr{GObject}, Ptr{GtkTreePath}, Ptr{_GtkTreeIter}), instance, _path, _iter) nothing end - function rows_reordered(instance::GtkTreeModel, _path::GtkTreePath, _iter::Maybe(Union{GtkTreeIter, Ref{_GtkTreeIter}}), _new_order) + function rows_reordered(instance::GtkTreeModel, _path::GtkTreePath, _iter::Maybe(GtkTreeIterLike), _new_order) _iter_maybe = nothing_to_null(_iter) _new_order_arr = convert(Vector{Int32}, _new_order) _length = length(_new_order) ret = ccall(("gtk_tree_model_rows_reordered_with_length", libgtk4), Nothing, (Ptr{GObject}, Ptr{GtkTreePath}, Ptr{_GtkTreeIter}, Ptr{Int32}, Int32), instance, _path, _iter_maybe, _new_order_arr, _length) nothing end - function unref_node(instance::GtkTreeModel, _iter::Union{GtkTreeIter, Ref{_GtkTreeIter}}) + function unref_node(instance::GtkTreeModel, _iter::GtkTreeIterLike) ret = ccall(("gtk_tree_model_unref_node", libgtk4), Nothing, (Ptr{GObject}, Ptr{_GtkTreeIter}), instance, _iter) nothing end diff --git a/src/gen/gtk4_structs b/src/gen/gtk4_structs index 95f1284d..9136fbf1 100644 --- a/src/gen/gtk4_structs +++ b/src/gen/gtk4_structs @@ -1,22 +1,25 @@ quote $(Expr(:toplevel, quote - mutable struct GtkBitset <: GBoxed - handle::Ptr{GtkBitset} - begin - (GLib.g_type(::Type{T}) where T <: GtkBitset) = begin - ccall(("gtk_bitset_get_type", libgtk4), GType, ()) - end - function GtkBitset(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GtkBitset <: GBoxed + handle::Ptr{GtkBitset} + begin + (GLib.g_type(::Type{T}) where T <: GtkBitset) = begin + ccall(("gtk_bitset_get_type", libgtk4), GType, ()) + end + function GtkBitset(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GtkBitset) end - push!(gboxed_types, GtkBitset) end + const GtkBitsetLike = GtkBitset end begin mutable struct GtkBitsetIter <: GBoxed @@ -37,6 +40,7 @@ $(Expr(:toplevel, quote push!(gboxed_types, GtkBitsetIter) end end + const GtkBitsetIterLike = GtkBitsetIter const _GtkBitsetIter = GtkBitsetIter end begin @@ -71,15 +75,20 @@ $(Expr(:toplevel, quote convert(::Type{GtkBorder}, p::Ptr{_GtkBorder}, owns = false) = begin GtkBorder(p, owns) end + const GtkBorderLike = Union{Ref{_GtkBorder}, GtkBorder} end end - mutable struct GtkBuildableParseContext - handle::Ptr{GtkBuildableParseContext} + begin + mutable struct GtkBuildableParseContext + handle::Ptr{GtkBuildableParseContext} + end + const GtkBuildableParseContextLike = GtkBuildableParseContext end begin mutable struct GtkBuildableParser handle::Ptr{GtkBuildableParser} end + const GtkBuildableParserLike = GtkBuildableParser const _GtkBuildableParser = GtkBuildableParser end begin @@ -100,46 +109,56 @@ $(Expr(:toplevel, quote convert(::Type{GtkCssLocation}, p::Ptr{_GtkCssLocation}, owns = false) = begin GtkCssLocation(p, owns) end + const GtkCssLocationLike = Union{Ref{_GtkCssLocation}, GtkCssLocation} end end - mutable struct GtkCssSection <: GBoxed - handle::Ptr{GtkCssSection} - begin - (GLib.g_type(::Type{T}) where T <: GtkCssSection) = begin - ccall(("gtk_css_section_get_type", libgtk4), GType, ()) - end - function GtkCssSection(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GtkCssSection <: GBoxed + handle::Ptr{GtkCssSection} + begin + (GLib.g_type(::Type{T}) where T <: GtkCssSection) = begin + ccall(("gtk_css_section_get_type", libgtk4), GType, ()) + end + function GtkCssSection(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GtkCssSection) end - push!(gboxed_types, GtkCssSection) end + const GtkCssSectionLike = GtkCssSection end - mutable struct GtkCssStyleChange - handle::Ptr{GtkCssStyleChange} + begin + mutable struct GtkCssStyleChange + handle::Ptr{GtkCssStyleChange} + end + const GtkCssStyleChangeLike = GtkCssStyleChange end - mutable struct GtkExpressionWatch <: GBoxed - handle::Ptr{GtkExpressionWatch} - begin - (GLib.g_type(::Type{T}) where T <: GtkExpressionWatch) = begin - ccall(("gtk_expression_watch_get_type", libgtk4), GType, ()) - end - function GtkExpressionWatch(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GtkExpressionWatch <: GBoxed + handle::Ptr{GtkExpressionWatch} + begin + (GLib.g_type(::Type{T}) where T <: GtkExpressionWatch) = begin + ccall(("gtk_expression_watch_get_type", libgtk4), GType, ()) end + function GtkExpressionWatch(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GtkExpressionWatch) end - push!(gboxed_types, GtkExpressionWatch) end + const GtkExpressionWatchLike = GtkExpressionWatch end begin struct _GtkPadActionEntry @@ -159,28 +178,35 @@ $(Expr(:toplevel, quote convert(::Type{GtkPadActionEntry}, p::Ptr{_GtkPadActionEntry}, owns = false) = begin GtkPadActionEntry(p, owns) end + const GtkPadActionEntryLike = Union{Ref{_GtkPadActionEntry}, GtkPadActionEntry} end end - mutable struct GtkPaperSize <: GBoxed - handle::Ptr{GtkPaperSize} - begin - (GLib.g_type(::Type{T}) where T <: GtkPaperSize) = begin - ccall(("gtk_paper_size_get_type", libgtk4), GType, ()) - end - function GtkPaperSize(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GtkPaperSize <: GBoxed + handle::Ptr{GtkPaperSize} + begin + (GLib.g_type(::Type{T}) where T <: GtkPaperSize) = begin + ccall(("gtk_paper_size_get_type", libgtk4), GType, ()) + end + function GtkPaperSize(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GtkPaperSize) end - push!(gboxed_types, GtkPaperSize) end + const GtkPaperSizeLike = GtkPaperSize end - mutable struct GtkPrintBackend - handle::Ptr{GtkPrintBackend} + begin + mutable struct GtkPrintBackend + handle::Ptr{GtkPrintBackend} + end + const GtkPrintBackendLike = GtkPrintBackend end begin struct _GtkRecentData @@ -202,25 +228,29 @@ $(Expr(:toplevel, quote convert(::Type{GtkRecentData}, p::Ptr{_GtkRecentData}, owns = false) = begin GtkRecentData(p, owns) end + const GtkRecentDataLike = Union{Ref{_GtkRecentData}, GtkRecentData} end end - mutable struct GtkRecentInfo <: GBoxed - handle::Ptr{GtkRecentInfo} - begin - (GLib.g_type(::Type{T}) where T <: GtkRecentInfo) = begin - ccall(("gtk_recent_info_get_type", libgtk4), GType, ()) - end - function GtkRecentInfo(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GtkRecentInfo <: GBoxed + handle::Ptr{GtkRecentInfo} + begin + (GLib.g_type(::Type{T}) where T <: GtkRecentInfo) = begin + ccall(("gtk_recent_info_get_type", libgtk4), GType, ()) end + function GtkRecentInfo(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GtkRecentInfo) end - push!(gboxed_types, GtkRecentInfo) end + const GtkRecentInfoLike = GtkRecentInfo end begin struct _GtkRequestedSize @@ -238,6 +268,7 @@ $(Expr(:toplevel, quote convert(::Type{GtkRequestedSize}, p::Ptr{_GtkRequestedSize}, owns = false) = begin GtkRequestedSize(p, owns) end + const GtkRequestedSizeLike = Union{Ref{_GtkRequestedSize}, GtkRequestedSize} end end begin @@ -270,25 +301,29 @@ $(Expr(:toplevel, quote convert(::Type{GtkRequisition}, p::Ptr{_GtkRequisition}, owns = false) = begin GtkRequisition(p, owns) end + const GtkRequisitionLike = Union{Ref{_GtkRequisition}, GtkRequisition} end end - mutable struct GtkScrollInfo <: GBoxed - handle::Ptr{GtkScrollInfo} - begin - (GLib.g_type(::Type{T}) where T <: GtkScrollInfo) = begin - ccall(("gtk_scroll_info_get_type", libgtk4), GType, ()) - end - function GtkScrollInfo(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GtkScrollInfo <: GBoxed + handle::Ptr{GtkScrollInfo} + begin + (GLib.g_type(::Type{T}) where T <: GtkScrollInfo) = begin + ccall(("gtk_scroll_info_get_type", libgtk4), GType, ()) + end + function GtkScrollInfo(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, GtkScrollInfo) end - push!(gboxed_types, GtkScrollInfo) end + const GtkScrollInfoLike = GtkScrollInfo end begin struct _GtkTextIter @@ -332,6 +367,7 @@ $(Expr(:toplevel, quote convert(::Type{GtkTextIter}, p::Ptr{_GtkTextIter}, owns = false) = begin GtkTextIter(p, owns) end + const GtkTextIterLike = Union{Ref{_GtkTextIter}, GtkTextIter} end end begin @@ -366,25 +402,29 @@ $(Expr(:toplevel, quote convert(::Type{GtkTreeIter}, p::Ptr{_GtkTreeIter}, owns = false) = begin GtkTreeIter(p, owns) end + const GtkTreeIterLike = Union{Ref{_GtkTreeIter}, GtkTreeIter} end end - mutable struct GtkTreePath <: GBoxed - handle::Ptr{GtkTreePath} - begin - (GLib.g_type(::Type{T}) where T <: GtkTreePath) = begin - ccall(("gtk_tree_path_get_type", libgtk4), GType, ()) - end - function GtkTreePath(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct GtkTreePath <: GBoxed + handle::Ptr{GtkTreePath} + begin + (GLib.g_type(::Type{T}) where T <: GtkTreePath) = begin + ccall(("gtk_tree_path_get_type", libgtk4), GType, ()) end + function GtkTreePath(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, GtkTreePath) end - push!(gboxed_types, GtkTreePath) end + const GtkTreePathLike = GtkTreePath end @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.Bitset.html)." GtkBitset @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.BitsetIter.html)." GtkBitsetIter @@ -7488,7 +7528,7 @@ $(Expr(:toplevel, quote GLib.setproperties!(obj; kwargs...) obj end - function GtkColorButton(_rgba::Union{GdkRGBA, Ref{_GdkRGBA}}; kwargs...) + function GtkColorButton(_rgba::GdkRGBALike; kwargs...) obj = G_.ColorButton_new_with_rgba(_rgba) GLib.setproperties!(obj; kwargs...) obj @@ -7536,7 +7576,7 @@ $(Expr(:toplevel, quote function GtkComboBoxText() G_.ComboBoxText_new() end - function GtkConstantExpression(_value::Union{GValue, Ref{_GValue}}) + function GtkConstantExpression(_value::GValueLike) G_.ConstantExpression_new_for_value(_value) end function GtkConstraint(_target::Maybe(GtkConstraintTarget), _target_attribute, _relation, _source::Maybe(GtkConstraintTarget), _source_attribute, _multiplier::Real, _constant::Real, _strength::Integer; kwargs...) @@ -8470,7 +8510,7 @@ $(Expr(:toplevel, quote function GtkBorder() G_.Border_new() end - function GtkCssSection(_file::Maybe(GFile), _start::Union{GtkCssLocation, Ref{_GtkCssLocation}}, _end::Union{GtkCssLocation, Ref{_GtkCssLocation}}) + function GtkCssSection(_file::Maybe(GFile), _start::GtkCssLocationLike, _end::GtkCssLocationLike) G_.CssSection_new(_file, _start, _end) end function GtkPaperSize(_name::Maybe(Union{AbstractString, Symbol})) @@ -10051,8 +10091,8 @@ $(Expr(:toplevel, quote end function GtkCellAllocCallback(renderer, cell_area, cell_background, data) renderer = convert(GtkCellRenderer, renderer, false) - cell_area = convert(Union{GdkRectangle, Ref{_GdkRectangle}}, cell_area, false) - cell_background = convert(Union{GdkRectangle, Ref{_GdkRectangle}}, cell_background, false) + cell_area = convert(GdkRectangleLike, cell_area, false) + cell_background = convert(GdkRectangleLike, cell_background, false) f = data ret = f(renderer, cell_area, cell_background) convert(Cint, ret) @@ -10073,7 +10113,7 @@ $(Expr(:toplevel, quote leaftype = GLib.find_leaf_type(tree_model) convert(leaftype, tree_model, false) end - iter = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, iter, false) + iter = convert(GtkTreeIterLike, iter, false) f = data ret = f(cell_layout, cell, tree_model, iter) nothing @@ -10094,7 +10134,7 @@ $(Expr(:toplevel, quote function GtkEntryCompletionMatchFunc(completion, key, iter, user_data) completion = convert(GtkEntryCompletion, completion, false) key = string_or_nothing(key, false) - iter = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, iter, false) + iter = convert(GtkTreeIterLike, iter, false) f = user_data ret = f(completion, key, iter) convert(Cint, ret) @@ -10255,7 +10295,7 @@ $(Expr(:toplevel, quote leaftype = GLib.find_leaf_type(tree_model) convert(leaftype, tree_model, false) end - iter = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, iter, false) + iter = convert(GtkTreeIterLike, iter, false) f = data ret = f(tree_column, cell, tree_model, iter) nothing @@ -10265,8 +10305,8 @@ $(Expr(:toplevel, quote leaftype = GLib.find_leaf_type(model) convert(leaftype, model, false) end - a = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, a, false) - b = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, b, false) + a = convert(GtkTreeIterLike, a, false) + b = convert(GtkTreeIterLike, b, false) f = user_data ret = f(model, a, b) convert(Int32, ret) @@ -10285,7 +10325,7 @@ $(Expr(:toplevel, quote leaftype = GLib.find_leaf_type(model) convert(leaftype, model, false) end - iter = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, iter, false) + iter = convert(GtkTreeIterLike, iter, false) f = data ret = f(model, iter, value, column) nothing @@ -10295,7 +10335,7 @@ $(Expr(:toplevel, quote leaftype = GLib.find_leaf_type(model) convert(leaftype, model, false) end - iter = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, iter, false) + iter = convert(GtkTreeIterLike, iter, false) f = data ret = f(model, iter) convert(Cint, ret) @@ -10306,7 +10346,7 @@ $(Expr(:toplevel, quote convert(leaftype, model, false) end path = convert(GtkTreePath, path, false) - iter = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, iter, false) + iter = convert(GtkTreeIterLike, iter, false) f = data ret = f(model, path, iter) convert(Cint, ret) @@ -10317,7 +10357,7 @@ $(Expr(:toplevel, quote convert(leaftype, model, false) end path = convert(GtkTreePath, path, false) - iter = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, iter, false) + iter = convert(GtkTreeIterLike, iter, false) f = data ret = f(model, path, iter) nothing @@ -10355,7 +10395,7 @@ $(Expr(:toplevel, quote leaftype = GLib.find_leaf_type(model) convert(leaftype, model, false) end - iter = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, iter, false) + iter = convert(GtkTreeIterLike, iter, false) f = data ret = f(model, iter) convert(Cint, ret) @@ -10366,11 +10406,11 @@ $(Expr(:toplevel, quote convert(leaftype, model, false) end key = string_or_nothing(key, false) - iter = convert(Union{GtkTreeIter, Ref{_GtkTreeIter}}, iter, false) + iter = convert(GtkTreeIterLike, iter, false) f = search_data ret = f(model, column, key, iter) convert(Cint, ret) end - export GtkBitset, GtkBitsetIter, _GtkBitsetIter, GtkBorder, _GtkBorder, GtkBuildableParseContext, GtkBuildableParser, _GtkBuildableParser, GtkCssLocation, _GtkCssLocation, GtkCssSection, GtkCssStyleChange, GtkExpressionWatch, GtkPadActionEntry, _GtkPadActionEntry, GtkPaperSize, GtkPrintBackend, GtkRecentData, _GtkRecentData, GtkRecentInfo, GtkRequestedSize, _GtkRequestedSize, GtkRequisition, _GtkRequisition, GtkScrollInfo, GtkTextIter, _GtkTextIter, GtkTreeIter, _GtkTreeIter, GtkTreePath, GtkAccessible, GtkAccessibleRange, GtkActionable, GtkAppChooser, GtkBuildable, GtkBuilderScope, GtkCellEditable, GtkCellLayout, GtkColorChooser, GtkConstraintTarget, GtkEditable, GtkFileChooser, GtkFontChooser, GtkNative, GtkOrientable, GtkPrintOperationPreview, GtkRoot, GtkScrollable, GtkSectionModel, GtkSelectionModel, GtkShortcutManager, GtkStyleProvider, GtkSymbolicPaintable, GtkTreeDragDest, GtkTreeDragSource, GtkTreeModel, GtkTreeSortable, GtkATContext, GtkAboutDialog, GtkAboutDialogLeaf, GtkActionBar, GtkActionBarLeaf, GtkActivateAction, GtkActivateActionLeaf, GtkAdjustment, GtkAdjustmentLeaf, GtkAlertDialog, GtkAlertDialogLeaf, GtkAlternativeTrigger, GtkAlternativeTriggerLeaf, GtkAnyFilter, GtkAnyFilterLeaf, GtkAppChooserButton, GtkAppChooserButtonLeaf, GtkAppChooserDialog, GtkAppChooserDialogLeaf, GtkAppChooserWidget, GtkAppChooserWidgetLeaf, GtkApplication, GtkApplicationLeaf, GtkApplicationWindow, GtkApplicationWindowLeaf, GtkAspectFrame, GtkAspectFrameLeaf, GtkAssistant, GtkAssistantLeaf, GtkAssistantPage, GtkAssistantPageLeaf, GtkBinLayout, GtkBinLayoutLeaf, GtkBookmarkList, GtkBookmarkListLeaf, GtkBoolFilter, GtkBoolFilterLeaf, GtkBox, GtkBoxLeaf, GtkBoxLayout, GtkBoxLayoutLeaf, GtkBuilder, GtkBuilderLeaf, GtkBuilderCScope, GtkBuilderCScopeLeaf, GtkBuilderListItemFactory, GtkBuilderListItemFactoryLeaf, GtkButton, GtkButtonLeaf, GtkCalendar, GtkCalendarLeaf, GtkCallbackAction, GtkCallbackActionLeaf, GtkCellArea, GtkCellAreaBox, GtkCellAreaBoxLeaf, GtkCellAreaContext, GtkCellAreaContextLeaf, GtkCellRenderer, GtkCellRendererAccel, GtkCellRendererAccelLeaf, GtkCellRendererCombo, GtkCellRendererComboLeaf, GtkCellRendererPixbuf, GtkCellRendererPixbufLeaf, GtkCellRendererProgress, GtkCellRendererProgressLeaf, GtkCellRendererSpin, GtkCellRendererSpinLeaf, GtkCellRendererSpinner, GtkCellRendererSpinnerLeaf, GtkCellRendererText, GtkCellRendererTextLeaf, GtkCellRendererToggle, GtkCellRendererToggleLeaf, GtkCellView, GtkCellViewLeaf, GtkCenterBox, GtkCenterBoxLeaf, GtkCenterLayout, GtkCenterLayoutLeaf, GtkCheckButton, GtkCheckButtonLeaf, GtkColorButton, GtkColorButtonLeaf, GtkColorChooserDialog, GtkColorChooserDialogLeaf, GtkColorChooserWidget, GtkColorChooserWidgetLeaf, GtkColorDialog, GtkColorDialogLeaf, GtkColorDialogButton, GtkColorDialogButtonLeaf, GtkColumnView, GtkColumnViewLeaf, GtkColumnViewCell, GtkColumnViewCellLeaf, GtkColumnViewColumn, GtkColumnViewColumnLeaf, GtkColumnViewRow, GtkColumnViewRowLeaf, GtkColumnViewSorter, GtkColumnViewSorterLeaf, GtkComboBox, GtkComboBoxLeaf, GtkComboBoxText, GtkComboBoxTextLeaf, GtkConstantExpression, GtkConstantExpressionLeaf, GtkConstraint, GtkConstraintLeaf, GtkConstraintGuide, GtkConstraintGuideLeaf, GtkConstraintLayout, GtkConstraintLayoutLeaf, GtkConstraintLayoutChild, GtkConstraintLayoutChildLeaf, GtkCssProvider, GtkCssProviderLeaf, GtkCustomFilter, GtkCustomFilterLeaf, GtkCustomLayout, GtkCustomLayoutLeaf, GtkCustomSorter, GtkCustomSorterLeaf, GtkDialog, GtkDialogLeaf, GtkDirectoryList, GtkDirectoryListLeaf, GtkDragIcon, GtkDragIconLeaf, GtkDragSource, GtkDragSourceLeaf, GtkDrawingArea, GtkDrawingAreaLeaf, GtkDropControllerMotion, GtkDropControllerMotionLeaf, GtkDropDown, GtkDropDownLeaf, GtkDropTarget, GtkDropTargetLeaf, GtkDropTargetAsync, GtkDropTargetAsyncLeaf, GtkEditableLabel, GtkEditableLabelLeaf, GtkEmojiChooser, GtkEmojiChooserLeaf, GtkEntry, GtkEntryLeaf, GtkEntryBuffer, GtkEntryBufferLeaf, GtkEntryCompletion, GtkEntryCompletionLeaf, GtkEventController, GtkEventControllerFocus, GtkEventControllerFocusLeaf, GtkEventControllerKey, GtkEventControllerKeyLeaf, GtkEventControllerLegacy, GtkEventControllerLegacyLeaf, GtkEventControllerMotion, GtkEventControllerMotionLeaf, GtkEventControllerScroll, GtkEventControllerScrollLeaf, GtkEveryFilter, GtkEveryFilterLeaf, GtkExpander, GtkExpanderLeaf, GtkExpression, GtkFileChooserDialog, GtkFileChooserDialogLeaf, GtkFileChooserNative, GtkFileChooserNativeLeaf, GtkFileChooserWidget, GtkFileChooserWidgetLeaf, GtkFileDialog, GtkFileDialogLeaf, GtkFileFilter, GtkFileFilterLeaf, GtkFileLauncher, GtkFileLauncherLeaf, GtkFilter, GtkFilterLeaf, GtkFilterListModel, GtkFilterListModelLeaf, GtkFixed, GtkFixedLeaf, GtkFixedLayout, GtkFixedLayoutLeaf, GtkFixedLayoutChild, GtkFixedLayoutChildLeaf, GtkFlattenListModel, GtkFlattenListModelLeaf, GtkFlowBox, GtkFlowBoxLeaf, GtkFlowBoxChild, GtkFlowBoxChildLeaf, GtkFontButton, GtkFontButtonLeaf, GtkFontChooserDialog, GtkFontChooserDialogLeaf, GtkFontChooserWidget, GtkFontChooserWidgetLeaf, GtkFontDialog, GtkFontDialogLeaf, GtkFontDialogButton, GtkFontDialogButtonLeaf, GtkFrame, GtkFrameLeaf, GtkGLArea, GtkGLAreaLeaf, GtkGesture, GtkGestureClick, GtkGestureClickLeaf, GtkGestureDrag, GtkGestureDragLeaf, GtkGestureLongPress, GtkGestureLongPressLeaf, GtkGesturePan, GtkGesturePanLeaf, GtkGestureRotate, GtkGestureRotateLeaf, GtkGestureSingle, GtkGestureSingleLeaf, GtkGestureStylus, GtkGestureStylusLeaf, GtkGestureSwipe, GtkGestureSwipeLeaf, GtkGestureZoom, GtkGestureZoomLeaf, GtkGrid, GtkGridLeaf, GtkGridLayout, GtkGridLayoutLeaf, GtkGridLayoutChild, GtkGridLayoutChildLeaf, GtkGridView, GtkGridViewLeaf, GtkHeaderBar, GtkHeaderBarLeaf, GtkIMContext, GtkIMContextSimple, GtkIMContextSimpleLeaf, GtkIMMulticontext, GtkIMMulticontextLeaf, GtkIconPaintable, GtkIconPaintableLeaf, GtkIconTheme, GtkIconThemeLeaf, GtkIconView, GtkIconViewLeaf, GtkImage, GtkImageLeaf, GtkInfoBar, GtkInfoBarLeaf, GtkInscription, GtkInscriptionLeaf, GtkKeyvalTrigger, GtkKeyvalTriggerLeaf, GtkLabel, GtkLabelLeaf, GtkLayoutChild, GtkLayoutManager, GtkLevelBar, GtkLevelBarLeaf, GtkLinkButton, GtkLinkButtonLeaf, GtkListBase, GtkListBox, GtkListBoxLeaf, GtkListBoxRow, GtkListBoxRowLeaf, GtkListHeader, GtkListHeaderLeaf, GtkListItem, GtkListItemLeaf, GtkListItemFactory, GtkListItemFactoryLeaf, GtkListStore, GtkListStoreLeaf, GtkListView, GtkListViewLeaf, GtkLockButton, GtkLockButtonLeaf, GtkMapListModel, GtkMapListModelLeaf, GtkMediaControls, GtkMediaControlsLeaf, GtkMediaFile, GtkMediaStream, GtkMenuButton, GtkMenuButtonLeaf, GtkMessageDialog, GtkMessageDialogLeaf, GtkMnemonicAction, GtkMnemonicActionLeaf, GtkMnemonicTrigger, GtkMnemonicTriggerLeaf, GtkMountOperation, GtkMountOperationLeaf, GtkMultiFilter, GtkMultiSelection, GtkMultiSelectionLeaf, GtkMultiSorter, GtkMultiSorterLeaf, GtkNamedAction, GtkNamedActionLeaf, GtkNativeDialog, GtkNeverTrigger, GtkNeverTriggerLeaf, GtkNoSelection, GtkNoSelectionLeaf, GtkNotebook, GtkNotebookLeaf, GtkNotebookPage, GtkNotebookPageLeaf, GtkNothingAction, GtkNothingActionLeaf, GtkNumericSorter, GtkNumericSorterLeaf, GtkObjectExpression, GtkObjectExpressionLeaf, GtkOverlay, GtkOverlayLeaf, GtkOverlayLayout, GtkOverlayLayoutLeaf, GtkOverlayLayoutChild, GtkOverlayLayoutChildLeaf, GtkPadController, GtkPadControllerLeaf, GtkPageSetup, GtkPageSetupLeaf, GtkPaned, GtkPanedLeaf, GtkPasswordEntry, GtkPasswordEntryLeaf, GtkPasswordEntryBuffer, GtkPasswordEntryBufferLeaf, GtkPicture, GtkPictureLeaf, GtkPopover, GtkPopoverLeaf, GtkPopoverMenu, GtkPopoverMenuLeaf, GtkPopoverMenuBar, GtkPopoverMenuBarLeaf, GtkPrintContext, GtkPrintContextLeaf, GtkPrintJob, GtkPrintJobLeaf, GtkPrintOperation, GtkPrintOperationLeaf, GtkPrintSettings, GtkPrintSettingsLeaf, GtkPrinter, GtkPrinterLeaf, GtkProgressBar, GtkProgressBarLeaf, GtkPropertyExpression, GtkPropertyExpressionLeaf, GtkRange, GtkRangeLeaf, GtkRecentManager, GtkRecentManagerLeaf, GtkRevealer, GtkRevealerLeaf, GtkScale, GtkScaleLeaf, GtkScaleButton, GtkScaleButtonLeaf, GtkScrollbar, GtkScrollbarLeaf, GtkScrolledWindow, GtkScrolledWindowLeaf, GtkSearchBar, GtkSearchBarLeaf, GtkSearchEntry, GtkSearchEntryLeaf, GtkSelectionFilterModel, GtkSelectionFilterModelLeaf, GtkSeparator, GtkSeparatorLeaf, GtkSettings, GtkSettingsLeaf, GtkShortcut, GtkShortcutLeaf, GtkShortcutAction, GtkShortcutController, GtkShortcutControllerLeaf, GtkShortcutLabel, GtkShortcutLabelLeaf, GtkShortcutTrigger, GtkShortcutsGroup, GtkShortcutsGroupLeaf, GtkShortcutsSection, GtkShortcutsSectionLeaf, GtkShortcutsShortcut, GtkShortcutsShortcutLeaf, GtkShortcutsWindow, GtkShortcutsWindowLeaf, GtkSignalAction, GtkSignalActionLeaf, GtkSignalListItemFactory, GtkSignalListItemFactoryLeaf, GtkSingleSelection, GtkSingleSelectionLeaf, GtkSizeGroup, GtkSizeGroupLeaf, GtkSliceListModel, GtkSliceListModelLeaf, GtkSnapshot, GtkSnapshotLeaf, GtkSortListModel, GtkSortListModelLeaf, GtkSorter, GtkSorterLeaf, GtkSpinButton, GtkSpinButtonLeaf, GtkSpinner, GtkSpinnerLeaf, GtkStack, GtkStackLeaf, GtkStackPage, GtkStackPageLeaf, GtkStackSidebar, GtkStackSidebarLeaf, GtkStackSwitcher, GtkStackSwitcherLeaf, GtkStatusbar, GtkStatusbarLeaf, GtkStringFilter, GtkStringFilterLeaf, GtkStringList, GtkStringListLeaf, GtkStringObject, GtkStringObjectLeaf, GtkStringSorter, GtkStringSorterLeaf, GtkStyleContext, GtkStyleContextLeaf, GtkSwitch, GtkSwitchLeaf, GtkText, GtkTextLeaf, GtkTextBuffer, GtkTextBufferLeaf, GtkTextChildAnchor, GtkTextChildAnchorLeaf, GtkTextMark, GtkTextMarkLeaf, GtkTextTag, GtkTextTagLeaf, GtkTextTagTable, GtkTextTagTableLeaf, GtkTextView, GtkTextViewLeaf, GtkToggleButton, GtkToggleButtonLeaf, GtkTooltip, GtkTooltipLeaf, GtkTreeExpander, GtkTreeExpanderLeaf, GtkTreeListModel, GtkTreeListModelLeaf, GtkTreeListRow, GtkTreeListRowLeaf, GtkTreeListRowSorter, GtkTreeListRowSorterLeaf, GtkTreeModelFilter, GtkTreeModelFilterLeaf, GtkTreeModelSort, GtkTreeModelSortLeaf, GtkTreeSelection, GtkTreeSelectionLeaf, GtkTreeStore, GtkTreeStoreLeaf, GtkTreeView, GtkTreeViewLeaf, GtkTreeViewColumn, GtkTreeViewColumnLeaf, GtkUriLauncher, GtkUriLauncherLeaf, GtkVideo, GtkVideoLeaf, GtkViewport, GtkViewportLeaf, GtkVolumeButton, GtkVolumeButtonLeaf, GtkWidget, GtkWidgetPaintable, GtkWidgetPaintableLeaf, GtkWindow, GtkWindowLeaf, GtkWindowControls, GtkWindowControlsLeaf, GtkWindowGroup, GtkWindowGroupLeaf, GtkWindowHandle, GtkWindowHandleLeaf, GtkAssistantPageFunc, GtkCellAllocCallback, GtkCellCallback, GtkCellLayoutDataFunc, GtkCustomFilterFunc, GtkDrawingAreaDrawFunc, GtkEntryCompletionMatchFunc, GtkExpressionNotify, GtkFlowBoxCreateWidgetFunc, GtkFlowBoxFilterFunc, GtkFlowBoxForeachFunc, GtkFlowBoxSortFunc, GtkFontFilterFunc, GtkIconViewForeachFunc, GtkListBoxCreateWidgetFunc, GtkListBoxFilterFunc, GtkListBoxForeachFunc, GtkListBoxSortFunc, GtkListBoxUpdateHeaderFunc, GtkMapListModelMapFunc, GtkMenuButtonCreatePopupFunc, GtkPageSetupDoneFunc, GtkPrintSettingsFunc, GtkPrinterFunc, GtkScaleFormatValueFunc, GtkShortcutFunc, GtkTextCharPredicate, GtkTextTagTableForeach, GtkTickCallback, GtkTreeCellDataFunc, GtkTreeIterCompareFunc, GtkTreeListModelCreateModelFunc, GtkTreeModelFilterModifyFunc, GtkTreeModelFilterVisibleFunc, GtkTreeModelForeachFunc, GtkTreeSelectionForeachFunc, GtkTreeSelectionFunc, GtkTreeViewColumnDropFunc, GtkTreeViewMappingFunc, GtkTreeViewRowSeparatorFunc, GtkTreeViewSearchEqualFunc + export GtkBitset, GtkBitsetIter, GtkBitsetIterLike, _GtkBitsetIter, GtkBorder, GtkBorderLike, _GtkBorder, GtkBuildableParseContext, GtkBuildableParser, GtkBuildableParserLike, _GtkBuildableParser, GtkCssLocation, GtkCssLocationLike, _GtkCssLocation, GtkCssSection, GtkCssStyleChange, GtkExpressionWatch, GtkPadActionEntry, GtkPadActionEntryLike, _GtkPadActionEntry, GtkPaperSize, GtkPrintBackend, GtkRecentData, GtkRecentDataLike, _GtkRecentData, GtkRecentInfo, GtkRequestedSize, GtkRequestedSizeLike, _GtkRequestedSize, GtkRequisition, GtkRequisitionLike, _GtkRequisition, GtkScrollInfo, GtkTextIter, GtkTextIterLike, _GtkTextIter, GtkTreeIter, GtkTreeIterLike, _GtkTreeIter, GtkTreePath, GtkAccessible, GtkAccessibleRange, GtkActionable, GtkAppChooser, GtkBuildable, GtkBuilderScope, GtkCellEditable, GtkCellLayout, GtkColorChooser, GtkConstraintTarget, GtkEditable, GtkFileChooser, GtkFontChooser, GtkNative, GtkOrientable, GtkPrintOperationPreview, GtkRoot, GtkScrollable, GtkSectionModel, GtkSelectionModel, GtkShortcutManager, GtkStyleProvider, GtkSymbolicPaintable, GtkTreeDragDest, GtkTreeDragSource, GtkTreeModel, GtkTreeSortable, GtkATContext, GtkAboutDialog, GtkAboutDialogLeaf, GtkActionBar, GtkActionBarLeaf, GtkActivateAction, GtkActivateActionLeaf, GtkAdjustment, GtkAdjustmentLeaf, GtkAlertDialog, GtkAlertDialogLeaf, GtkAlternativeTrigger, GtkAlternativeTriggerLeaf, GtkAnyFilter, GtkAnyFilterLeaf, GtkAppChooserButton, GtkAppChooserButtonLeaf, GtkAppChooserDialog, GtkAppChooserDialogLeaf, GtkAppChooserWidget, GtkAppChooserWidgetLeaf, GtkApplication, GtkApplicationLeaf, GtkApplicationWindow, GtkApplicationWindowLeaf, GtkAspectFrame, GtkAspectFrameLeaf, GtkAssistant, GtkAssistantLeaf, GtkAssistantPage, GtkAssistantPageLeaf, GtkBinLayout, GtkBinLayoutLeaf, GtkBookmarkList, GtkBookmarkListLeaf, GtkBoolFilter, GtkBoolFilterLeaf, GtkBox, GtkBoxLeaf, GtkBoxLayout, GtkBoxLayoutLeaf, GtkBuilder, GtkBuilderLeaf, GtkBuilderCScope, GtkBuilderCScopeLeaf, GtkBuilderListItemFactory, GtkBuilderListItemFactoryLeaf, GtkButton, GtkButtonLeaf, GtkCalendar, GtkCalendarLeaf, GtkCallbackAction, GtkCallbackActionLeaf, GtkCellArea, GtkCellAreaBox, GtkCellAreaBoxLeaf, GtkCellAreaContext, GtkCellAreaContextLeaf, GtkCellRenderer, GtkCellRendererAccel, GtkCellRendererAccelLeaf, GtkCellRendererCombo, GtkCellRendererComboLeaf, GtkCellRendererPixbuf, GtkCellRendererPixbufLeaf, GtkCellRendererProgress, GtkCellRendererProgressLeaf, GtkCellRendererSpin, GtkCellRendererSpinLeaf, GtkCellRendererSpinner, GtkCellRendererSpinnerLeaf, GtkCellRendererText, GtkCellRendererTextLeaf, GtkCellRendererToggle, GtkCellRendererToggleLeaf, GtkCellView, GtkCellViewLeaf, GtkCenterBox, GtkCenterBoxLeaf, GtkCenterLayout, GtkCenterLayoutLeaf, GtkCheckButton, GtkCheckButtonLeaf, GtkColorButton, GtkColorButtonLeaf, GtkColorChooserDialog, GtkColorChooserDialogLeaf, GtkColorChooserWidget, GtkColorChooserWidgetLeaf, GtkColorDialog, GtkColorDialogLeaf, GtkColorDialogButton, GtkColorDialogButtonLeaf, GtkColumnView, GtkColumnViewLeaf, GtkColumnViewCell, GtkColumnViewCellLeaf, GtkColumnViewColumn, GtkColumnViewColumnLeaf, GtkColumnViewRow, GtkColumnViewRowLeaf, GtkColumnViewSorter, GtkColumnViewSorterLeaf, GtkComboBox, GtkComboBoxLeaf, GtkComboBoxText, GtkComboBoxTextLeaf, GtkConstantExpression, GtkConstantExpressionLeaf, GtkConstraint, GtkConstraintLeaf, GtkConstraintGuide, GtkConstraintGuideLeaf, GtkConstraintLayout, GtkConstraintLayoutLeaf, GtkConstraintLayoutChild, GtkConstraintLayoutChildLeaf, GtkCssProvider, GtkCssProviderLeaf, GtkCustomFilter, GtkCustomFilterLeaf, GtkCustomLayout, GtkCustomLayoutLeaf, GtkCustomSorter, GtkCustomSorterLeaf, GtkDialog, GtkDialogLeaf, GtkDirectoryList, GtkDirectoryListLeaf, GtkDragIcon, GtkDragIconLeaf, GtkDragSource, GtkDragSourceLeaf, GtkDrawingArea, GtkDrawingAreaLeaf, GtkDropControllerMotion, GtkDropControllerMotionLeaf, GtkDropDown, GtkDropDownLeaf, GtkDropTarget, GtkDropTargetLeaf, GtkDropTargetAsync, GtkDropTargetAsyncLeaf, GtkEditableLabel, GtkEditableLabelLeaf, GtkEmojiChooser, GtkEmojiChooserLeaf, GtkEntry, GtkEntryLeaf, GtkEntryBuffer, GtkEntryBufferLeaf, GtkEntryCompletion, GtkEntryCompletionLeaf, GtkEventController, GtkEventControllerFocus, GtkEventControllerFocusLeaf, GtkEventControllerKey, GtkEventControllerKeyLeaf, GtkEventControllerLegacy, GtkEventControllerLegacyLeaf, GtkEventControllerMotion, GtkEventControllerMotionLeaf, GtkEventControllerScroll, GtkEventControllerScrollLeaf, GtkEveryFilter, GtkEveryFilterLeaf, GtkExpander, GtkExpanderLeaf, GtkExpression, GtkFileChooserDialog, GtkFileChooserDialogLeaf, GtkFileChooserNative, GtkFileChooserNativeLeaf, GtkFileChooserWidget, GtkFileChooserWidgetLeaf, GtkFileDialog, GtkFileDialogLeaf, GtkFileFilter, GtkFileFilterLeaf, GtkFileLauncher, GtkFileLauncherLeaf, GtkFilter, GtkFilterLeaf, GtkFilterListModel, GtkFilterListModelLeaf, GtkFixed, GtkFixedLeaf, GtkFixedLayout, GtkFixedLayoutLeaf, GtkFixedLayoutChild, GtkFixedLayoutChildLeaf, GtkFlattenListModel, GtkFlattenListModelLeaf, GtkFlowBox, GtkFlowBoxLeaf, GtkFlowBoxChild, GtkFlowBoxChildLeaf, GtkFontButton, GtkFontButtonLeaf, GtkFontChooserDialog, GtkFontChooserDialogLeaf, GtkFontChooserWidget, GtkFontChooserWidgetLeaf, GtkFontDialog, GtkFontDialogLeaf, GtkFontDialogButton, GtkFontDialogButtonLeaf, GtkFrame, GtkFrameLeaf, GtkGLArea, GtkGLAreaLeaf, GtkGesture, GtkGestureClick, GtkGestureClickLeaf, GtkGestureDrag, GtkGestureDragLeaf, GtkGestureLongPress, GtkGestureLongPressLeaf, GtkGesturePan, GtkGesturePanLeaf, GtkGestureRotate, GtkGestureRotateLeaf, GtkGestureSingle, GtkGestureSingleLeaf, GtkGestureStylus, GtkGestureStylusLeaf, GtkGestureSwipe, GtkGestureSwipeLeaf, GtkGestureZoom, GtkGestureZoomLeaf, GtkGrid, GtkGridLeaf, GtkGridLayout, GtkGridLayoutLeaf, GtkGridLayoutChild, GtkGridLayoutChildLeaf, GtkGridView, GtkGridViewLeaf, GtkHeaderBar, GtkHeaderBarLeaf, GtkIMContext, GtkIMContextSimple, GtkIMContextSimpleLeaf, GtkIMMulticontext, GtkIMMulticontextLeaf, GtkIconPaintable, GtkIconPaintableLeaf, GtkIconTheme, GtkIconThemeLeaf, GtkIconView, GtkIconViewLeaf, GtkImage, GtkImageLeaf, GtkInfoBar, GtkInfoBarLeaf, GtkInscription, GtkInscriptionLeaf, GtkKeyvalTrigger, GtkKeyvalTriggerLeaf, GtkLabel, GtkLabelLeaf, GtkLayoutChild, GtkLayoutManager, GtkLevelBar, GtkLevelBarLeaf, GtkLinkButton, GtkLinkButtonLeaf, GtkListBase, GtkListBox, GtkListBoxLeaf, GtkListBoxRow, GtkListBoxRowLeaf, GtkListHeader, GtkListHeaderLeaf, GtkListItem, GtkListItemLeaf, GtkListItemFactory, GtkListItemFactoryLeaf, GtkListStore, GtkListStoreLeaf, GtkListView, GtkListViewLeaf, GtkLockButton, GtkLockButtonLeaf, GtkMapListModel, GtkMapListModelLeaf, GtkMediaControls, GtkMediaControlsLeaf, GtkMediaFile, GtkMediaStream, GtkMenuButton, GtkMenuButtonLeaf, GtkMessageDialog, GtkMessageDialogLeaf, GtkMnemonicAction, GtkMnemonicActionLeaf, GtkMnemonicTrigger, GtkMnemonicTriggerLeaf, GtkMountOperation, GtkMountOperationLeaf, GtkMultiFilter, GtkMultiSelection, GtkMultiSelectionLeaf, GtkMultiSorter, GtkMultiSorterLeaf, GtkNamedAction, GtkNamedActionLeaf, GtkNativeDialog, GtkNeverTrigger, GtkNeverTriggerLeaf, GtkNoSelection, GtkNoSelectionLeaf, GtkNotebook, GtkNotebookLeaf, GtkNotebookPage, GtkNotebookPageLeaf, GtkNothingAction, GtkNothingActionLeaf, GtkNumericSorter, GtkNumericSorterLeaf, GtkObjectExpression, GtkObjectExpressionLeaf, GtkOverlay, GtkOverlayLeaf, GtkOverlayLayout, GtkOverlayLayoutLeaf, GtkOverlayLayoutChild, GtkOverlayLayoutChildLeaf, GtkPadController, GtkPadControllerLeaf, GtkPageSetup, GtkPageSetupLeaf, GtkPaned, GtkPanedLeaf, GtkPasswordEntry, GtkPasswordEntryLeaf, GtkPasswordEntryBuffer, GtkPasswordEntryBufferLeaf, GtkPicture, GtkPictureLeaf, GtkPopover, GtkPopoverLeaf, GtkPopoverMenu, GtkPopoverMenuLeaf, GtkPopoverMenuBar, GtkPopoverMenuBarLeaf, GtkPrintContext, GtkPrintContextLeaf, GtkPrintJob, GtkPrintJobLeaf, GtkPrintOperation, GtkPrintOperationLeaf, GtkPrintSettings, GtkPrintSettingsLeaf, GtkPrinter, GtkPrinterLeaf, GtkProgressBar, GtkProgressBarLeaf, GtkPropertyExpression, GtkPropertyExpressionLeaf, GtkRange, GtkRangeLeaf, GtkRecentManager, GtkRecentManagerLeaf, GtkRevealer, GtkRevealerLeaf, GtkScale, GtkScaleLeaf, GtkScaleButton, GtkScaleButtonLeaf, GtkScrollbar, GtkScrollbarLeaf, GtkScrolledWindow, GtkScrolledWindowLeaf, GtkSearchBar, GtkSearchBarLeaf, GtkSearchEntry, GtkSearchEntryLeaf, GtkSelectionFilterModel, GtkSelectionFilterModelLeaf, GtkSeparator, GtkSeparatorLeaf, GtkSettings, GtkSettingsLeaf, GtkShortcut, GtkShortcutLeaf, GtkShortcutAction, GtkShortcutController, GtkShortcutControllerLeaf, GtkShortcutLabel, GtkShortcutLabelLeaf, GtkShortcutTrigger, GtkShortcutsGroup, GtkShortcutsGroupLeaf, GtkShortcutsSection, GtkShortcutsSectionLeaf, GtkShortcutsShortcut, GtkShortcutsShortcutLeaf, GtkShortcutsWindow, GtkShortcutsWindowLeaf, GtkSignalAction, GtkSignalActionLeaf, GtkSignalListItemFactory, GtkSignalListItemFactoryLeaf, GtkSingleSelection, GtkSingleSelectionLeaf, GtkSizeGroup, GtkSizeGroupLeaf, GtkSliceListModel, GtkSliceListModelLeaf, GtkSnapshot, GtkSnapshotLeaf, GtkSortListModel, GtkSortListModelLeaf, GtkSorter, GtkSorterLeaf, GtkSpinButton, GtkSpinButtonLeaf, GtkSpinner, GtkSpinnerLeaf, GtkStack, GtkStackLeaf, GtkStackPage, GtkStackPageLeaf, GtkStackSidebar, GtkStackSidebarLeaf, GtkStackSwitcher, GtkStackSwitcherLeaf, GtkStatusbar, GtkStatusbarLeaf, GtkStringFilter, GtkStringFilterLeaf, GtkStringList, GtkStringListLeaf, GtkStringObject, GtkStringObjectLeaf, GtkStringSorter, GtkStringSorterLeaf, GtkStyleContext, GtkStyleContextLeaf, GtkSwitch, GtkSwitchLeaf, GtkText, GtkTextLeaf, GtkTextBuffer, GtkTextBufferLeaf, GtkTextChildAnchor, GtkTextChildAnchorLeaf, GtkTextMark, GtkTextMarkLeaf, GtkTextTag, GtkTextTagLeaf, GtkTextTagTable, GtkTextTagTableLeaf, GtkTextView, GtkTextViewLeaf, GtkToggleButton, GtkToggleButtonLeaf, GtkTooltip, GtkTooltipLeaf, GtkTreeExpander, GtkTreeExpanderLeaf, GtkTreeListModel, GtkTreeListModelLeaf, GtkTreeListRow, GtkTreeListRowLeaf, GtkTreeListRowSorter, GtkTreeListRowSorterLeaf, GtkTreeModelFilter, GtkTreeModelFilterLeaf, GtkTreeModelSort, GtkTreeModelSortLeaf, GtkTreeSelection, GtkTreeSelectionLeaf, GtkTreeStore, GtkTreeStoreLeaf, GtkTreeView, GtkTreeViewLeaf, GtkTreeViewColumn, GtkTreeViewColumnLeaf, GtkUriLauncher, GtkUriLauncherLeaf, GtkVideo, GtkVideoLeaf, GtkViewport, GtkViewportLeaf, GtkVolumeButton, GtkVolumeButtonLeaf, GtkWidget, GtkWidgetPaintable, GtkWidgetPaintableLeaf, GtkWindow, GtkWindowLeaf, GtkWindowControls, GtkWindowControlsLeaf, GtkWindowGroup, GtkWindowGroupLeaf, GtkWindowHandle, GtkWindowHandleLeaf, GtkAssistantPageFunc, GtkCellAllocCallback, GtkCellCallback, GtkCellLayoutDataFunc, GtkCustomFilterFunc, GtkDrawingAreaDrawFunc, GtkEntryCompletionMatchFunc, GtkExpressionNotify, GtkFlowBoxCreateWidgetFunc, GtkFlowBoxFilterFunc, GtkFlowBoxForeachFunc, GtkFlowBoxSortFunc, GtkFontFilterFunc, GtkIconViewForeachFunc, GtkListBoxCreateWidgetFunc, GtkListBoxFilterFunc, GtkListBoxForeachFunc, GtkListBoxSortFunc, GtkListBoxUpdateHeaderFunc, GtkMapListModelMapFunc, GtkMenuButtonCreatePopupFunc, GtkPageSetupDoneFunc, GtkPrintSettingsFunc, GtkPrinterFunc, GtkScaleFormatValueFunc, GtkShortcutFunc, GtkTextCharPredicate, GtkTextTagTableForeach, GtkTickCallback, GtkTreeCellDataFunc, GtkTreeIterCompareFunc, GtkTreeListModelCreateModelFunc, GtkTreeModelFilterModifyFunc, GtkTreeModelFilterVisibleFunc, GtkTreeModelForeachFunc, GtkTreeSelectionForeachFunc, GtkTreeSelectionFunc, GtkTreeViewColumnDropFunc, GtkTreeViewMappingFunc, GtkTreeViewRowSeparatorFunc, GtkTreeViewSearchEqualFunc end)) end diff --git a/src/gen/pango_functions b/src/gen/pango_functions index f9352857..3de10cf6 100644 --- a/src/gen/pango_functions +++ b/src/gen/pango_functions @@ -2,22 +2,22 @@ quote $(Expr(:toplevel, quote function attr_allow_breaks_new(_allow_breaks::Bool) ret = ccall(("pango_attr_allow_breaks_new", libpango), Ptr{_PangoAttribute}, (Cint,), _allow_breaks) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_background_alpha_new(_alpha::Integer) ret = ccall(("pango_attr_background_alpha_new", libpango), Ptr{_PangoAttribute}, (UInt16,), _alpha) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_background_new(_red::Integer, _green::Integer, _blue::Integer) ret = ccall(("pango_attr_background_new", libpango), Ptr{_PangoAttribute}, (UInt16, UInt16, UInt16), _red, _green, _blue) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_baseline_shift_new(_shift::Integer) ret = ccall(("pango_attr_baseline_shift_new", libpango), Ptr{_PangoAttribute}, (Int32,), _shift) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_break(_text::Union{AbstractString, Symbol}, _length::Integer, _attr_list::PangoAttrList, _offset::Integer, _attrs) @@ -28,72 +28,72 @@ $(Expr(:toplevel, quote end function attr_fallback_new(_enable_fallback::Bool) ret = ccall(("pango_attr_fallback_new", libpango), Ptr{_PangoAttribute}, (Cint,), _enable_fallback) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_family_new(_family::Union{AbstractString, Symbol}) ret = ccall(("pango_attr_family_new", libpango), Ptr{_PangoAttribute}, (Cstring,), _family) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_font_desc_new(_desc::PangoFontDescription) ret = ccall(("pango_attr_font_desc_new", libpango), Ptr{_PangoAttribute}, (Ptr{PangoFontDescription},), _desc) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_font_features_new(_features::Union{AbstractString, Symbol}) ret = ccall(("pango_attr_font_features_new", libpango), Ptr{_PangoAttribute}, (Cstring,), _features) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_font_scale_new(_scale) ret = ccall(("pango_attr_font_scale_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _scale) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_foreground_alpha_new(_alpha::Integer) ret = ccall(("pango_attr_foreground_alpha_new", libpango), Ptr{_PangoAttribute}, (UInt16,), _alpha) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_foreground_new(_red::Integer, _green::Integer, _blue::Integer) ret = ccall(("pango_attr_foreground_new", libpango), Ptr{_PangoAttribute}, (UInt16, UInt16, UInt16), _red, _green, _blue) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_gravity_hint_new(_hint) ret = ccall(("pango_attr_gravity_hint_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _hint) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_gravity_new(_gravity) ret = ccall(("pango_attr_gravity_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _gravity) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_insert_hyphens_new(_insert_hyphens::Bool) ret = ccall(("pango_attr_insert_hyphens_new", libpango), Ptr{_PangoAttribute}, (Cint,), _insert_hyphens) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_language_new(_language::PangoLanguage) ret = ccall(("pango_attr_language_new", libpango), Ptr{_PangoAttribute}, (Ptr{PangoLanguage},), _language) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_letter_spacing_new(_letter_spacing::Integer) ret = ccall(("pango_attr_letter_spacing_new", libpango), Ptr{_PangoAttribute}, (Int32,), _letter_spacing) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_line_height_new(_factor::Real) ret = ccall(("pango_attr_line_height_new", libpango), Ptr{_PangoAttribute}, (Float64,), _factor) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_line_height_new_absolute(_height::Integer) ret = ccall(("pango_attr_line_height_new_absolute", libpango), Ptr{_PangoAttribute}, (Int32,), _height) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_list_from_string(_text::Union{AbstractString, Symbol}) @@ -103,72 +103,72 @@ $(Expr(:toplevel, quote end function attr_overline_color_new(_red::Integer, _green::Integer, _blue::Integer) ret = ccall(("pango_attr_overline_color_new", libpango), Ptr{_PangoAttribute}, (UInt16, UInt16, UInt16), _red, _green, _blue) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_overline_new(_overline) ret = ccall(("pango_attr_overline_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _overline) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_rise_new(_rise::Integer) ret = ccall(("pango_attr_rise_new", libpango), Ptr{_PangoAttribute}, (Int32,), _rise) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_scale_new(_scale_factor::Real) ret = ccall(("pango_attr_scale_new", libpango), Ptr{_PangoAttribute}, (Float64,), _scale_factor) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_sentence_new() ret = ccall(("pango_attr_sentence_new", libpango), Ptr{_PangoAttribute}, ()) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end - function attr_shape_new(_ink_rect::Union{PangoRectangle, Ref{_PangoRectangle}}, _logical_rect::Union{PangoRectangle, Ref{_PangoRectangle}}) + function attr_shape_new(_ink_rect::PangoRectangleLike, _logical_rect::PangoRectangleLike) ret = ccall(("pango_attr_shape_new", libpango), Ptr{_PangoAttribute}, (Ptr{_PangoRectangle}, Ptr{_PangoRectangle}), _ink_rect, _logical_rect) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_show_new(_flags) ret = ccall(("pango_attr_show_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _flags) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_size_new(_size::Integer) ret = ccall(("pango_attr_size_new", libpango), Ptr{_PangoAttribute}, (Int32,), _size) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_size_new_absolute(_size::Integer) ret = ccall(("pango_attr_size_new_absolute", libpango), Ptr{_PangoAttribute}, (Int32,), _size) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_stretch_new(_stretch) ret = ccall(("pango_attr_stretch_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _stretch) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_strikethrough_color_new(_red::Integer, _green::Integer, _blue::Integer) ret = ccall(("pango_attr_strikethrough_color_new", libpango), Ptr{_PangoAttribute}, (UInt16, UInt16, UInt16), _red, _green, _blue) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_strikethrough_new(_strikethrough::Bool) ret = ccall(("pango_attr_strikethrough_new", libpango), Ptr{_PangoAttribute}, (Cint,), _strikethrough) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_style_new(_style) ret = ccall(("pango_attr_style_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _style) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_text_transform_new(_transform) ret = ccall(("pango_attr_text_transform_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _transform) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_type_get_name(_type) @@ -183,27 +183,27 @@ $(Expr(:toplevel, quote end function attr_underline_color_new(_red::Integer, _green::Integer, _blue::Integer) ret = ccall(("pango_attr_underline_color_new", libpango), Ptr{_PangoAttribute}, (UInt16, UInt16, UInt16), _red, _green, _blue) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_underline_new(_underline) ret = ccall(("pango_attr_underline_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _underline) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_variant_new(_variant) ret = ccall(("pango_attr_variant_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _variant) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_weight_new(_weight) ret = ccall(("pango_attr_weight_new", libpango), Ptr{_PangoAttribute}, (UInt32,), _weight) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function attr_word_new() ret = ccall(("pango_attr_word_new", libpango), Ptr{_PangoAttribute}, ()) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end function bidi_type_for_unichar(_ch) @@ -211,12 +211,12 @@ $(Expr(:toplevel, quote ret2 = BidiType(ret) ret2 end - function default_break(_text::Union{AbstractString, Symbol}, _length::Integer, _analysis::Maybe(Union{PangoAnalysis, Ref{_PangoAnalysis}}), _attrs::Union{PangoLogAttr, Ref{_PangoLogAttr}}, _attrs_len::Integer) + function default_break(_text::Union{AbstractString, Symbol}, _length::Integer, _analysis::Maybe(PangoAnalysisLike), _attrs::PangoLogAttrLike, _attrs_len::Integer) _analysis_maybe = nothing_to_null(_analysis) ret = ccall(("pango_default_break", libpango), Nothing, (Cstring, Int32, Ptr{_PangoAnalysis}, Ptr{_PangoLogAttr}, Int32), _text, _length, _analysis_maybe, _attrs, _attrs_len) nothing end - function extents_to_pixels(_inclusive::Maybe(Union{PangoRectangle, Ref{_PangoRectangle}}), _nearest::Maybe(Union{PangoRectangle, Ref{_PangoRectangle}})) + function extents_to_pixels(_inclusive::Maybe(PangoRectangleLike), _nearest::Maybe(PangoRectangleLike)) _inclusive_maybe = nothing_to_null(_inclusive) _nearest_maybe = nothing_to_null(_nearest) ret = ccall(("pango_extents_to_pixels", libpango), Nothing, (Ptr{_PangoRectangle}, Ptr{_PangoRectangle}), _inclusive_maybe, _nearest_maybe) @@ -246,7 +246,7 @@ $(Expr(:toplevel, quote ret = ccall(("pango_get_log_attrs", libpango), Nothing, (Cstring, Int32, Int32, Ptr{PangoLanguage}, Ptr{_PangoLogAttr}, Int32), _text, _length, _level, _language, _attrs_arr, _attrs_len) nothing end - function gravity_get_for_matrix(_matrix::Maybe(Union{PangoMatrix, Ref{_PangoMatrix}})) + function gravity_get_for_matrix(_matrix::Maybe(PangoMatrixLike)) _matrix_maybe = nothing_to_null(_matrix) ret = ccall(("pango_gravity_get_for_matrix", libpango), UInt32, (Ptr{_PangoMatrix},), _matrix_maybe) ret2 = Gravity(ret) @@ -390,22 +390,22 @@ $(Expr(:toplevel, quote ret2 = convert_if_not_null(PangoLanguage, ret, true) ret2 end - function shape(_text::Union{AbstractString, Symbol}, _length::Integer, _analysis::Union{PangoAnalysis, Ref{_PangoAnalysis}}, _glyphs::Union{PangoGlyphString, Ref{_PangoGlyphString}}) + function shape(_text::Union{AbstractString, Symbol}, _length::Integer, _analysis::PangoAnalysisLike, _glyphs::PangoGlyphStringLike) ret = ccall(("pango_shape", libpango), Nothing, (Cstring, Int32, Ptr{_PangoAnalysis}, Ptr{_PangoGlyphString}), _text, _length, _analysis, _glyphs) nothing end - function shape_full(_item_text::Union{AbstractString, Symbol}, _item_length::Integer, _paragraph_text::Maybe(Union{AbstractString, Symbol}), _paragraph_length::Integer, _analysis::Union{PangoAnalysis, Ref{_PangoAnalysis}}, _glyphs::Union{PangoGlyphString, Ref{_PangoGlyphString}}) + function shape_full(_item_text::Union{AbstractString, Symbol}, _item_length::Integer, _paragraph_text::Maybe(Union{AbstractString, Symbol}), _paragraph_length::Integer, _analysis::PangoAnalysisLike, _glyphs::PangoGlyphStringLike) _paragraph_text_maybe = nothing_to_null(_paragraph_text) ret = ccall(("pango_shape_full", libpango), Nothing, (Cstring, Int32, Cstring, Int32, Ptr{_PangoAnalysis}, Ptr{_PangoGlyphString}), _item_text, _item_length, _paragraph_text_maybe, _paragraph_length, _analysis, _glyphs) nothing end - function shape_item(_item::Union{PangoItem, Ref{_PangoItem}}, _paragraph_text::Maybe(Union{AbstractString, Symbol}), _paragraph_length::Integer, _log_attrs::Maybe(Union{PangoLogAttr, Ref{_PangoLogAttr}}), _glyphs::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _flags) + function shape_item(_item::PangoItemLike, _paragraph_text::Maybe(Union{AbstractString, Symbol}), _paragraph_length::Integer, _log_attrs::Maybe(PangoLogAttrLike), _glyphs::PangoGlyphStringLike, _flags) _paragraph_text_maybe = nothing_to_null(_paragraph_text) _log_attrs_maybe = nothing_to_null(_log_attrs) ret = ccall(("pango_shape_item", libpango), Nothing, (Ptr{_PangoItem}, Cstring, Int32, Ptr{_PangoLogAttr}, Ptr{_PangoGlyphString}, UInt32), _item, _paragraph_text_maybe, _paragraph_length, _log_attrs_maybe, _glyphs, _flags) nothing end - function shape_with_flags(_item_text::Union{AbstractString, Symbol}, _item_length::Integer, _paragraph_text::Maybe(Union{AbstractString, Symbol}), _paragraph_length::Integer, _analysis::Union{PangoAnalysis, Ref{_PangoAnalysis}}, _glyphs::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _flags) + function shape_with_flags(_item_text::Union{AbstractString, Symbol}, _item_length::Integer, _paragraph_text::Maybe(Union{AbstractString, Symbol}), _paragraph_length::Integer, _analysis::PangoAnalysisLike, _glyphs::PangoGlyphStringLike, _flags) _paragraph_text_maybe = nothing_to_null(_paragraph_text) ret = ccall(("pango_shape_with_flags", libpango), Nothing, (Cstring, Int32, Cstring, Int32, Ptr{_PangoAnalysis}, Ptr{_PangoGlyphString}, UInt32), _item_text, _item_length, _paragraph_text_maybe, _paragraph_length, _analysis, _glyphs, _flags) nothing @@ -415,7 +415,7 @@ $(Expr(:toplevel, quote ret2 = convert_if_not_null(PangoTabArray, ret, true) ret2 end - function tailor_break(_text::Union{AbstractString, Symbol}, _length::Integer, _analysis::Union{PangoAnalysis, Ref{_PangoAnalysis}}, _offset::Integer, _attrs) + function tailor_break(_text::Union{AbstractString, Symbol}, _length::Integer, _analysis::PangoAnalysisLike, _offset::Integer, _attrs) _attrs_arr = convert(Vector{_PangoLogAttr}, _attrs) _attrs_len = length(_attrs) ret = ccall(("pango_tailor_break", libpango), Nothing, (Cstring, Int32, Ptr{_PangoAnalysis}, Int32, Ptr{_PangoLogAttr}, Int32), _text, _length, _analysis, _offset, _attrs_arr, _attrs_len) diff --git a/src/gen/pango_methods b/src/gen/pango_methods index f3704752..f6739fdf 100644 --- a/src/gen/pango_methods +++ b/src/gen/pango_methods @@ -47,7 +47,7 @@ $(Expr(:toplevel, quote ret2 = convert(PangoAttrList, ret, true) ret2 end - function change(instance::PangoAttrList, _attr::Union{PangoAttribute, Ref{_PangoAttribute}}) + function change(instance::PangoAttrList, _attr::PangoAttributeLike) ret = ccall(("pango_attr_list_change", libpango), Nothing, (Ptr{PangoAttrList}, Ptr{_PangoAttribute}), instance, _attr) nothing end @@ -71,11 +71,11 @@ $(Expr(:toplevel, quote ret2 = convert(PangoAttrIterator, ret, true) ret2 end - function insert(instance::PangoAttrList, _attr::Union{PangoAttribute, Ref{_PangoAttribute}}) + function insert(instance::PangoAttrList, _attr::PangoAttributeLike) ret = ccall(("pango_attr_list_insert", libpango), Nothing, (Ptr{PangoAttrList}, Ptr{_PangoAttribute}), instance, _attr) nothing end - function insert_before(instance::PangoAttrList, _attr::Union{PangoAttribute, Ref{_PangoAttribute}}) + function insert_before(instance::PangoAttrList, _attr::PangoAttributeLike) ret = ccall(("pango_attr_list_insert_before", libpango), Nothing, (Ptr{PangoAttrList}, Ptr{_PangoAttribute}), instance, _attr) nothing end @@ -101,91 +101,91 @@ $(Expr(:toplevel, quote ret = ccall(("pango_attr_list_update", libpango), Nothing, (Ptr{PangoAttrList}, Int32, Int32, Int32), instance, _pos, _remove, _add) nothing end - function as_color(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function as_color(instance::PangoAttributeLike) ret = ccall(("pango_attribute_as_color", libpango), Ptr{_PangoAttrColor}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttrColor, Ref{_PangoAttrColor}}, ret) + ret2 = convert(PangoAttrColorLike, ret) ret2 end - function as_float(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function as_float(instance::PangoAttributeLike) ret = ccall(("pango_attribute_as_float", libpango), Ptr{_PangoAttrFloat}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttrFloat, Ref{_PangoAttrFloat}}, ret) + ret2 = convert(PangoAttrFloatLike, ret) ret2 end - function as_font_desc(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function as_font_desc(instance::PangoAttributeLike) ret = ccall(("pango_attribute_as_font_desc", libpango), Ptr{_PangoAttrFontDesc}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttrFontDesc, Ref{_PangoAttrFontDesc}}, ret) + ret2 = convert(PangoAttrFontDescLike, ret) ret2 end - function as_font_features(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function as_font_features(instance::PangoAttributeLike) ret = ccall(("pango_attribute_as_font_features", libpango), Ptr{_PangoAttrFontFeatures}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttrFontFeatures, Ref{_PangoAttrFontFeatures}}, ret) + ret2 = convert(PangoAttrFontFeaturesLike, ret) ret2 end - function as_int(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function as_int(instance::PangoAttributeLike) ret = ccall(("pango_attribute_as_int", libpango), Ptr{_PangoAttrInt}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttrInt, Ref{_PangoAttrInt}}, ret) + ret2 = convert(PangoAttrIntLike, ret) ret2 end - function as_language(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function as_language(instance::PangoAttributeLike) ret = ccall(("pango_attribute_as_language", libpango), Ptr{_PangoAttrLanguage}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttrLanguage, Ref{_PangoAttrLanguage}}, ret) + ret2 = convert(PangoAttrLanguageLike, ret) ret2 end - function as_shape(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function as_shape(instance::PangoAttributeLike) ret = ccall(("pango_attribute_as_shape", libpango), Ptr{_PangoAttrShape}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttrShape, Ref{_PangoAttrShape}}, ret) + ret2 = convert(PangoAttrShapeLike, ret) ret2 end - function as_size(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function as_size(instance::PangoAttributeLike) ret = ccall(("pango_attribute_as_size", libpango), Ptr{_PangoAttrSize}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttrSize, Ref{_PangoAttrSize}}, ret) + ret2 = convert(PangoAttrSizeLike, ret) ret2 end - function as_string(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function as_string(instance::PangoAttributeLike) ret = ccall(("pango_attribute_as_string", libpango), Ptr{_PangoAttrString}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttrString, Ref{_PangoAttrString}}, ret) + ret2 = convert(PangoAttrStringLike, ret) ret2 end - function copy(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function copy(instance::PangoAttributeLike) ret = ccall(("pango_attribute_copy", libpango), Ptr{_PangoAttribute}, (Ptr{_PangoAttribute},), instance) - ret2 = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, ret, true) + ret2 = convert(PangoAttributeLike, ret, true) ret2 end - function destroy(instance::Union{PangoAttribute, Ref{_PangoAttribute}}) + function destroy(instance::PangoAttributeLike) ret = ccall(("pango_attribute_destroy", libpango), Nothing, (Ptr{_PangoAttribute},), instance) nothing end - function equal(instance::Union{PangoAttribute, Ref{_PangoAttribute}}, _attr2::Union{PangoAttribute, Ref{_PangoAttribute}}) + function equal(instance::PangoAttributeLike, _attr2::PangoAttributeLike) ret = ccall(("pango_attribute_equal", libpango), Cint, (Ptr{_PangoAttribute}, Ptr{_PangoAttribute}), instance, _attr2) ret2 = convert(Bool, ret) ret2 end - function init(instance::Union{PangoAttribute, Ref{_PangoAttribute}}, _klass::Union{PangoAttrClass, Ref{_PangoAttrClass}}) + function init(instance::PangoAttributeLike, _klass::PangoAttrClassLike) ret = ccall(("pango_attribute_init", libpango), Nothing, (Ptr{_PangoAttribute}, Ptr{_PangoAttrClass}), instance, _klass) nothing end - function copy(instance::Union{PangoColor, Ref{_PangoColor}}) + function copy(instance::PangoColorLike) ret = ccall(("pango_color_copy", libpango), Ptr{_PangoColor}, (Ptr{_PangoColor},), instance) ret2 = convert_if_not_null(PangoColor, ret, true) ret2 end - function free(instance::Union{PangoColor, Ref{_PangoColor}}) + function free(instance::PangoColorLike) ret = ccall(("pango_color_free", libpango), Nothing, (Ptr{_PangoColor},), instance) nothing end - function parse(instance::Union{PangoColor, Ref{_PangoColor}}, _spec::Union{AbstractString, Symbol}) + function parse(instance::PangoColorLike, _spec::Union{AbstractString, Symbol}) ret = ccall(("pango_color_parse", libpango), Cint, (Ptr{_PangoColor}, Cstring), instance, _spec) ret2 = convert(Bool, ret) ret2 end - function parse_with_alpha(instance::Union{PangoColor, Ref{_PangoColor}}, _spec::Union{AbstractString, Symbol}) + function parse_with_alpha(instance::PangoColorLike, _spec::Union{AbstractString, Symbol}) m_alpha = Ref{UInt16}() ret = ccall(("pango_color_parse_with_alpha", libpango), Cint, (Ptr{_PangoColor}, Ptr{UInt16}, Cstring), instance, m_alpha, _spec) ret2 = convert(Bool, ret) _alpha = m_alpha[] (ret2, _alpha) end - function to_string(instance::Union{PangoColor, Ref{_PangoColor}}) + function to_string(instance::PangoColorLike) ret = ccall(("pango_color_to_string", libpango), Cstring, (Ptr{_PangoColor},), instance) ret2 = string_or_nothing(ret, true) ret2 @@ -341,120 +341,120 @@ $(Expr(:toplevel, quote ret = ccall(("pango_font_description_unset_fields", libpango), Nothing, (Ptr{PangoFontDescription}, UInt32), instance, _to_unset) nothing end - function get_approximate_char_width(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function get_approximate_char_width(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_get_approximate_char_width", libpango), Int32, (Ptr{_PangoFontMetrics},), instance) ret end - function get_approximate_digit_width(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function get_approximate_digit_width(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_get_approximate_digit_width", libpango), Int32, (Ptr{_PangoFontMetrics},), instance) ret end - function get_ascent(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function get_ascent(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_get_ascent", libpango), Int32, (Ptr{_PangoFontMetrics},), instance) ret end - function get_descent(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function get_descent(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_get_descent", libpango), Int32, (Ptr{_PangoFontMetrics},), instance) ret end - function get_height(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function get_height(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_get_height", libpango), Int32, (Ptr{_PangoFontMetrics},), instance) ret end - function get_strikethrough_position(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function get_strikethrough_position(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_get_strikethrough_position", libpango), Int32, (Ptr{_PangoFontMetrics},), instance) ret end - function get_strikethrough_thickness(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function get_strikethrough_thickness(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_get_strikethrough_thickness", libpango), Int32, (Ptr{_PangoFontMetrics},), instance) ret end - function get_underline_position(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function get_underline_position(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_get_underline_position", libpango), Int32, (Ptr{_PangoFontMetrics},), instance) ret end - function get_underline_thickness(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function get_underline_thickness(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_get_underline_thickness", libpango), Int32, (Ptr{_PangoFontMetrics},), instance) ret end - function ref(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function ref(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_ref", libpango), Ptr{_PangoFontMetrics}, (Ptr{_PangoFontMetrics},), instance) ret2 = convert_if_not_null(PangoFontMetrics, ret, true) ret2 end - function unref(instance::Union{PangoFontMetrics, Ref{_PangoFontMetrics}}) + function unref(instance::PangoFontMetricsLike) ret = ccall(("pango_font_metrics_unref", libpango), Nothing, (Ptr{_PangoFontMetrics},), instance) nothing end - function apply_attrs(instance::Union{PangoGlyphItem, Ref{_PangoGlyphItem}}, _text::Union{AbstractString, Symbol}, _list::PangoAttrList) + function apply_attrs(instance::PangoGlyphItemLike, _text::Union{AbstractString, Symbol}, _list::PangoAttrList) ret = ccall(("pango_glyph_item_apply_attrs", libpango), Ptr{GLib._GSList{_PangoGlyphItem}}, (Ptr{_PangoGlyphItem}, Cstring, Ptr{PangoAttrList}), instance, _text, _list) ret2 = GLib.GList(ret, true) ret2 end - function copy(instance::Union{PangoGlyphItem, Ref{_PangoGlyphItem}}) + function copy(instance::PangoGlyphItemLike) ret = ccall(("pango_glyph_item_copy", libpango), Ptr{_PangoGlyphItem}, (Ptr{_PangoGlyphItem},), instance) ret2 = convert_if_not_null(PangoGlyphItem, ret, true) ret2 end - function free(instance::Union{PangoGlyphItem, Ref{_PangoGlyphItem}}) + function free(instance::PangoGlyphItemLike) ret = ccall(("pango_glyph_item_free", libpango), Nothing, (Ptr{_PangoGlyphItem},), instance) nothing end - function get_logical_widths(instance::Union{PangoGlyphItem, Ref{_PangoGlyphItem}}, _text::Union{AbstractString, Symbol}, _logical_widths) + function get_logical_widths(instance::PangoGlyphItemLike, _text::Union{AbstractString, Symbol}, _logical_widths) _logical_widths_arr = convert(Vector{Int32}, _logical_widths) ret = ccall(("pango_glyph_item_get_logical_widths", libpango), Nothing, (Ptr{_PangoGlyphItem}, Cstring, Ptr{Int32}), instance, _text, _logical_widths_arr) nothing end - function letter_space(instance::Union{PangoGlyphItem, Ref{_PangoGlyphItem}}, _text::Union{AbstractString, Symbol}, _log_attrs, _letter_spacing::Integer) + function letter_space(instance::PangoGlyphItemLike, _text::Union{AbstractString, Symbol}, _log_attrs, _letter_spacing::Integer) _log_attrs_arr = convert(Vector{_PangoLogAttr}, _log_attrs) ret = ccall(("pango_glyph_item_letter_space", libpango), Nothing, (Ptr{_PangoGlyphItem}, Cstring, Ptr{_PangoLogAttr}, Int32), instance, _text, _log_attrs_arr, _letter_spacing) nothing end - function split(instance::Union{PangoGlyphItem, Ref{_PangoGlyphItem}}, _text::Union{AbstractString, Symbol}, _split_index::Integer) + function split(instance::PangoGlyphItemLike, _text::Union{AbstractString, Symbol}, _split_index::Integer) ret = ccall(("pango_glyph_item_split", libpango), Ptr{_PangoGlyphItem}, (Ptr{_PangoGlyphItem}, Cstring, Int32), instance, _text, _split_index) ret2 = convert_if_not_null(PangoGlyphItem, ret, true) ret2 end - function copy(instance::Union{PangoGlyphItemIter, Ref{_PangoGlyphItemIter}}) + function copy(instance::PangoGlyphItemIterLike) ret = ccall(("pango_glyph_item_iter_copy", libpango), Ptr{_PangoGlyphItemIter}, (Ptr{_PangoGlyphItemIter},), instance) ret2 = convert_if_not_null(PangoGlyphItemIter, ret, true) ret2 end - function free(instance::Union{PangoGlyphItemIter, Ref{_PangoGlyphItemIter}}) + function free(instance::PangoGlyphItemIterLike) ret = ccall(("pango_glyph_item_iter_free", libpango), Nothing, (Ptr{_PangoGlyphItemIter},), instance) nothing end - function init_end(instance::Union{PangoGlyphItemIter, Ref{_PangoGlyphItemIter}}, _glyph_item::Union{PangoGlyphItem, Ref{_PangoGlyphItem}}, _text::Union{AbstractString, Symbol}) + function init_end(instance::PangoGlyphItemIterLike, _glyph_item::PangoGlyphItemLike, _text::Union{AbstractString, Symbol}) ret = ccall(("pango_glyph_item_iter_init_end", libpango), Cint, (Ptr{_PangoGlyphItemIter}, Ptr{_PangoGlyphItem}, Cstring), instance, _glyph_item, _text) ret2 = convert(Bool, ret) ret2 end - function init_start(instance::Union{PangoGlyphItemIter, Ref{_PangoGlyphItemIter}}, _glyph_item::Union{PangoGlyphItem, Ref{_PangoGlyphItem}}, _text::Union{AbstractString, Symbol}) + function init_start(instance::PangoGlyphItemIterLike, _glyph_item::PangoGlyphItemLike, _text::Union{AbstractString, Symbol}) ret = ccall(("pango_glyph_item_iter_init_start", libpango), Cint, (Ptr{_PangoGlyphItemIter}, Ptr{_PangoGlyphItem}, Cstring), instance, _glyph_item, _text) ret2 = convert(Bool, ret) ret2 end - function next_cluster(instance::Union{PangoGlyphItemIter, Ref{_PangoGlyphItemIter}}) + function next_cluster(instance::PangoGlyphItemIterLike) ret = ccall(("pango_glyph_item_iter_next_cluster", libpango), Cint, (Ptr{_PangoGlyphItemIter},), instance) ret2 = convert(Bool, ret) ret2 end - function prev_cluster(instance::Union{PangoGlyphItemIter, Ref{_PangoGlyphItemIter}}) + function prev_cluster(instance::PangoGlyphItemIterLike) ret = ccall(("pango_glyph_item_iter_prev_cluster", libpango), Cint, (Ptr{_PangoGlyphItemIter},), instance) ret2 = convert(Bool, ret) ret2 end function GlyphString_new() ret = ccall(("pango_glyph_string_new", libpango), Ptr{_PangoGlyphString}, ()) - ret2 = convert(Union{PangoGlyphString, Ref{_PangoGlyphString}}, ret, true) + ret2 = convert(PangoGlyphStringLike, ret, true) ret2 end - function copy(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}) + function copy(instance::PangoGlyphStringLike) ret = ccall(("pango_glyph_string_copy", libpango), Ptr{_PangoGlyphString}, (Ptr{_PangoGlyphString},), instance) ret2 = convert_if_not_null(PangoGlyphString, ret, true) ret2 end - function extents(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _font::PangoFont) + function extents(instance::PangoGlyphStringLike, _font::PangoFont) m_ink_rect = Ref{_PangoRectangle}() m_logical_rect = Ref{_PangoRectangle}() ret = ccall(("pango_glyph_string_extents", libpango), Nothing, (Ptr{_PangoGlyphString}, Ptr{GObject}, Ptr{_PangoRectangle}, Ptr{_PangoRectangle}), instance, _font, m_ink_rect, m_logical_rect) @@ -464,7 +464,7 @@ $(Expr(:toplevel, quote _logical_rect = convert(_PangoRectangle, _logical_rect) (_ink_rect, _logical_rect) end - function extents_range(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _start::Integer, _end::Integer, _font::PangoFont) + function extents_range(instance::PangoGlyphStringLike, _start::Integer, _end::Integer, _font::PangoFont) m_ink_rect = Ref{_PangoRectangle}() m_logical_rect = Ref{_PangoRectangle}() ret = ccall(("pango_glyph_string_extents_range", libpango), Nothing, (Ptr{_PangoGlyphString}, Int32, Int32, Ptr{GObject}, Ptr{_PangoRectangle}, Ptr{_PangoRectangle}), instance, _start, _end, _font, m_ink_rect, m_logical_rect) @@ -474,37 +474,37 @@ $(Expr(:toplevel, quote _logical_rect = convert(_PangoRectangle, _logical_rect) (_ink_rect, _logical_rect) end - function free(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}) + function free(instance::PangoGlyphStringLike) ret = ccall(("pango_glyph_string_free", libpango), Nothing, (Ptr{_PangoGlyphString},), instance) nothing end - function get_logical_widths(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _text::Union{AbstractString, Symbol}, _length::Integer, _embedding_level::Integer, _logical_widths) + function get_logical_widths(instance::PangoGlyphStringLike, _text::Union{AbstractString, Symbol}, _length::Integer, _embedding_level::Integer, _logical_widths) _logical_widths_arr = convert(Vector{Int32}, _logical_widths) ret = ccall(("pango_glyph_string_get_logical_widths", libpango), Nothing, (Ptr{_PangoGlyphString}, Cstring, Int32, Int32, Ptr{Int32}), instance, _text, _length, _embedding_level, _logical_widths_arr) nothing end - function get_width(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}) + function get_width(instance::PangoGlyphStringLike) ret = ccall(("pango_glyph_string_get_width", libpango), Int32, (Ptr{_PangoGlyphString},), instance) ret end - function index_to_x(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _text::Union{AbstractString, Symbol}, _length::Integer, _analysis::Union{PangoAnalysis, Ref{_PangoAnalysis}}, _index_::Integer, _trailing::Bool) + function index_to_x(instance::PangoGlyphStringLike, _text::Union{AbstractString, Symbol}, _length::Integer, _analysis::PangoAnalysisLike, _index_::Integer, _trailing::Bool) m_x_pos = Ref{Int32}() ret = ccall(("pango_glyph_string_index_to_x", libpango), Nothing, (Ptr{_PangoGlyphString}, Cstring, Int32, Ptr{_PangoAnalysis}, Int32, Cint, Ptr{Int32}), instance, _text, _length, _analysis, _index_, _trailing, m_x_pos) _x_pos = m_x_pos[] _x_pos end - function index_to_x_full(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _text::Union{AbstractString, Symbol}, _length::Integer, _analysis::Union{PangoAnalysis, Ref{_PangoAnalysis}}, _attrs::Maybe(Union{PangoLogAttr, Ref{_PangoLogAttr}}), _index_::Integer, _trailing::Bool) + function index_to_x_full(instance::PangoGlyphStringLike, _text::Union{AbstractString, Symbol}, _length::Integer, _analysis::PangoAnalysisLike, _attrs::Maybe(PangoLogAttrLike), _index_::Integer, _trailing::Bool) _attrs_maybe = nothing_to_null(_attrs) m_x_pos = Ref{Int32}() ret = ccall(("pango_glyph_string_index_to_x_full", libpango), Nothing, (Ptr{_PangoGlyphString}, Cstring, Int32, Ptr{_PangoAnalysis}, Ptr{_PangoLogAttr}, Int32, Cint, Ptr{Int32}), instance, _text, _length, _analysis, _attrs_maybe, _index_, _trailing, m_x_pos) _x_pos = m_x_pos[] _x_pos end - function set_size(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _new_len::Integer) + function set_size(instance::PangoGlyphStringLike, _new_len::Integer) ret = ccall(("pango_glyph_string_set_size", libpango), Nothing, (Ptr{_PangoGlyphString}, Int32), instance, _new_len) nothing end - function x_to_index(instance::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _text::Union{AbstractString, Symbol}, _length::Integer, _analysis::Union{PangoAnalysis, Ref{_PangoAnalysis}}, _x_pos::Integer) + function x_to_index(instance::PangoGlyphStringLike, _text::Union{AbstractString, Symbol}, _length::Integer, _analysis::PangoAnalysisLike, _x_pos::Integer) m_index_ = Ref{Int32}() m_trailing = Ref{Int32}() ret = ccall(("pango_glyph_string_x_to_index", libpango), Nothing, (Ptr{_PangoGlyphString}, Cstring, Int32, Ptr{_PangoAnalysis}, Int32, Ptr{Int32}, Ptr{Int32}), instance, _text, _length, _analysis, _x_pos, m_index_, m_trailing) @@ -514,25 +514,25 @@ $(Expr(:toplevel, quote end function Item_new() ret = ccall(("pango_item_new", libpango), Ptr{_PangoItem}, ()) - ret2 = convert(Union{PangoItem, Ref{_PangoItem}}, ret, true) + ret2 = convert(PangoItemLike, ret, true) ret2 end - function apply_attrs(instance::Union{PangoItem, Ref{_PangoItem}}, _iter::PangoAttrIterator) + function apply_attrs(instance::PangoItemLike, _iter::PangoAttrIterator) ret = ccall(("pango_item_apply_attrs", libpango), Nothing, (Ptr{_PangoItem}, Ptr{PangoAttrIterator}), instance, _iter) nothing end - function copy(instance::Union{PangoItem, Ref{_PangoItem}}) + function copy(instance::PangoItemLike) ret = ccall(("pango_item_copy", libpango), Ptr{_PangoItem}, (Ptr{_PangoItem},), instance) ret2 = convert_if_not_null(PangoItem, ret, true) ret2 end - function free(instance::Union{PangoItem, Ref{_PangoItem}}) + function free(instance::PangoItemLike) ret = ccall(("pango_item_free", libpango), Nothing, (Ptr{_PangoItem},), instance) nothing end - function split(instance::Union{PangoItem, Ref{_PangoItem}}, _split_index::Integer, _split_offset::Integer) + function split(instance::PangoItemLike, _split_index::Integer, _split_offset::Integer) ret = ccall(("pango_item_split", libpango), Ptr{_PangoItem}, (Ptr{_PangoItem}, Int32, Int32), instance, _split_index, _split_offset) - ret2 = convert(Union{PangoItem, Ref{_PangoItem}}, ret, true) + ret2 = convert(PangoItemLike, ret, true) ret2 end function get_sample_string(instance::PangoLanguage) @@ -688,7 +688,7 @@ $(Expr(:toplevel, quote ret2 = convert(Bool, ret) ret2 end - function get_extents(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}) + function get_extents(instance::PangoLayoutLineLike) m_ink_rect = Ref{_PangoRectangle}() m_logical_rect = Ref{_PangoRectangle}() ret = ccall(("pango_layout_line_get_extents", libpango), Nothing, (Ptr{_PangoLayoutLine}, Ptr{_PangoRectangle}, Ptr{_PangoRectangle}), instance, m_ink_rect, m_logical_rect) @@ -698,17 +698,17 @@ $(Expr(:toplevel, quote _logical_rect = convert(_PangoRectangle, _logical_rect) (_ink_rect, _logical_rect) end - function get_height(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}) + function get_height(instance::PangoLayoutLineLike) m_height = Ref{Int32}() ret = ccall(("pango_layout_line_get_height", libpango), Nothing, (Ptr{_PangoLayoutLine}, Ptr{Int32}), instance, m_height) _height = m_height[] _height end - function get_length(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}) + function get_length(instance::PangoLayoutLineLike) ret = ccall(("pango_layout_line_get_length", libpango), Int32, (Ptr{_PangoLayoutLine},), instance) ret end - function get_pixel_extents(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}) + function get_pixel_extents(instance::PangoLayoutLineLike) m_ink_rect = Ref{_PangoRectangle}() m_logical_rect = Ref{_PangoRectangle}() ret = ccall(("pango_layout_line_get_pixel_extents", libpango), Nothing, (Ptr{_PangoLayoutLine}, Ptr{_PangoRectangle}, Ptr{_PangoRectangle}), instance, m_ink_rect, m_logical_rect) @@ -718,16 +718,16 @@ $(Expr(:toplevel, quote _logical_rect = convert(_PangoRectangle, _logical_rect) (_ink_rect, _logical_rect) end - function get_resolved_direction(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}) + function get_resolved_direction(instance::PangoLayoutLineLike) ret = ccall(("pango_layout_line_get_resolved_direction", libpango), UInt32, (Ptr{_PangoLayoutLine},), instance) ret2 = Direction(ret) ret2 end - function get_start_index(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}) + function get_start_index(instance::PangoLayoutLineLike) ret = ccall(("pango_layout_line_get_start_index", libpango), Int32, (Ptr{_PangoLayoutLine},), instance) ret end - function get_x_ranges(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}, _start_index::Integer, _end_index::Integer) + function get_x_ranges(instance::PangoLayoutLineLike, _start_index::Integer, _end_index::Integer) m_ranges = Ref{Ptr{Int32}}() m_n_ranges = Ref{Int32}() ret = ccall(("pango_layout_line_get_x_ranges", libpango), Nothing, (Ptr{_PangoLayoutLine}, Int32, Int32, Ptr{Ptr{Int32}}, Ptr{Int32}), instance, _start_index, _end_index, m_ranges, m_n_ranges) @@ -740,27 +740,27 @@ $(Expr(:toplevel, quote _n_ranges = m_n_ranges[] _ranges end - function index_to_x(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}, _index_::Integer, _trailing::Bool) + function index_to_x(instance::PangoLayoutLineLike, _index_::Integer, _trailing::Bool) m_x_pos = Ref{Int32}() ret = ccall(("pango_layout_line_index_to_x", libpango), Nothing, (Ptr{_PangoLayoutLine}, Int32, Cint, Ptr{Int32}), instance, _index_, _trailing, m_x_pos) _x_pos = m_x_pos[] _x_pos end - function is_paragraph_start(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}) + function is_paragraph_start(instance::PangoLayoutLineLike) ret = ccall(("pango_layout_line_is_paragraph_start", libpango), Cint, (Ptr{_PangoLayoutLine},), instance) ret2 = convert(Bool, ret) ret2 end - function ref(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}) + function ref(instance::PangoLayoutLineLike) ret = ccall(("pango_layout_line_ref", libpango), Ptr{_PangoLayoutLine}, (Ptr{_PangoLayoutLine},), instance) ret2 = convert_if_not_null(PangoLayoutLine, ret, true) ret2 end - function unref(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}) + function unref(instance::PangoLayoutLineLike) ret = ccall(("pango_layout_line_unref", libpango), Nothing, (Ptr{_PangoLayoutLine},), instance) nothing end - function x_to_index(instance::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}, _x_pos::Integer) + function x_to_index(instance::PangoLayoutLineLike, _x_pos::Integer) m_index_ = Ref{Int32}() m_trailing = Ref{Int32}() ret = ccall(("pango_layout_line_x_to_index", libpango), Cint, (Ptr{_PangoLayoutLine}, Int32, Ptr{Int32}, Ptr{Int32}), instance, _x_pos, m_index_, m_trailing) @@ -769,24 +769,24 @@ $(Expr(:toplevel, quote _trailing = m_trailing[] (ret2, _index_, _trailing) end - function concat(instance::Union{PangoMatrix, Ref{_PangoMatrix}}, _new_matrix::Union{PangoMatrix, Ref{_PangoMatrix}}) + function concat(instance::PangoMatrixLike, _new_matrix::PangoMatrixLike) ret = ccall(("pango_matrix_concat", libpango), Nothing, (Ptr{_PangoMatrix}, Ptr{_PangoMatrix}), instance, _new_matrix) nothing end - function copy(instance::Union{PangoMatrix, Ref{_PangoMatrix}}) + function copy(instance::PangoMatrixLike) ret = ccall(("pango_matrix_copy", libpango), Ptr{_PangoMatrix}, (Ptr{_PangoMatrix},), instance) ret2 = convert_if_not_null(PangoMatrix, ret, true) ret2 end - function free(instance::Union{PangoMatrix, Ref{_PangoMatrix}}) + function free(instance::PangoMatrixLike) ret = ccall(("pango_matrix_free", libpango), Nothing, (Ptr{_PangoMatrix},), instance) nothing end - function get_font_scale_factor(instance::Union{PangoMatrix, Ref{_PangoMatrix}}) + function get_font_scale_factor(instance::PangoMatrixLike) ret = ccall(("pango_matrix_get_font_scale_factor", libpango), Float64, (Ptr{_PangoMatrix},), instance) ret end - function get_font_scale_factors(instance::Union{PangoMatrix, Ref{_PangoMatrix}}) + function get_font_scale_factors(instance::PangoMatrixLike) m_xscale = Ref{Float64}() m_yscale = Ref{Float64}() ret = ccall(("pango_matrix_get_font_scale_factors", libpango), Nothing, (Ptr{_PangoMatrix}, Ptr{Float64}, Ptr{Float64}), instance, m_xscale, m_yscale) @@ -794,19 +794,19 @@ $(Expr(:toplevel, quote _yscale = m_yscale[] (_xscale, _yscale) end - function get_slant_ratio(instance::Union{PangoMatrix, Ref{_PangoMatrix}}) + function get_slant_ratio(instance::PangoMatrixLike) ret = ccall(("pango_matrix_get_slant_ratio", libpango), Float64, (Ptr{_PangoMatrix},), instance) ret end - function rotate(instance::Union{PangoMatrix, Ref{_PangoMatrix}}, _degrees::Real) + function rotate(instance::PangoMatrixLike, _degrees::Real) ret = ccall(("pango_matrix_rotate", libpango), Nothing, (Ptr{_PangoMatrix}, Float64), instance, _degrees) nothing end - function scale(instance::Union{PangoMatrix, Ref{_PangoMatrix}}, _scale_x::Real, _scale_y::Real) + function scale(instance::PangoMatrixLike, _scale_x::Real, _scale_y::Real) ret = ccall(("pango_matrix_scale", libpango), Nothing, (Ptr{_PangoMatrix}, Float64, Float64), instance, _scale_x, _scale_y) nothing end - function transform_distance(instance::Union{PangoMatrix, Ref{_PangoMatrix}}, _dx::Real, _dy::Real) + function transform_distance(instance::PangoMatrixLike, _dx::Real, _dy::Real) m_dx = Ref{Float64}() m_dx[] = Base.cconvert(Float64, _dx) m_dy = Ref{Float64}() @@ -816,7 +816,7 @@ $(Expr(:toplevel, quote _dy = m_dy[] (_dx, _dy) end - function transform_pixel_rectangle(instance::Union{PangoMatrix, Ref{_PangoMatrix}}, _rect::_PangoRectangle) + function transform_pixel_rectangle(instance::PangoMatrixLike, _rect::_PangoRectangle) m_rect = Ref{_PangoRectangle}() m_rect[] = Base.cconvert(_PangoRectangle, _rect) ret = ccall(("pango_matrix_transform_pixel_rectangle", libpango), Nothing, (Ptr{_PangoMatrix}, Ptr{_PangoRectangle}), instance, m_rect) @@ -824,7 +824,7 @@ $(Expr(:toplevel, quote _rect = convert(_PangoRectangle, _rect) _rect end - function transform_point(instance::Union{PangoMatrix, Ref{_PangoMatrix}}, _x::Real, _y::Real) + function transform_point(instance::PangoMatrixLike, _x::Real, _y::Real) m_x = Ref{Float64}() m_x[] = Base.cconvert(Float64, _x) m_y = Ref{Float64}() @@ -834,7 +834,7 @@ $(Expr(:toplevel, quote _y = m_y[] (_x, _y) end - function transform_rectangle(instance::Union{PangoMatrix, Ref{_PangoMatrix}}, _rect::_PangoRectangle) + function transform_rectangle(instance::PangoMatrixLike, _rect::_PangoRectangle) m_rect = Ref{_PangoRectangle}() m_rect[] = Base.cconvert(_PangoRectangle, _rect) ret = ccall(("pango_matrix_transform_rectangle", libpango), Nothing, (Ptr{_PangoMatrix}, Ptr{_PangoRectangle}), instance, m_rect) @@ -842,7 +842,7 @@ $(Expr(:toplevel, quote _rect = convert(_PangoRectangle, _rect) _rect end - function translate(instance::Union{PangoMatrix, Ref{_PangoMatrix}}, _tx::Real, _ty::Real) + function translate(instance::PangoMatrixLike, _tx::Real, _ty::Real) ret = ccall(("pango_matrix_translate", libpango), Nothing, (Ptr{_PangoMatrix}, Float64, Float64), instance, _tx, _ty) nothing end @@ -987,7 +987,7 @@ $(Expr(:toplevel, quote _desc_maybe = nothing_to_null(_desc) _language_maybe = nothing_to_null(_language) ret = ccall(("pango_context_get_metrics", libpango), Ptr{_PangoFontMetrics}, (Ptr{GObject}, Ptr{PangoFontDescription}, Ptr{PangoLanguage}), instance, _desc_maybe, _language_maybe) - ret2 = convert(Union{PangoFontMetrics, Ref{_PangoFontMetrics}}, ret, true) + ret2 = convert(PangoFontMetricsLike, ret, true) ret2 end function get_round_glyph_positions(instance::PangoContext) @@ -1049,7 +1049,7 @@ $(Expr(:toplevel, quote ret = ccall(("pango_context_set_language", libpango), Nothing, (Ptr{GObject}, Ptr{PangoLanguage}), instance, _language_maybe) nothing end - function set_matrix(instance::PangoContext, _matrix::Maybe(Union{PangoMatrix, Ref{_PangoMatrix}})) + function set_matrix(instance::PangoContext, _matrix::Maybe(PangoMatrixLike)) _matrix_maybe = nothing_to_null(_matrix) ret = ccall(("pango_context_set_matrix", libpango), Nothing, (Ptr{GObject}, Ptr{_PangoMatrix}), instance, _matrix_maybe) nothing @@ -1128,7 +1128,7 @@ $(Expr(:toplevel, quote function get_metrics(instance::PangoFont, _language::Maybe(PangoLanguage)) _language_maybe = nothing_to_null(_language) ret = ccall(("pango_font_get_metrics", libpango), Ptr{_PangoFontMetrics}, (Ptr{GObject}, Ptr{PangoLanguage}), instance, _language_maybe) - ret2 = convert(Union{PangoFontMetrics, Ref{_PangoFontMetrics}}, ret, true) + ret2 = convert(PangoFontMetricsLike, ret, true) ret2 end function has_char(instance::PangoFont, _wc) @@ -1291,7 +1291,7 @@ $(Expr(:toplevel, quote end function get_metrics(instance::PangoFontset) ret = ccall(("pango_fontset_get_metrics", libpango), Ptr{_PangoFontMetrics}, (Ptr{GObject},), instance) - ret2 = convert(Union{PangoFontMetrics, Ref{_PangoFontMetrics}}, ret, true) + ret2 = convert(PangoFontMetricsLike, ret, true) ret2 end function FontsetSimple_new(_language::PangoLanguage) @@ -1682,12 +1682,12 @@ $(Expr(:toplevel, quote ret = ccall(("pango_renderer_draw_glyph", libpango), Nothing, (Ptr{GObject}, Ptr{GObject}, UInt32, Float64, Float64), instance, _font, _glyph, _x, _y) nothing end - function draw_glyph_item(instance::PangoRenderer, _text::Maybe(Union{AbstractString, Symbol}), _glyph_item::Union{PangoGlyphItem, Ref{_PangoGlyphItem}}, _x::Integer, _y::Integer) + function draw_glyph_item(instance::PangoRenderer, _text::Maybe(Union{AbstractString, Symbol}), _glyph_item::PangoGlyphItemLike, _x::Integer, _y::Integer) _text_maybe = nothing_to_null(_text) ret = ccall(("pango_renderer_draw_glyph_item", libpango), Nothing, (Ptr{GObject}, Cstring, Ptr{_PangoGlyphItem}, Int32, Int32), instance, _text_maybe, _glyph_item, _x, _y) nothing end - function draw_glyphs(instance::PangoRenderer, _font::PangoFont, _glyphs::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _x::Integer, _y::Integer) + function draw_glyphs(instance::PangoRenderer, _font::PangoFont, _glyphs::PangoGlyphStringLike, _x::Integer, _y::Integer) ret = ccall(("pango_renderer_draw_glyphs", libpango), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{_PangoGlyphString}, Int32, Int32), instance, _font, _glyphs, _x, _y) nothing end @@ -1695,7 +1695,7 @@ $(Expr(:toplevel, quote ret = ccall(("pango_renderer_draw_layout", libpango), Nothing, (Ptr{GObject}, Ptr{GObject}, Int32, Int32), instance, _layout, _x, _y) nothing end - function draw_layout_line(instance::PangoRenderer, _line::Union{PangoLayoutLine, Ref{_PangoLayoutLine}}, _x::Integer, _y::Integer) + function draw_layout_line(instance::PangoRenderer, _line::PangoLayoutLineLike, _x::Integer, _y::Integer) ret = ccall(("pango_renderer_draw_layout_line", libpango), Nothing, (Ptr{GObject}, Ptr{_PangoLayoutLine}, Int32, Int32), instance, _line, _x, _y) nothing end @@ -1739,12 +1739,12 @@ $(Expr(:toplevel, quote ret = ccall(("pango_renderer_set_alpha", libpango), Nothing, (Ptr{GObject}, UInt32, UInt16), instance, _part, _alpha) nothing end - function set_color(instance::PangoRenderer, _part, _color::Maybe(Union{PangoColor, Ref{_PangoColor}})) + function set_color(instance::PangoRenderer, _part, _color::Maybe(PangoColorLike)) _color_maybe = nothing_to_null(_color) ret = ccall(("pango_renderer_set_color", libpango), Nothing, (Ptr{GObject}, UInt32, Ptr{_PangoColor}), instance, _part, _color_maybe) nothing end - function set_matrix(instance::PangoRenderer, _matrix::Maybe(Union{PangoMatrix, Ref{_PangoMatrix}})) + function set_matrix(instance::PangoRenderer, _matrix::Maybe(PangoMatrixLike)) _matrix_maybe = nothing_to_null(_matrix) ret = ccall(("pango_renderer_set_matrix", libpango), Nothing, (Ptr{GObject}, Ptr{_PangoMatrix}), instance, _matrix_maybe) nothing diff --git a/src/gen/pango_structs b/src/gen/pango_structs index d61c554f..961b2d13 100644 --- a/src/gen/pango_structs +++ b/src/gen/pango_structs @@ -1,23 +1,26 @@ quote $(Expr(:toplevel, quote const gboxed_types = Any[] - mutable struct PangoLanguage <: GBoxed - handle::Ptr{PangoLanguage} - begin - (GLib.g_type(::Type{T}) where T <: PangoLanguage) = begin - ccall(("pango_language_get_type", libpango), GType, ()) - end - function PangoLanguage(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct PangoLanguage <: GBoxed + handle::Ptr{PangoLanguage} + begin + (GLib.g_type(::Type{T}) where T <: PangoLanguage) = begin + ccall(("pango_language_get_type", libpango), GType, ()) + end + function PangoLanguage(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, PangoLanguage) end - push!(gboxed_types, PangoLanguage) end + const PangoLanguageLike = PangoLanguage end begin struct _PangoColor @@ -50,6 +53,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoColor}, p::Ptr{_PangoColor}, owns = false) = begin PangoColor(p, owns) end + const PangoColorLike = Union{Ref{_PangoColor}, PangoColor} end end begin @@ -69,6 +73,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrClass}, p::Ptr{_PangoAttrClass}, owns = false) = begin PangoAttrClass(p, owns) end + const PangoAttrClassLike = Union{Ref{_PangoAttrClass}, PangoAttrClass} end end begin @@ -88,25 +93,29 @@ $(Expr(:toplevel, quote convert(::Type{PangoRectangle}, p::Ptr{_PangoRectangle}, owns = false) = begin PangoRectangle(p, owns) end + const PangoRectangleLike = Union{Ref{_PangoRectangle}, PangoRectangle} end end - mutable struct PangoFontDescription <: GBoxed - handle::Ptr{PangoFontDescription} - begin - (GLib.g_type(::Type{T}) where T <: PangoFontDescription) = begin - ccall(("pango_font_description_get_type", libpango), GType, ()) - end - function PangoFontDescription(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct PangoFontDescription <: GBoxed + handle::Ptr{PangoFontDescription} + begin + (GLib.g_type(::Type{T}) where T <: PangoFontDescription) = begin + ccall(("pango_font_description_get_type", libpango), GType, ()) end + function PangoFontDescription(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, PangoFontDescription) end - push!(gboxed_types, PangoFontDescription) end + const PangoFontDescriptionLike = PangoFontDescription end begin struct _PangoAttribute @@ -139,6 +148,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttribute}, p::Ptr{_PangoAttribute}, owns = false) = begin PangoAttribute(p, owns) end + const PangoAttributeLike = Union{Ref{_PangoAttribute}, PangoAttribute} end end begin @@ -163,6 +173,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAnalysis}, p::Ptr{_PangoAnalysis}, owns = false) = begin PangoAnalysis(p, owns) end + const PangoAnalysisLike = Union{Ref{_PangoAnalysis}, PangoAnalysis} end end begin @@ -197,6 +208,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoItem}, p::Ptr{_PangoItem}, owns = false) = begin PangoItem(p, owns) end + const PangoItemLike = Union{Ref{_PangoItem}, PangoItem} end end begin @@ -214,6 +226,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoGlyphVisAttr}, p::Ptr{_PangoGlyphVisAttr}, owns = false) = begin PangoGlyphVisAttr(p, owns) end + const PangoGlyphVisAttrLike = Union{Ref{_PangoGlyphVisAttr}, PangoGlyphVisAttr} end end begin @@ -232,6 +245,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoGlyphGeometry}, p::Ptr{_PangoGlyphGeometry}, owns = false) = begin PangoGlyphGeometry(p, owns) end + const PangoGlyphGeometryLike = Union{Ref{_PangoGlyphGeometry}, PangoGlyphGeometry} end end begin @@ -250,6 +264,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoGlyphInfo}, p::Ptr{_PangoGlyphInfo}, owns = false) = begin PangoGlyphInfo(p, owns) end + const PangoGlyphInfoLike = Union{Ref{_PangoGlyphInfo}, PangoGlyphInfo} end end begin @@ -284,6 +299,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoGlyphString}, p::Ptr{_PangoGlyphString}, owns = false) = begin PangoGlyphString(p, owns) end + const PangoGlyphStringLike = Union{Ref{_PangoGlyphString}, PangoGlyphString} end end begin @@ -319,6 +335,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoGlyphItem}, p::Ptr{_PangoGlyphItem}, owns = false) = begin PangoGlyphItem(p, owns) end + const PangoGlyphItemLike = Union{Ref{_PangoGlyphItem}, PangoGlyphItem} end end begin @@ -336,6 +353,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrColor}, p::Ptr{_PangoAttrColor}, owns = false) = begin PangoAttrColor(p, owns) end + const PangoAttrColorLike = Union{Ref{_PangoAttrColor}, PangoAttrColor} end end begin @@ -353,6 +371,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrFloat}, p::Ptr{_PangoAttrFloat}, owns = false) = begin PangoAttrFloat(p, owns) end + const PangoAttrFloatLike = Union{Ref{_PangoAttrFloat}, PangoAttrFloat} end end begin @@ -370,6 +389,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrFontDesc}, p::Ptr{_PangoAttrFontDesc}, owns = false) = begin PangoAttrFontDesc(p, owns) end + const PangoAttrFontDescLike = Union{Ref{_PangoAttrFontDesc}, PangoAttrFontDesc} end end begin @@ -387,6 +407,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrFontFeatures}, p::Ptr{_PangoAttrFontFeatures}, owns = false) = begin PangoAttrFontFeatures(p, owns) end + const PangoAttrFontFeaturesLike = Union{Ref{_PangoAttrFontFeatures}, PangoAttrFontFeatures} end end begin @@ -404,25 +425,29 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrInt}, p::Ptr{_PangoAttrInt}, owns = false) = begin PangoAttrInt(p, owns) end + const PangoAttrIntLike = Union{Ref{_PangoAttrInt}, PangoAttrInt} end end - mutable struct PangoAttrIterator <: GBoxed - handle::Ptr{PangoAttrIterator} - begin - (GLib.g_type(::Type{T}) where T <: PangoAttrIterator) = begin - ccall(("pango_attr_iterator_get_type", libpango), GType, ()) - end - function PangoAttrIterator(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct PangoAttrIterator <: GBoxed + handle::Ptr{PangoAttrIterator} + begin + (GLib.g_type(::Type{T}) where T <: PangoAttrIterator) = begin + ccall(("pango_attr_iterator_get_type", libpango), GType, ()) end + function PangoAttrIterator(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, PangoAttrIterator) end - push!(gboxed_types, PangoAttrIterator) end + const PangoAttrIteratorLike = PangoAttrIterator end begin struct _PangoAttrLanguage @@ -439,25 +464,29 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrLanguage}, p::Ptr{_PangoAttrLanguage}, owns = false) = begin PangoAttrLanguage(p, owns) end + const PangoAttrLanguageLike = Union{Ref{_PangoAttrLanguage}, PangoAttrLanguage} end end - mutable struct PangoAttrList <: GBoxed - handle::Ptr{PangoAttrList} - begin - (GLib.g_type(::Type{T}) where T <: PangoAttrList) = begin - ccall(("pango_attr_list_get_type", libpango), GType, ()) - end - function PangoAttrList(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct PangoAttrList <: GBoxed + handle::Ptr{PangoAttrList} + begin + (GLib.g_type(::Type{T}) where T <: PangoAttrList) = begin + ccall(("pango_attr_list_get_type", libpango), GType, ()) + end + function PangoAttrList(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, PangoAttrList) end - push!(gboxed_types, PangoAttrList) end + const PangoAttrListLike = PangoAttrList end begin struct _PangoAttrShape @@ -478,6 +507,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrShape}, p::Ptr{_PangoAttrShape}, owns = false) = begin PangoAttrShape(p, owns) end + const PangoAttrShapeLike = Union{Ref{_PangoAttrShape}, PangoAttrShape} end end begin @@ -496,6 +526,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrSize}, p::Ptr{_PangoAttrSize}, owns = false) = begin PangoAttrSize(p, owns) end + const PangoAttrSizeLike = Union{Ref{_PangoAttrSize}, PangoAttrSize} end end begin @@ -513,6 +544,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoAttrString}, p::Ptr{_PangoAttrString}, owns = false) = begin PangoAttrString(p, owns) end + const PangoAttrStringLike = Union{Ref{_PangoAttrString}, PangoAttrString} end end begin @@ -553,6 +585,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoFontMetrics}, p::Ptr{_PangoFontMetrics}, owns = false) = begin PangoFontMetrics(p, owns) end + const PangoFontMetricsLike = Union{Ref{_PangoFontMetrics}, PangoFontMetrics} end end begin @@ -591,25 +624,29 @@ $(Expr(:toplevel, quote convert(::Type{PangoGlyphItemIter}, p::Ptr{_PangoGlyphItemIter}, owns = false) = begin PangoGlyphItemIter(p, owns) end + const PangoGlyphItemIterLike = Union{Ref{_PangoGlyphItemIter}, PangoGlyphItemIter} end end - mutable struct PangoLayoutIter <: GBoxed - handle::Ptr{PangoLayoutIter} - begin - (GLib.g_type(::Type{T}) where T <: PangoLayoutIter) = begin - ccall(("pango_layout_iter_get_type", libpango), GType, ()) - end - function PangoLayoutIter(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct PangoLayoutIter <: GBoxed + handle::Ptr{PangoLayoutIter} + begin + (GLib.g_type(::Type{T}) where T <: PangoLayoutIter) = begin + ccall(("pango_layout_iter_get_type", libpango), GType, ()) + end + function PangoLayoutIter(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, PangoLayoutIter) end - push!(gboxed_types, PangoLayoutIter) end + const PangoLayoutIterLike = PangoLayoutIter end begin struct _PangoLayoutLine @@ -645,6 +682,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoLayoutLine}, p::Ptr{_PangoLayoutLine}, owns = false) = begin PangoLayoutLine(p, owns) end + const PangoLayoutLineLike = Union{Ref{_PangoLayoutLine}, PangoLayoutLine} end end begin @@ -676,6 +714,7 @@ $(Expr(:toplevel, quote convert(::Type{PangoLogAttr}, p::Ptr{_PangoLogAttr}, owns = false) = begin PangoLogAttr(p, owns) end + const PangoLogAttrLike = Union{Ref{_PangoLogAttr}, PangoLogAttr} end end begin @@ -712,43 +751,50 @@ $(Expr(:toplevel, quote convert(::Type{PangoMatrix}, p::Ptr{_PangoMatrix}, owns = false) = begin PangoMatrix(p, owns) end + const PangoMatrixLike = Union{Ref{_PangoMatrix}, PangoMatrix} end end - mutable struct PangoScriptIter <: GBoxed - handle::Ptr{PangoScriptIter} - begin - (GLib.g_type(::Type{T}) where T <: PangoScriptIter) = begin - ccall(("pango_script_iter_get_type", libpango), GType, ()) - end - function PangoScriptIter(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct PangoScriptIter <: GBoxed + handle::Ptr{PangoScriptIter} + begin + (GLib.g_type(::Type{T}) where T <: PangoScriptIter) = begin + ccall(("pango_script_iter_get_type", libpango), GType, ()) end + function PangoScriptIter(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end + end + x end - x + push!(gboxed_types, PangoScriptIter) end - push!(gboxed_types, PangoScriptIter) end + const PangoScriptIterLike = PangoScriptIter end - mutable struct PangoTabArray <: GBoxed - handle::Ptr{PangoTabArray} - begin - (GLib.g_type(::Type{T}) where T <: PangoTabArray) = begin - ccall(("pango_tab_array_get_type", libpango), GType, ()) - end - function PangoTabArray(ref::Ptr{T}, own::Bool = false) where T <: GBoxed - x = new(ref) - if own - finalizer(x) do x - GLib.delboxed(x) + begin + mutable struct PangoTabArray <: GBoxed + handle::Ptr{PangoTabArray} + begin + (GLib.g_type(::Type{T}) where T <: PangoTabArray) = begin + ccall(("pango_tab_array_get_type", libpango), GType, ()) + end + function PangoTabArray(ref::Ptr{T}, own::Bool = false) where T <: GBoxed + x = new(ref) + if own + finalizer(x) do x + GLib.delboxed(x) + end end + x end - x + push!(gboxed_types, PangoTabArray) end - push!(gboxed_types, PangoTabArray) end + const PangoTabArrayLike = PangoTabArray end gboxed_cache_init() = begin append!(GLib.gboxed_types, gboxed_types) @@ -1037,7 +1083,7 @@ $(Expr(:toplevel, quote convert(Ptr{Nothing}, ret) end function PangoAttrFilterFunc(attribute, user_data) - attribute = convert(Union{PangoAttribute, Ref{_PangoAttribute}}, attribute, false) + attribute = convert(PangoAttributeLike, attribute, false) f = user_data ret = f(attribute) convert(Cint, ret) @@ -1049,6 +1095,6 @@ $(Expr(:toplevel, quote ret = f(fontset, font) convert(Cint, ret) end - export PangoLanguage, PangoColor, _PangoColor, PangoAttrClass, _PangoAttrClass, PangoRectangle, _PangoRectangle, PangoFontDescription, PangoAttribute, _PangoAttribute, PangoAnalysis, _PangoAnalysis, PangoItem, _PangoItem, PangoGlyphVisAttr, _PangoGlyphVisAttr, PangoGlyphGeometry, _PangoGlyphGeometry, PangoGlyphInfo, _PangoGlyphInfo, PangoGlyphString, _PangoGlyphString, PangoGlyphItem, _PangoGlyphItem, PangoAttrColor, _PangoAttrColor, PangoAttrFloat, _PangoAttrFloat, PangoAttrFontDesc, _PangoAttrFontDesc, PangoAttrFontFeatures, _PangoAttrFontFeatures, PangoAttrInt, _PangoAttrInt, PangoAttrIterator, PangoAttrLanguage, _PangoAttrLanguage, PangoAttrList, PangoAttrShape, _PangoAttrShape, PangoAttrSize, _PangoAttrSize, PangoAttrString, _PangoAttrString, PangoFontMetrics, _PangoFontMetrics, PangoGlyphItemIter, _PangoGlyphItemIter, PangoLayoutIter, PangoLayoutLine, _PangoLayoutLine, PangoLogAttr, _PangoLogAttr, PangoMatrix, _PangoMatrix, PangoScriptIter, PangoTabArray, PangoContext, PangoContextLeaf, PangoCoverage, PangoCoverageLeaf, PangoFont, PangoFontFace, PangoFontFamily, PangoFontMap, PangoFontset, PangoFontsetSimple, PangoFontsetSimpleLeaf, PangoLayout, PangoLayoutLeaf, PangoRenderer, PangoAttrDataCopyFunc, PangoAttrFilterFunc, PangoFontsetForeachFunc + export PangoLanguage, PangoColor, _PangoColor, PangoColorLike, PangoAttrClass, _PangoAttrClass, PangoAttrClassLike, PangoRectangle, _PangoRectangle, PangoRectangleLike, PangoFontDescription, PangoAttribute, _PangoAttribute, PangoAttributeLike, PangoAnalysis, _PangoAnalysis, PangoAnalysisLike, PangoItem, _PangoItem, PangoItemLike, PangoGlyphVisAttr, _PangoGlyphVisAttr, PangoGlyphVisAttrLike, PangoGlyphGeometry, _PangoGlyphGeometry, PangoGlyphGeometryLike, PangoGlyphInfo, _PangoGlyphInfo, PangoGlyphInfoLike, PangoGlyphString, _PangoGlyphString, PangoGlyphStringLike, PangoGlyphItem, _PangoGlyphItem, PangoGlyphItemLike, PangoAttrColor, PangoAttrColorLike, _PangoAttrColor, PangoAttrFloat, PangoAttrFloatLike, _PangoAttrFloat, PangoAttrFontDesc, PangoAttrFontDescLike, _PangoAttrFontDesc, PangoAttrFontFeatures, PangoAttrFontFeaturesLike, _PangoAttrFontFeatures, PangoAttrInt, PangoAttrIntLike, _PangoAttrInt, PangoAttrIterator, PangoAttrLanguage, PangoAttrLanguageLike, _PangoAttrLanguage, PangoAttrList, PangoAttrShape, PangoAttrShapeLike, _PangoAttrShape, PangoAttrSize, PangoAttrSizeLike, _PangoAttrSize, PangoAttrString, PangoAttrStringLike, _PangoAttrString, PangoFontMetrics, PangoFontMetricsLike, _PangoFontMetrics, PangoGlyphItemIter, PangoGlyphItemIterLike, _PangoGlyphItemIter, PangoLayoutIter, PangoLayoutLine, PangoLayoutLineLike, _PangoLayoutLine, PangoLogAttr, PangoLogAttrLike, _PangoLogAttr, PangoMatrix, PangoMatrixLike, _PangoMatrix, PangoScriptIter, PangoTabArray, PangoContext, PangoContextLeaf, PangoCoverage, PangoCoverageLeaf, PangoFont, PangoFontFace, PangoFontFamily, PangoFontMap, PangoFontset, PangoFontsetSimple, PangoFontsetSimpleLeaf, PangoLayout, PangoLayoutLeaf, PangoRenderer, PangoAttrDataCopyFunc, PangoAttrFilterFunc, PangoFontsetForeachFunc end)) end diff --git a/src/gen/pangocairo_structs b/src/gen/pangocairo_structs index 53eeedf7..e5af5c5e 100644 --- a/src/gen/pangocairo_structs +++ b/src/gen/pangocairo_structs @@ -16,7 +16,7 @@ $(Expr(:toplevel, quote end function PangoCairoShapeRendererFunc(cr, attr, do_path, data) cr = convert(cairoContext, cr, false) - attr = convert(Union{PangoAttrShape, Ref{_PangoAttrShape}}, attr) + attr = convert(PangoAttrShapeLike, attr) do_path = convert(Bool, do_path) f = data ret = f(cr, attr, do_path) diff --git a/src/text.jl b/src/text.jl index 3d0f2345..8bb9ebef 100644 --- a/src/text.jl +++ b/src/text.jl @@ -34,14 +34,11 @@ end show(io::IO, iter::_GtkTextIter) = println("_GtkTextIter($(iter.offset) ))") -""" - buffer(iter::Union{Ref{_GtkTextIter}, GtkTextIter}) - -Returns the buffer associated with `iter`. -""" -buffer(iter::TI) = convert(GtkTextBuffer, - ccall((:gtk_text_iter_get_buffer, libgtk4),Ptr{GtkTextBuffer},(Ref{_GtkTextIter},),iter) -) +#""" +# buffer(iter::Union{Ref{_GtkTextIter}, GtkTextIter}) +# +#Returns the buffer associated with `iter`. +#""" """ char_offset(iter::Union{Ref{_GtkTextIter}, GtkTextIter}) @@ -65,49 +62,49 @@ end function getproperty(text::TI, key::Symbol) Base.in(key, fieldnames(typeof(text))) && return getfield(text, key) if key === :offset - ccall((:gtk_text_iter_get_offset, libgtk4), Cint, (Ptr{_GtkTextIter},), text) + G_.get_offset(text) elseif key === :line - ccall((:gtk_text_iter_get_line, libgtk4), Cint, (Ptr{_GtkTextIter},), text) + G_.get_line(text) elseif key === :line_offset - ccall((:gtk_text_iter_get_line_offset, libgtk4), Cint, (Ptr{_GtkTextIter},), text) + G_.get_line_offset(text) elseif key === :line_index - ccall((:gtk_text_iter_get_line_index, libgtk4), Cint, (Ptr{_GtkTextIter},), text) + G_.get_line_index(text) elseif key === :visible_line_index - ccall((:gtk_text_iter_get_visible_line_index, libgtk4), Cint, (Ptr{_GtkTextIter},), text) + G_.get_visible_line_index(text) elseif key === :visible_line_offset - ccall((:gtk_text_iter_get_visible_line_offset, libgtk4), Cint, (Ptr{_GtkTextIter},), text) + G_.get_visible_line_offset(text) elseif key === :marks - ccall((:gtk_text_iter_get_marks, libgtk4), Ptr{_GSList{GtkTextMark}}, (Ptr{_GtkTextIter},), text) # GtkTextMark iter + G_.get_marks(text) elseif key === :toggled_on_tags - ccall((:gtk_text_iter_get_toggled_tags, libgtk4), Ptr{_GSList{GtkTextTag}}, (Ptr{_GtkTextIter}, Cint), text, true) # GtkTextTag iter + G_.get_toggled_tags(text, true) elseif key === :toggled_off_tags - ccall((:gtk_text_iter_get_toggled_tags, libgtk4), Ptr{_GSList{GtkTextTag}}, (Ptr{_GtkTextIter}, Cint), text, false) # GtkTextTag iter + G_.get_toggled_tags(text, false) # elseif key === :child_anchor # convert(GtkTextChildAnchor, ccall((:gtk_text_iter_get_child_anchor, libgtk4), Ptr{GtkTextChildAnchor}, (Ptr{_GtkTextIter}, Cint), text, false)) elseif key === :can_insert - Bool(ccall((:gtk_text_iter_can_insert, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), text, true)) + G_.can_insert(text, true) elseif key === :starts_word - Bool(ccall((:gtk_text_iter_starts_word, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.starts_word(text) elseif key === :ends_word - Bool(ccall((:gtk_text_iter_ends_word, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.ends_word(text) elseif key === :inside_word - Bool(ccall((:gtk_text_iter_inside_word, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.inside_word(text) elseif key === :starts_line - Bool(ccall((:gtk_text_iter_starts_line, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.starts_line(text) elseif key === :ends_line - Bool(ccall((:gtk_text_iter_ends_line, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.ends_line(text) elseif key === :starts_sentence - Bool(ccall((:gtk_text_iter_starts_sentence, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.starts_sentence(text) elseif key === :ends_sentence - Bool(ccall((:gtk_text_iter_ends_sentence, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.ends_sentence(text) elseif key === :inside_sentence - Bool(ccall((:gtk_text_iter_inside_sentence, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.inside_sentence(text) elseif key === :is_cursor_position - Bool(ccall((:gtk_text_iter_is_cursor_position, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.is_cursor_position(text) elseif key === :chars_in_line - ccall((:gtk_text_iter_get_chars_in_line, libgtk4), Cint, (Ptr{_GtkTextIter},), text) + G_.get_chars_in_line(text) elseif key === :bytes_in_line - ccall((:gtk_text_iter_get_bytes_in_line, libgtk4), Cint, (Ptr{_GtkTextIter},), text) + G_.get_bytes_in_line(text) # elseif key === :attributes # view = get_gtk_property(text, :view)::GtkTextView # attrs = get_gtk_property(view, :default_attributes)::GtkTextAttributes @@ -116,9 +113,9 @@ function getproperty(text::TI, key::Symbol) # elseif key === :language # ccall((:gtk_text_iter_get_language, libgtk4), Ptr{PangoLanguage}, (Ptr{_GtkTextIter}, Ptr{GtkTextAttributes}), text) elseif key === :is_end - Bool(ccall((:gtk_text_iter_is_end, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.is_end(text) elseif key === :is_start - Bool(ccall((:gtk_text_iter_is_start, libgtk4), Cint, (Ptr{_GtkTextIter},), text)) + G_.is_start(text) elseif key === :char convert(Char, ccall((:gtk_text_iter_get_char, libgtk4), UInt32, (Ptr{_GtkTextIter},), text)) elseif key === :pixbuf @@ -132,17 +129,17 @@ end function setproperty!(text::TI, key::Symbol, value) Base.in(key, fieldnames(typeof(text))) && return setfield!(text, key, value) if key === :offset - ccall((:gtk_text_iter_set_offset, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), text, value) + G_.set_offset(text, value) elseif key === :line - ccall((:gtk_text_iter_set_line, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), text, value) + G_.set_line(text, value) elseif key === :line_offset - ccall((:gtk_text_iter_set_line_offset, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), text, value) + G_.set_line_offset(text, value) elseif key === :line_index - ccall((:gtk_text_iter_set_line_index, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), text, value) + G_.set_line_index(text, value) elseif key === :visible_line_index - ccall((:gtk_text_iter_set_visible_line_index, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), text, value) + G_.set_visible_line_index(text, value) elseif key === :visible_line_offset - ccall((:gtk_text_iter_set_visible_line_offset, libgtk4), Cint, (Ptr{_GtkTextIter}, Cint), text, value) + G_.set_visible_line_offset(text, value) else @warn "_GtkTextIter doesn't have attribute with key $key" false @@ -150,16 +147,11 @@ function setproperty!(text::TI, key::Symbol, value) return text end -Base.:(==)(lhs::TI, rhs::TI) = Bool(ccall((:gtk_text_iter_equal, libgtk4), - Cint, (Ref{_GtkTextIter}, Ref{_GtkTextIter}), lhs, rhs)) -Base.:(<)(lhs::TI, rhs::TI) = ccall((:gtk_text_iter_compare, libgtk4), Cint, - (Ref{_GtkTextIter}, Ref{_GtkTextIter}), lhs, rhs) < 0 -Base.:(<=)(lhs::TI, rhs::TI) = ccall((:gtk_text_iter_compare, libgtk4), Cint, - (Ref{_GtkTextIter}, Ref{_GtkTextIter}), lhs, rhs) <= 0 -Base.:(>)(lhs::TI, rhs::TI) = ccall((:gtk_text_iter_compare, libgtk4), Cint, - (Ref{_GtkTextIter}, Ref{_GtkTextIter}), lhs, rhs) > 0 -Base.:(>=)(lhs::TI, rhs::TI) = ccall((:gtk_text_iter_compare, libgtk4), Cint, - (Ref{_GtkTextIter}, Ref{_GtkTextIter}), lhs, rhs) >= 0 +Base.:(==)(lhs::TI, rhs::TI) = G_.equal(lhs, rhs) +Base.:(<)(lhs::TI, rhs::TI) = G_.compare(lhs, rhs) < 0 +Base.:(<=)(lhs::TI, rhs::TI) = G_.compare(lhs, rhs) <= 0 +Base.:(>)(lhs::TI, rhs::TI) = G_.compare(lhs, rhs) > 0 +Base.:(>=)(lhs::TI, rhs::TI) = G_.compare(lhs, rhs) >= 0 start_(iter::TI) = Ref(iter) iterate(::TI, iter=start_(iter)) = iter.is_end ? nothing : (iter.char, iter + 1) @@ -173,9 +165,7 @@ Base.:-(iter::TI, count::Integer) = (iter = copy(iter); skip(iter, -count); iter Moves `iter` `count` characters. Returns a Bool indicating if the move was successful. """ -Base.skip(iter::TI, count::Integer) = - Bool(ccall((:gtk_text_iter_forward_chars, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) +Base.skip(iter::TI, count::Integer) = G_.forward_chars(iter, count) """ skip(iter::Ref{_GtkTextIter}, what::Symbol) @@ -193,26 +183,19 @@ Operations are : """ function Base.skip(iter::TI, what::Symbol) if what === :backward_line - Bool(ccall((:gtk_text_iter_backward_line, libgtk4), Cint, - (Ptr{_GtkTextIter},), iter)) + G_.backward_line(iter) elseif what === :forward_line - Bool(ccall((:gtk_text_iter_forward_line, libgtk4), Cint, - (Ptr{_GtkTextIter},), iter)) + G_.forward_line(iter) elseif what === :forward_to_line_end - Bool(ccall((:gtk_text_iter_forward_to_line_end, libgtk4), Cint, - (Ptr{_GtkTextIter},), iter)) + G_.forward_to_line_end(iter) elseif what === :forward_word_end - Bool(ccall((:gtk_text_iter_forward_word_end, libgtk4), Cint, - (Ptr{_GtkTextIter},), iter)) + G_.forward_word_end(iter) elseif what === :backward_word_start - Bool(ccall((:gtk_text_iter_backward_word_start, libgtk4), Cint, - (Ptr{_GtkTextIter},), iter)) + G_.backward_word_start(iter) elseif what === :backward_sentence_start - Bool(ccall((:gtk_text_iter_backward_sentence_start, libgtk4), Cint, - (Ptr{_GtkTextIter},), iter)) + G_.backward_sentence_start(iter) elseif what === :forward_sentence_end - Bool(ccall((:gtk_text_iter_forward_sentence_end, libgtk4), Cint, - (Ptr{_GtkTextIter},), iter)) + G_.forward_sentence_end(iter) else @warn "_GtkTextIter doesn't have iterator of type $what" false @@ -239,34 +222,25 @@ Operations are : """ function Base.skip(iter::TI, count::Integer, what::Symbol) if what === :char || what === :chars - Bool(ccall((:gtk_text_iter_forward_chars, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) + G_.forward_chars(iter, count) elseif what === :line || what === :lines - Bool(ccall((:gtk_text_iter_forward_lines, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) + G_.forward_lines(iter, count) elseif what === :word || what === :words - Bool(ccall((:gtk_text_iter_forward_word_ends, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) + G_.forward_word_ends(iter, count) elseif what === :word_cursor_position || what === :word_cursor_positions - Bool(ccall((:gtk_text_iter_forward_cursor_positions, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) + G_.forward_cursor_positions(iter, count) elseif what === :sentence || what === :sentences - Bool(ccall((:gtk_text_iter_forward_sentence_ends, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) + G_.forward_sentence_ends(iter, count) elseif what === :visible_word || what === :visible_words - Bool(ccall((:gtk_text_iter_forward_visible_word_ends, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) + G_.forward_visible_word_ends(iter, count) elseif what === :visible_cursor_position || what === :visible_cursor_positions - Bool(ccall((:gtk_text_iter_forward_visible_cursor_positions, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) + G_.forward_visible_cursor_positions(iter, count) elseif what === :visible_line || what === :visible_lines - Bool(ccall((:gtk_text_iter_forward_visible_lines, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) + G_.forward_visible_lines(iter, count) elseif what === :line_end || what === :line_ends count >= 0 || error("_GtkTextIter cannot iterate line_ends backwards") for i = 1:count - if !Bool(ccall((:gtk_text_iter_forward_visible_lines, libgtk4), Cint, - (Ptr{_GtkTextIter}, Cint), iter, count)) + if !G_.forward_visible_lines(iter,count) return false end end @@ -297,11 +271,11 @@ function forward_search(iter::TI, str::AbstractString, start::Ref{_GtkTextIter}, stop::Ref{_GtkTextIter}, limit::Ref{_GtkTextIter}, flag) - Bool(ccall((:gtk_text_iter_forward_search, libgtk4), - Cint, - (Ptr{_GtkTextIter}, Ptr{UInt8}, Cuint, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), - iter, string(str), flag, start, stop, limit - )) + found, start_out, stop_out = G_.forward_search(iter, str, flag, limit) + + start[] = start_out + stop[] = stop_out + found end """ @@ -315,11 +289,11 @@ function backward_search(iter::TI, str::AbstractString, start::Ref{_GtkTextIter}, stop::Ref{_GtkTextIter}, limit::Ref{_GtkTextIter}, flag) - Bool(ccall((:gtk_text_iter_backward_search, libgtk4), - Cint, - (Ptr{_GtkTextIter}, Ptr{UInt8}, Cuint, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), - iter, string(str), flag, start, stop, limit - )) + found, start_out, stop_out = G_.backward_search(iter, str, flag, limit) + + start[] = start_out + stop[] = stop_out + found end """ @@ -392,25 +366,20 @@ function getproperty(text::GtkTextRange, key::Symbol) starttext = first(text) endtext = last(text) if key === :slice - bytestring(ccall((:gtk_text_iter_get_slice, libgtk4), Ptr{UInt8}, - (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), starttext, endtext)) + G_.get_slice(starttext, endtext) elseif key === :visible_slice - bytestring(ccall((:gtk_text_iter_get_visible_slice, libgtk4), Ptr{UInt8}, - (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), starttext, endtext)) + G_.get_visible_slice(starttext, endtext) elseif key === :text - bytestring(ccall((:gtk_text_iter_get_text, libgtk4), Ptr{UInt8}, - (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), starttext, endtext)) + G_.get_text(starttext, endtext) elseif key === :visible_text - bytestring(ccall((:gtk_text_iter_get_visible_text, libgtk4), Ptr{UInt8}, - (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), starttext, endtext)) + G_.get_visible_text(starttext, endtext) end end function splice!(text::GtkTextBuffer, index::GtkTextRange) G_.delete(text, first(index), last(index)) text end -in(x::TI, r::GtkTextRange) = Bool(ccall((:gtk_text_iter_in_range, libgtk4), Cint, - (Ptr{_GtkTextIter}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), x, first(r), last(r))) +in(x::TI, r::GtkTextRange) = G_.in_range(x, first(r), last(r)) ##### GtkTextBuffer #####