From f1aad48f5a09e8ad66138f9ea312d68fb4026dd6 Mon Sep 17 00:00:00 2001 From: Jared Wahlstrand Date: Thu, 28 Nov 2024 22:05:42 -0500 Subject: [PATCH] reintroduce some macros, define g_type for interfaces --- Adwaita/src/gen/adw_structs | 1232 +-------- GI/src/giimport.jl | 33 +- Project.toml | 2 +- examples/custom_widget.jl | 21 +- src/GLib/gio.jl | 13 + src/GLib/gobject.jl | 28 + src/GLib/gtype.jl | 74 +- src/GLib/gvariant.jl | 4 + src/gen/gdk4_structs | 526 +--- src/gen/gdkpixbuf_structs | 126 +- src/gen/gio_structs | 2092 +-------------- src/gen/gobject_structs | 62 +- src/gen/gsk4_structs | 126 +- src/gen/gtk4_structs | 4856 +++-------------------------------- src/gen/pango_structs | 180 +- src/gen/pangocairo_structs | 16 +- 16 files changed, 687 insertions(+), 8704 deletions(-) diff --git a/Adwaita/src/gen/adw_structs b/Adwaita/src/gen/adw_structs index 13853f0a..26bdb414 100644 --- a/Adwaita/src/gen/adw_structs +++ b/Adwaita/src/gen/adw_structs @@ -25,31 +25,9 @@ $(Expr(:toplevel, quote gboxed_cache_init() = begin append!(GLib.gboxed_types, gboxed_types) end - struct AdwSwipeable <: GInterface - handle::Ptr{GObject} - gc::Any - AdwSwipeable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end + GLib.@Giface AdwSwipeable libadwaita adw_swipeable_get_type const gtype_wrapper_cache = Dict{Symbol, Type}() - begin - abstract type AdwDialog <: GtkWidget end - mutable struct AdwDialogLeaf <: AdwDialog - handle::Ptr{GObject} - function AdwDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwDialog] = AdwDialogLeaf - (GLib.g_type(::Type{T}) where T <: AdwDialog) = begin - ccall(("adw_dialog_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwDialog GtkWidget libadwaita adw_dialog_get_type begin function GLib.signalnames(::Type{AdwDialog}) vcat([:close_attempt, :closed], signalnames(supertype(AdwDialog))) @@ -63,23 +41,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwAboutDialog <: AdwDialog end - mutable struct AdwAboutDialogLeaf <: AdwAboutDialog - handle::Ptr{GObject} - function AdwAboutDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwAboutDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwAboutDialog] = AdwAboutDialogLeaf - (GLib.g_type(::Type{T}) where T <: AdwAboutDialog) = begin - ccall(("adw_about_dialog_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwAboutDialog AdwDialog libadwaita adw_about_dialog_get_type begin function GLib.signalnames(::Type{AdwAboutDialog}) vcat([:activate_link], signalnames(supertype(AdwAboutDialog))) @@ -93,45 +55,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwWindow <: GtkWindow end - mutable struct AdwWindowLeaf <: AdwWindow - handle::Ptr{GObject} - function AdwWindowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwWindowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwWindow] = AdwWindowLeaf - (GLib.g_type(::Type{T}) where T <: AdwWindow) = begin - ccall(("adw_window_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwWindow GtkWindow libadwaita adw_window_get_type begin function GLib.signalnames(::Type{AdwWindow}) signalnames(supertype(AdwWindow)) end end - begin - abstract type AdwAboutWindow <: AdwWindow end - mutable struct AdwAboutWindowLeaf <: AdwAboutWindow - handle::Ptr{GObject} - function AdwAboutWindowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwAboutWindowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwAboutWindow] = AdwAboutWindowLeaf - (GLib.g_type(::Type{T}) where T <: AdwAboutWindow) = begin - ccall(("adw_about_window_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwAboutWindow AdwWindow libadwaita adw_about_window_get_type begin function GLib.signalnames(::Type{AdwAboutWindow}) vcat([:activate_link], signalnames(supertype(AdwAboutWindow))) @@ -145,45 +75,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwPreferencesRow <: GtkListBoxRow end - mutable struct AdwPreferencesRowLeaf <: AdwPreferencesRow - handle::Ptr{GObject} - function AdwPreferencesRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwPreferencesRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwPreferencesRow] = AdwPreferencesRowLeaf - (GLib.g_type(::Type{T}) where T <: AdwPreferencesRow) = begin - ccall(("adw_preferences_row_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwPreferencesRow GtkListBoxRow libadwaita adw_preferences_row_get_type begin function GLib.signalnames(::Type{AdwPreferencesRow}) signalnames(supertype(AdwPreferencesRow)) end end - begin - abstract type AdwActionRow <: AdwPreferencesRow end - mutable struct AdwActionRowLeaf <: AdwActionRow - handle::Ptr{GObject} - function AdwActionRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwActionRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwActionRow] = AdwActionRowLeaf - (GLib.g_type(::Type{T}) where T <: AdwActionRow) = begin - ccall(("adw_action_row_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwActionRow AdwPreferencesRow libadwaita adw_action_row_get_type begin function GLib.signalnames(::Type{AdwActionRow}) vcat([:activated], signalnames(supertype(AdwActionRow))) @@ -197,23 +95,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwAlertDialog <: AdwDialog end - mutable struct AdwAlertDialogLeaf <: AdwAlertDialog - handle::Ptr{GObject} - function AdwAlertDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwAlertDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwAlertDialog] = AdwAlertDialogLeaf - (GLib.g_type(::Type{T}) where T <: AdwAlertDialog) = begin - ccall(("adw_alert_dialog_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwAlertDialog AdwDialog libadwaita adw_alert_dialog_get_type begin function GLib.signalnames(::Type{AdwAlertDialog}) vcat([:response], signalnames(supertype(AdwAlertDialog))) @@ -227,23 +109,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwAnimation <: GObject end - mutable struct AdwAnimationLeaf <: AdwAnimation - handle::Ptr{GObject} - function AdwAnimationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwAnimationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwAnimation] = AdwAnimationLeaf - (GLib.g_type(::Type{T}) where T <: AdwAnimation) = begin - ccall(("adw_animation_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwAnimation GObject libadwaita adw_animation_get_type begin function GLib.signalnames(::Type{AdwAnimation}) vcat([:done], signalnames(supertype(AdwAnimation))) @@ -257,45 +123,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwAnimationTarget <: GObject end - mutable struct AdwAnimationTargetLeaf <: AdwAnimationTarget - handle::Ptr{GObject} - function AdwAnimationTargetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwAnimationTargetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwAnimationTarget] = AdwAnimationTargetLeaf - (GLib.g_type(::Type{T}) where T <: AdwAnimationTarget) = begin - ccall(("adw_animation_target_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwAnimationTarget GObject libadwaita adw_animation_target_get_type begin function GLib.signalnames(::Type{AdwAnimationTarget}) signalnames(supertype(AdwAnimationTarget)) end end - begin - abstract type AdwApplication <: GtkApplication end - mutable struct AdwApplicationLeaf <: AdwApplication - handle::Ptr{GObject} - function AdwApplicationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwApplicationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwApplication] = AdwApplicationLeaf - (GLib.g_type(::Type{T}) where T <: AdwApplication) = begin - ccall(("adw_application_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwApplication GtkApplication libadwaita adw_application_get_type begin function GLib.signalnames(::Type{AdwApplication}) vcat([:action_added, :action_enabled_changed, :action_removed, :action_state_changed], signalnames(supertype(AdwApplication))) @@ -309,23 +143,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwApplicationWindow <: GtkApplicationWindow end - mutable struct AdwApplicationWindowLeaf <: AdwApplicationWindow - handle::Ptr{GObject} - function AdwApplicationWindowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwApplicationWindowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwApplicationWindow] = AdwApplicationWindowLeaf - (GLib.g_type(::Type{T}) where T <: AdwApplicationWindow) = begin - ccall(("adw_application_window_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwApplicationWindow GtkApplicationWindow libadwaita adw_application_window_get_type begin function GLib.signalnames(::Type{AdwApplicationWindow}) vcat([:action_added, :action_enabled_changed, :action_removed, :action_state_changed], signalnames(supertype(AdwApplicationWindow))) @@ -339,45 +157,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwAvatar <: GtkWidget end - mutable struct AdwAvatarLeaf <: AdwAvatar - handle::Ptr{GObject} - function AdwAvatarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwAvatarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwAvatar] = AdwAvatarLeaf - (GLib.g_type(::Type{T}) where T <: AdwAvatar) = begin - ccall(("adw_avatar_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwAvatar GtkWidget libadwaita adw_avatar_get_type begin function GLib.signalnames(::Type{AdwAvatar}) signalnames(supertype(AdwAvatar)) end end - begin - abstract type AdwBanner <: GtkWidget end - mutable struct AdwBannerLeaf <: AdwBanner - handle::Ptr{GObject} - function AdwBannerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwBannerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwBanner] = AdwBannerLeaf - (GLib.g_type(::Type{T}) where T <: AdwBanner) = begin - ccall(("adw_banner_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwBanner GtkWidget libadwaita adw_banner_get_type begin function GLib.signalnames(::Type{AdwBanner}) vcat([:button_clicked], signalnames(supertype(AdwBanner))) @@ -391,111 +177,31 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwBin <: GtkWidget end - mutable struct AdwBinLeaf <: AdwBin - handle::Ptr{GObject} - function AdwBinLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwBinLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwBin] = AdwBinLeaf - (GLib.g_type(::Type{T}) where T <: AdwBin) = begin - ccall(("adw_bin_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwBin GtkWidget libadwaita adw_bin_get_type begin function GLib.signalnames(::Type{AdwBin}) signalnames(supertype(AdwBin)) end end - begin - abstract type AdwBreakpointBin <: GtkWidget end - mutable struct AdwBreakpointBinLeaf <: AdwBreakpointBin - handle::Ptr{GObject} - function AdwBreakpointBinLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwBreakpointBinLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwBreakpointBin] = AdwBreakpointBinLeaf - (GLib.g_type(::Type{T}) where T <: AdwBreakpointBin) = begin - ccall(("adw_breakpoint_bin_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwBreakpointBin GtkWidget libadwaita adw_breakpoint_bin_get_type begin function GLib.signalnames(::Type{AdwBreakpointBin}) signalnames(supertype(AdwBreakpointBin)) end end - begin - abstract type AdwButtonContent <: GtkWidget end - mutable struct AdwButtonContentLeaf <: AdwButtonContent - handle::Ptr{GObject} - function AdwButtonContentLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwButtonContentLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwButtonContent] = AdwButtonContentLeaf - (GLib.g_type(::Type{T}) where T <: AdwButtonContent) = begin - ccall(("adw_button_content_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwButtonContent GtkWidget libadwaita adw_button_content_get_type begin function GLib.signalnames(::Type{AdwButtonContent}) signalnames(supertype(AdwButtonContent)) end end - begin - abstract type AdwCallbackAnimationTarget <: AdwAnimationTarget end - mutable struct AdwCallbackAnimationTargetLeaf <: AdwCallbackAnimationTarget - handle::Ptr{GObject} - function AdwCallbackAnimationTargetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwCallbackAnimationTargetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwCallbackAnimationTarget] = AdwCallbackAnimationTargetLeaf - (GLib.g_type(::Type{T}) where T <: AdwCallbackAnimationTarget) = begin - ccall(("adw_callback_animation_target_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwCallbackAnimationTarget AdwAnimationTarget libadwaita adw_callback_animation_target_get_type begin function GLib.signalnames(::Type{AdwCallbackAnimationTarget}) signalnames(supertype(AdwCallbackAnimationTarget)) end end - begin - abstract type AdwCarousel <: GtkWidget end - mutable struct AdwCarouselLeaf <: AdwCarousel - handle::Ptr{GObject} - function AdwCarouselLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwCarouselLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwCarousel] = AdwCarouselLeaf - (GLib.g_type(::Type{T}) where T <: AdwCarousel) = begin - ccall(("adw_carousel_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwCarousel GtkWidget libadwaita adw_carousel_get_type begin function GLib.signalnames(::Type{AdwCarousel}) vcat([:page_changed], signalnames(supertype(AdwCarousel))) @@ -509,155 +215,43 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwCarouselIndicatorDots <: GtkWidget end - mutable struct AdwCarouselIndicatorDotsLeaf <: AdwCarouselIndicatorDots - handle::Ptr{GObject} - function AdwCarouselIndicatorDotsLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwCarouselIndicatorDotsLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwCarouselIndicatorDots] = AdwCarouselIndicatorDotsLeaf - (GLib.g_type(::Type{T}) where T <: AdwCarouselIndicatorDots) = begin - ccall(("adw_carousel_indicator_dots_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwCarouselIndicatorDots GtkWidget libadwaita adw_carousel_indicator_dots_get_type begin function GLib.signalnames(::Type{AdwCarouselIndicatorDots}) signalnames(supertype(AdwCarouselIndicatorDots)) end end - begin - abstract type AdwCarouselIndicatorLines <: GtkWidget end - mutable struct AdwCarouselIndicatorLinesLeaf <: AdwCarouselIndicatorLines - handle::Ptr{GObject} - function AdwCarouselIndicatorLinesLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwCarouselIndicatorLinesLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwCarouselIndicatorLines] = AdwCarouselIndicatorLinesLeaf - (GLib.g_type(::Type{T}) where T <: AdwCarouselIndicatorLines) = begin - ccall(("adw_carousel_indicator_lines_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwCarouselIndicatorLines GtkWidget libadwaita adw_carousel_indicator_lines_get_type begin function GLib.signalnames(::Type{AdwCarouselIndicatorLines}) signalnames(supertype(AdwCarouselIndicatorLines)) end end - begin - abstract type AdwClamp <: GtkWidget end - mutable struct AdwClampLeaf <: AdwClamp - handle::Ptr{GObject} - function AdwClampLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwClampLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwClamp] = AdwClampLeaf - (GLib.g_type(::Type{T}) where T <: AdwClamp) = begin - ccall(("adw_clamp_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwClamp GtkWidget libadwaita adw_clamp_get_type begin function GLib.signalnames(::Type{AdwClamp}) signalnames(supertype(AdwClamp)) end end - begin - abstract type AdwClampLayout <: GtkLayoutManager end - mutable struct AdwClampLayoutLeaf <: AdwClampLayout - handle::Ptr{GObject} - function AdwClampLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwClampLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwClampLayout] = AdwClampLayoutLeaf - (GLib.g_type(::Type{T}) where T <: AdwClampLayout) = begin - ccall(("adw_clamp_layout_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwClampLayout GtkLayoutManager libadwaita adw_clamp_layout_get_type begin function GLib.signalnames(::Type{AdwClampLayout}) signalnames(supertype(AdwClampLayout)) end end - begin - abstract type AdwClampScrollable <: GtkWidget end - mutable struct AdwClampScrollableLeaf <: AdwClampScrollable - handle::Ptr{GObject} - function AdwClampScrollableLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwClampScrollableLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwClampScrollable] = AdwClampScrollableLeaf - (GLib.g_type(::Type{T}) where T <: AdwClampScrollable) = begin - ccall(("adw_clamp_scrollable_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwClampScrollable GtkWidget libadwaita adw_clamp_scrollable_get_type begin function GLib.signalnames(::Type{AdwClampScrollable}) signalnames(supertype(AdwClampScrollable)) end end - begin - abstract type AdwComboRow <: AdwActionRow end - mutable struct AdwComboRowLeaf <: AdwComboRow - handle::Ptr{GObject} - function AdwComboRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwComboRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwComboRow] = AdwComboRowLeaf - (GLib.g_type(::Type{T}) where T <: AdwComboRow) = begin - ccall(("adw_combo_row_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwComboRow AdwActionRow libadwaita adw_combo_row_get_type begin function GLib.signalnames(::Type{AdwComboRow}) signalnames(supertype(AdwComboRow)) end end - begin - abstract type AdwEntryRow <: AdwPreferencesRow end - mutable struct AdwEntryRowLeaf <: AdwEntryRow - handle::Ptr{GObject} - function AdwEntryRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwEntryRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwEntryRow] = AdwEntryRowLeaf - (GLib.g_type(::Type{T}) where T <: AdwEntryRow) = begin - ccall(("adw_entry_row_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwEntryRow AdwPreferencesRow libadwaita adw_entry_row_get_type begin function GLib.signalnames(::Type{AdwEntryRow}) vcat([:apply, :entry_activated, :changed, :delete_text, :insert_text], signalnames(supertype(AdwEntryRow))) @@ -671,45 +265,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwEnumListItem <: GObject end - mutable struct AdwEnumListItemLeaf <: AdwEnumListItem - handle::Ptr{GObject} - function AdwEnumListItemLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwEnumListItemLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwEnumListItem] = AdwEnumListItemLeaf - (GLib.g_type(::Type{T}) where T <: AdwEnumListItem) = begin - ccall(("adw_enum_list_item_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwEnumListItem GObject libadwaita adw_enum_list_item_get_type begin function GLib.signalnames(::Type{AdwEnumListItem}) signalnames(supertype(AdwEnumListItem)) end end - begin - abstract type AdwEnumListModel <: GObject end - mutable struct AdwEnumListModelLeaf <: AdwEnumListModel - handle::Ptr{GObject} - function AdwEnumListModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwEnumListModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwEnumListModel] = AdwEnumListModelLeaf - (GLib.g_type(::Type{T}) where T <: AdwEnumListModel) = begin - ccall(("adw_enum_list_model_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwEnumListModel GObject libadwaita adw_enum_list_model_get_type begin function GLib.signalnames(::Type{AdwEnumListModel}) vcat([:items_changed], signalnames(supertype(AdwEnumListModel))) @@ -723,133 +285,37 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwExpanderRow <: AdwPreferencesRow end - mutable struct AdwExpanderRowLeaf <: AdwExpanderRow - handle::Ptr{GObject} - function AdwExpanderRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwExpanderRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwExpanderRow] = AdwExpanderRowLeaf - (GLib.g_type(::Type{T}) where T <: AdwExpanderRow) = begin - ccall(("adw_expander_row_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwExpanderRow AdwPreferencesRow libadwaita adw_expander_row_get_type begin function GLib.signalnames(::Type{AdwExpanderRow}) signalnames(supertype(AdwExpanderRow)) end end - begin - abstract type AdwFlap <: GtkWidget end - mutable struct AdwFlapLeaf <: AdwFlap - handle::Ptr{GObject} - function AdwFlapLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwFlapLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwFlap] = AdwFlapLeaf - (GLib.g_type(::Type{T}) where T <: AdwFlap) = begin - ccall(("adw_flap_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwFlap GtkWidget libadwaita adw_flap_get_type begin function GLib.signalnames(::Type{AdwFlap}) signalnames(supertype(AdwFlap)) end end - begin - abstract type AdwHeaderBar <: GtkWidget end - mutable struct AdwHeaderBarLeaf <: AdwHeaderBar - handle::Ptr{GObject} - function AdwHeaderBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwHeaderBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwHeaderBar] = AdwHeaderBarLeaf - (GLib.g_type(::Type{T}) where T <: AdwHeaderBar) = begin - ccall(("adw_header_bar_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwHeaderBar GtkWidget libadwaita adw_header_bar_get_type begin function GLib.signalnames(::Type{AdwHeaderBar}) signalnames(supertype(AdwHeaderBar)) end end - begin - abstract type AdwLeaflet <: GtkWidget end - mutable struct AdwLeafletLeaf <: AdwLeaflet - handle::Ptr{GObject} - function AdwLeafletLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwLeafletLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwLeaflet] = AdwLeafletLeaf - (GLib.g_type(::Type{T}) where T <: AdwLeaflet) = begin - ccall(("adw_leaflet_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwLeaflet GtkWidget libadwaita adw_leaflet_get_type begin function GLib.signalnames(::Type{AdwLeaflet}) signalnames(supertype(AdwLeaflet)) end end - begin - abstract type AdwLeafletPage <: GObject end - mutable struct AdwLeafletPageLeaf <: AdwLeafletPage - handle::Ptr{GObject} - function AdwLeafletPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwLeafletPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwLeafletPage] = AdwLeafletPageLeaf - (GLib.g_type(::Type{T}) where T <: AdwLeafletPage) = begin - ccall(("adw_leaflet_page_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwLeafletPage GObject libadwaita adw_leaflet_page_get_type begin function GLib.signalnames(::Type{AdwLeafletPage}) signalnames(supertype(AdwLeafletPage)) end end - begin - abstract type AdwMessageDialog <: GtkWindow end - mutable struct AdwMessageDialogLeaf <: AdwMessageDialog - handle::Ptr{GObject} - function AdwMessageDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwMessageDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwMessageDialog] = AdwMessageDialogLeaf - (GLib.g_type(::Type{T}) where T <: AdwMessageDialog) = begin - ccall(("adw_message_dialog_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwMessageDialog GtkWindow libadwaita adw_message_dialog_get_type begin function GLib.signalnames(::Type{AdwMessageDialog}) vcat([:response], signalnames(supertype(AdwMessageDialog))) @@ -863,23 +329,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwNavigationPage <: GtkWidget end - mutable struct AdwNavigationPageLeaf <: AdwNavigationPage - handle::Ptr{GObject} - function AdwNavigationPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwNavigationPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwNavigationPage] = AdwNavigationPageLeaf - (GLib.g_type(::Type{T}) where T <: AdwNavigationPage) = begin - ccall(("adw_navigation_page_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwNavigationPage GtkWidget libadwaita adw_navigation_page_get_type begin function GLib.signalnames(::Type{AdwNavigationPage}) vcat([:hidden, :hiding, :showing, :shown], signalnames(supertype(AdwNavigationPage))) @@ -893,45 +343,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwNavigationSplitView <: GtkWidget end - mutable struct AdwNavigationSplitViewLeaf <: AdwNavigationSplitView - handle::Ptr{GObject} - function AdwNavigationSplitViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwNavigationSplitViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwNavigationSplitView] = AdwNavigationSplitViewLeaf - (GLib.g_type(::Type{T}) where T <: AdwNavigationSplitView) = begin - ccall(("adw_navigation_split_view_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwNavigationSplitView GtkWidget libadwaita adw_navigation_split_view_get_type begin function GLib.signalnames(::Type{AdwNavigationSplitView}) signalnames(supertype(AdwNavigationSplitView)) end end - begin - abstract type AdwNavigationView <: GtkWidget end - mutable struct AdwNavigationViewLeaf <: AdwNavigationView - handle::Ptr{GObject} - function AdwNavigationViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwNavigationViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwNavigationView] = AdwNavigationViewLeaf - (GLib.g_type(::Type{T}) where T <: AdwNavigationView) = begin - ccall(("adw_navigation_view_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwNavigationView GtkWidget libadwaita adw_navigation_view_get_type begin function GLib.signalnames(::Type{AdwNavigationView}) vcat([:get_next_page, :popped, :pushed, :replaced], signalnames(supertype(AdwNavigationView))) @@ -945,45 +363,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwOverlaySplitView <: GtkWidget end - mutable struct AdwOverlaySplitViewLeaf <: AdwOverlaySplitView - handle::Ptr{GObject} - function AdwOverlaySplitViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwOverlaySplitViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwOverlaySplitView] = AdwOverlaySplitViewLeaf - (GLib.g_type(::Type{T}) where T <: AdwOverlaySplitView) = begin - ccall(("adw_overlay_split_view_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwOverlaySplitView GtkWidget libadwaita adw_overlay_split_view_get_type begin function GLib.signalnames(::Type{AdwOverlaySplitView}) signalnames(supertype(AdwOverlaySplitView)) end end - begin - abstract type AdwPasswordEntryRow <: AdwEntryRow end - mutable struct AdwPasswordEntryRowLeaf <: AdwPasswordEntryRow - handle::Ptr{GObject} - function AdwPasswordEntryRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwPasswordEntryRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwPasswordEntryRow] = AdwPasswordEntryRowLeaf - (GLib.g_type(::Type{T}) where T <: AdwPasswordEntryRow) = begin - ccall(("adw_password_entry_row_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwPasswordEntryRow AdwEntryRow libadwaita adw_password_entry_row_get_type begin function GLib.signalnames(::Type{AdwPasswordEntryRow}) vcat([:changed, :delete_text, :insert_text], signalnames(supertype(AdwPasswordEntryRow))) @@ -997,133 +383,37 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwPreferencesDialog <: AdwDialog end - mutable struct AdwPreferencesDialogLeaf <: AdwPreferencesDialog - handle::Ptr{GObject} - function AdwPreferencesDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwPreferencesDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwPreferencesDialog] = AdwPreferencesDialogLeaf - (GLib.g_type(::Type{T}) where T <: AdwPreferencesDialog) = begin - ccall(("adw_preferences_dialog_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwPreferencesDialog AdwDialog libadwaita adw_preferences_dialog_get_type begin function GLib.signalnames(::Type{AdwPreferencesDialog}) signalnames(supertype(AdwPreferencesDialog)) end end - begin - abstract type AdwPreferencesGroup <: GtkWidget end - mutable struct AdwPreferencesGroupLeaf <: AdwPreferencesGroup - handle::Ptr{GObject} - function AdwPreferencesGroupLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwPreferencesGroupLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwPreferencesGroup] = AdwPreferencesGroupLeaf - (GLib.g_type(::Type{T}) where T <: AdwPreferencesGroup) = begin - ccall(("adw_preferences_group_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwPreferencesGroup GtkWidget libadwaita adw_preferences_group_get_type begin function GLib.signalnames(::Type{AdwPreferencesGroup}) signalnames(supertype(AdwPreferencesGroup)) end end - begin - abstract type AdwPreferencesPage <: GtkWidget end - mutable struct AdwPreferencesPageLeaf <: AdwPreferencesPage - handle::Ptr{GObject} - function AdwPreferencesPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwPreferencesPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwPreferencesPage] = AdwPreferencesPageLeaf - (GLib.g_type(::Type{T}) where T <: AdwPreferencesPage) = begin - ccall(("adw_preferences_page_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwPreferencesPage GtkWidget libadwaita adw_preferences_page_get_type begin function GLib.signalnames(::Type{AdwPreferencesPage}) signalnames(supertype(AdwPreferencesPage)) end end - begin - abstract type AdwPreferencesWindow <: AdwWindow end - mutable struct AdwPreferencesWindowLeaf <: AdwPreferencesWindow - handle::Ptr{GObject} - function AdwPreferencesWindowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwPreferencesWindowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwPreferencesWindow] = AdwPreferencesWindowLeaf - (GLib.g_type(::Type{T}) where T <: AdwPreferencesWindow) = begin - ccall(("adw_preferences_window_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwPreferencesWindow AdwWindow libadwaita adw_preferences_window_get_type begin function GLib.signalnames(::Type{AdwPreferencesWindow}) signalnames(supertype(AdwPreferencesWindow)) end end - begin - abstract type AdwPropertyAnimationTarget <: AdwAnimationTarget end - mutable struct AdwPropertyAnimationTargetLeaf <: AdwPropertyAnimationTarget - handle::Ptr{GObject} - function AdwPropertyAnimationTargetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwPropertyAnimationTargetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwPropertyAnimationTarget] = AdwPropertyAnimationTargetLeaf - (GLib.g_type(::Type{T}) where T <: AdwPropertyAnimationTarget) = begin - ccall(("adw_property_animation_target_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwPropertyAnimationTarget AdwAnimationTarget libadwaita adw_property_animation_target_get_type begin function GLib.signalnames(::Type{AdwPropertyAnimationTarget}) signalnames(supertype(AdwPropertyAnimationTarget)) end end - begin - abstract type AdwSpinRow <: AdwActionRow end - mutable struct AdwSpinRowLeaf <: AdwSpinRow - handle::Ptr{GObject} - function AdwSpinRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwSpinRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwSpinRow] = AdwSpinRowLeaf - (GLib.g_type(::Type{T}) where T <: AdwSpinRow) = begin - ccall(("adw_spin_row_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwSpinRow AdwActionRow libadwaita adw_spin_row_get_type begin function GLib.signalnames(::Type{AdwSpinRow}) vcat([:input, :output, :wrapped, :changed, :delete_text, :insert_text], signalnames(supertype(AdwSpinRow))) @@ -1137,23 +427,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwSplitButton <: GtkWidget end - mutable struct AdwSplitButtonLeaf <: AdwSplitButton - handle::Ptr{GObject} - function AdwSplitButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwSplitButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwSplitButton] = AdwSplitButtonLeaf - (GLib.g_type(::Type{T}) where T <: AdwSplitButton) = begin - ccall(("adw_split_button_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwSplitButton GtkWidget libadwaita adw_split_button_get_type begin function GLib.signalnames(::Type{AdwSplitButton}) vcat([:activate, :clicked], signalnames(supertype(AdwSplitButton))) @@ -1167,133 +441,37 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwSpringAnimation <: AdwAnimation end - mutable struct AdwSpringAnimationLeaf <: AdwSpringAnimation - handle::Ptr{GObject} - function AdwSpringAnimationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwSpringAnimationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwSpringAnimation] = AdwSpringAnimationLeaf - (GLib.g_type(::Type{T}) where T <: AdwSpringAnimation) = begin - ccall(("adw_spring_animation_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwSpringAnimation AdwAnimation libadwaita adw_spring_animation_get_type begin function GLib.signalnames(::Type{AdwSpringAnimation}) signalnames(supertype(AdwSpringAnimation)) end end - begin - abstract type AdwSqueezer <: GtkWidget end - mutable struct AdwSqueezerLeaf <: AdwSqueezer - handle::Ptr{GObject} - function AdwSqueezerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwSqueezerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwSqueezer] = AdwSqueezerLeaf - (GLib.g_type(::Type{T}) where T <: AdwSqueezer) = begin - ccall(("adw_squeezer_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwSqueezer GtkWidget libadwaita adw_squeezer_get_type begin function GLib.signalnames(::Type{AdwSqueezer}) signalnames(supertype(AdwSqueezer)) end end - begin - abstract type AdwSqueezerPage <: GObject end - mutable struct AdwSqueezerPageLeaf <: AdwSqueezerPage - handle::Ptr{GObject} - function AdwSqueezerPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwSqueezerPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwSqueezerPage] = AdwSqueezerPageLeaf - (GLib.g_type(::Type{T}) where T <: AdwSqueezerPage) = begin - ccall(("adw_squeezer_page_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwSqueezerPage GObject libadwaita adw_squeezer_page_get_type begin function GLib.signalnames(::Type{AdwSqueezerPage}) signalnames(supertype(AdwSqueezerPage)) end end - begin - abstract type AdwStatusPage <: GtkWidget end - mutable struct AdwStatusPageLeaf <: AdwStatusPage - handle::Ptr{GObject} - function AdwStatusPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwStatusPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwStatusPage] = AdwStatusPageLeaf - (GLib.g_type(::Type{T}) where T <: AdwStatusPage) = begin - ccall(("adw_status_page_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwStatusPage GtkWidget libadwaita adw_status_page_get_type begin function GLib.signalnames(::Type{AdwStatusPage}) signalnames(supertype(AdwStatusPage)) end end - begin - abstract type AdwStyleManager <: GObject end - mutable struct AdwStyleManagerLeaf <: AdwStyleManager - handle::Ptr{GObject} - function AdwStyleManagerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwStyleManagerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwStyleManager] = AdwStyleManagerLeaf - (GLib.g_type(::Type{T}) where T <: AdwStyleManager) = begin - ccall(("adw_style_manager_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwStyleManager GObject libadwaita adw_style_manager_get_type begin function GLib.signalnames(::Type{AdwStyleManager}) signalnames(supertype(AdwStyleManager)) end end - begin - abstract type AdwSwipeTracker <: GObject end - mutable struct AdwSwipeTrackerLeaf <: AdwSwipeTracker - handle::Ptr{GObject} - function AdwSwipeTrackerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwSwipeTrackerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwSwipeTracker] = AdwSwipeTrackerLeaf - (GLib.g_type(::Type{T}) where T <: AdwSwipeTracker) = begin - ccall(("adw_swipe_tracker_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwSwipeTracker GObject libadwaita adw_swipe_tracker_get_type begin function GLib.signalnames(::Type{AdwSwipeTracker}) vcat([:begin_swipe, :end_swipe, :prepare, :update_swipe], signalnames(supertype(AdwSwipeTracker))) @@ -1307,45 +485,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwSwitchRow <: AdwActionRow end - mutable struct AdwSwitchRowLeaf <: AdwSwitchRow - handle::Ptr{GObject} - function AdwSwitchRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwSwitchRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwSwitchRow] = AdwSwitchRowLeaf - (GLib.g_type(::Type{T}) where T <: AdwSwitchRow) = begin - ccall(("adw_switch_row_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwSwitchRow AdwActionRow libadwaita adw_switch_row_get_type begin function GLib.signalnames(::Type{AdwSwitchRow}) signalnames(supertype(AdwSwitchRow)) end end - begin - abstract type AdwTabBar <: GtkWidget end - mutable struct AdwTabBarLeaf <: AdwTabBar - handle::Ptr{GObject} - function AdwTabBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwTabBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwTabBar] = AdwTabBarLeaf - (GLib.g_type(::Type{T}) where T <: AdwTabBar) = begin - ccall(("adw_tab_bar_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwTabBar GtkWidget libadwaita adw_tab_bar_get_type begin function GLib.signalnames(::Type{AdwTabBar}) vcat([:extra_drag_drop, :extra_drag_value], signalnames(supertype(AdwTabBar))) @@ -1359,23 +505,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwTabButton <: GtkWidget end - mutable struct AdwTabButtonLeaf <: AdwTabButton - handle::Ptr{GObject} - function AdwTabButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwTabButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwTabButton] = AdwTabButtonLeaf - (GLib.g_type(::Type{T}) where T <: AdwTabButton) = begin - ccall(("adw_tab_button_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwTabButton GtkWidget libadwaita adw_tab_button_get_type begin function GLib.signalnames(::Type{AdwTabButton}) vcat([:activate, :clicked], signalnames(supertype(AdwTabButton))) @@ -1389,23 +519,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwTabOverview <: GtkWidget end - mutable struct AdwTabOverviewLeaf <: AdwTabOverview - handle::Ptr{GObject} - function AdwTabOverviewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwTabOverviewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwTabOverview] = AdwTabOverviewLeaf - (GLib.g_type(::Type{T}) where T <: AdwTabOverview) = begin - ccall(("adw_tab_overview_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwTabOverview GtkWidget libadwaita adw_tab_overview_get_type begin function GLib.signalnames(::Type{AdwTabOverview}) vcat([:create_tab, :extra_drag_drop, :extra_drag_value], signalnames(supertype(AdwTabOverview))) @@ -1419,45 +533,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwTabPage <: GObject end - mutable struct AdwTabPageLeaf <: AdwTabPage - handle::Ptr{GObject} - function AdwTabPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwTabPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwTabPage] = AdwTabPageLeaf - (GLib.g_type(::Type{T}) where T <: AdwTabPage) = begin - ccall(("adw_tab_page_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwTabPage GObject libadwaita adw_tab_page_get_type begin function GLib.signalnames(::Type{AdwTabPage}) signalnames(supertype(AdwTabPage)) end end - begin - abstract type AdwTabView <: GtkWidget end - mutable struct AdwTabViewLeaf <: AdwTabView - handle::Ptr{GObject} - function AdwTabViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwTabViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwTabView] = AdwTabViewLeaf - (GLib.g_type(::Type{T}) where T <: AdwTabView) = begin - ccall(("adw_tab_view_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwTabView GtkWidget libadwaita adw_tab_view_get_type begin function GLib.signalnames(::Type{AdwTabView}) vcat([:close_page, :create_window, :indicator_activated, :page_attached, :page_detached, :page_reordered, :setup_menu], signalnames(supertype(AdwTabView))) @@ -1471,45 +553,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwTimedAnimation <: AdwAnimation end - mutable struct AdwTimedAnimationLeaf <: AdwTimedAnimation - handle::Ptr{GObject} - function AdwTimedAnimationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwTimedAnimationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwTimedAnimation] = AdwTimedAnimationLeaf - (GLib.g_type(::Type{T}) where T <: AdwTimedAnimation) = begin - ccall(("adw_timed_animation_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwTimedAnimation AdwAnimation libadwaita adw_timed_animation_get_type begin function GLib.signalnames(::Type{AdwTimedAnimation}) signalnames(supertype(AdwTimedAnimation)) end end - begin - abstract type AdwToast <: GObject end - mutable struct AdwToastLeaf <: AdwToast - handle::Ptr{GObject} - function AdwToastLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwToastLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwToast] = AdwToastLeaf - (GLib.g_type(::Type{T}) where T <: AdwToast) = begin - ccall(("adw_toast_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwToast GObject libadwaita adw_toast_get_type begin function GLib.signalnames(::Type{AdwToast}) vcat([:button_clicked, :dismissed], signalnames(supertype(AdwToast))) @@ -1523,111 +573,31 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwToastOverlay <: GtkWidget end - mutable struct AdwToastOverlayLeaf <: AdwToastOverlay - handle::Ptr{GObject} - function AdwToastOverlayLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwToastOverlayLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwToastOverlay] = AdwToastOverlayLeaf - (GLib.g_type(::Type{T}) where T <: AdwToastOverlay) = begin - ccall(("adw_toast_overlay_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwToastOverlay GtkWidget libadwaita adw_toast_overlay_get_type begin function GLib.signalnames(::Type{AdwToastOverlay}) signalnames(supertype(AdwToastOverlay)) end end - begin - abstract type AdwToolbarView <: GtkWidget end - mutable struct AdwToolbarViewLeaf <: AdwToolbarView - handle::Ptr{GObject} - function AdwToolbarViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwToolbarViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwToolbarView] = AdwToolbarViewLeaf - (GLib.g_type(::Type{T}) where T <: AdwToolbarView) = begin - ccall(("adw_toolbar_view_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwToolbarView GtkWidget libadwaita adw_toolbar_view_get_type begin function GLib.signalnames(::Type{AdwToolbarView}) signalnames(supertype(AdwToolbarView)) end end - begin - abstract type AdwViewStack <: GtkWidget end - mutable struct AdwViewStackLeaf <: AdwViewStack - handle::Ptr{GObject} - function AdwViewStackLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwViewStackLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwViewStack] = AdwViewStackLeaf - (GLib.g_type(::Type{T}) where T <: AdwViewStack) = begin - ccall(("adw_view_stack_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwViewStack GtkWidget libadwaita adw_view_stack_get_type begin function GLib.signalnames(::Type{AdwViewStack}) signalnames(supertype(AdwViewStack)) end end - begin - abstract type AdwViewStackPage <: GObject end - mutable struct AdwViewStackPageLeaf <: AdwViewStackPage - handle::Ptr{GObject} - function AdwViewStackPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwViewStackPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwViewStackPage] = AdwViewStackPageLeaf - (GLib.g_type(::Type{T}) where T <: AdwViewStackPage) = begin - ccall(("adw_view_stack_page_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwViewStackPage GObject libadwaita adw_view_stack_page_get_type begin function GLib.signalnames(::Type{AdwViewStackPage}) signalnames(supertype(AdwViewStackPage)) end end - begin - abstract type AdwViewStackPages <: GObject end - mutable struct AdwViewStackPagesLeaf <: AdwViewStackPages - handle::Ptr{GObject} - function AdwViewStackPagesLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwViewStackPagesLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwViewStackPages] = AdwViewStackPagesLeaf - (GLib.g_type(::Type{T}) where T <: AdwViewStackPages) = begin - ccall(("adw_view_stack_pages_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwViewStackPages GObject libadwaita adw_view_stack_pages_get_type begin function GLib.signalnames(::Type{AdwViewStackPages}) vcat([:items_changed, :selection_changed], signalnames(supertype(AdwViewStackPages))) @@ -1641,89 +611,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type AdwViewSwitcher <: GtkWidget end - mutable struct AdwViewSwitcherLeaf <: AdwViewSwitcher - handle::Ptr{GObject} - function AdwViewSwitcherLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwViewSwitcherLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwViewSwitcher] = AdwViewSwitcherLeaf - (GLib.g_type(::Type{T}) where T <: AdwViewSwitcher) = begin - ccall(("adw_view_switcher_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwViewSwitcher GtkWidget libadwaita adw_view_switcher_get_type begin function GLib.signalnames(::Type{AdwViewSwitcher}) signalnames(supertype(AdwViewSwitcher)) end end - begin - abstract type AdwViewSwitcherBar <: GtkWidget end - mutable struct AdwViewSwitcherBarLeaf <: AdwViewSwitcherBar - handle::Ptr{GObject} - function AdwViewSwitcherBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwViewSwitcherBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwViewSwitcherBar] = AdwViewSwitcherBarLeaf - (GLib.g_type(::Type{T}) where T <: AdwViewSwitcherBar) = begin - ccall(("adw_view_switcher_bar_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwViewSwitcherBar GtkWidget libadwaita adw_view_switcher_bar_get_type begin function GLib.signalnames(::Type{AdwViewSwitcherBar}) signalnames(supertype(AdwViewSwitcherBar)) end end - begin - abstract type AdwViewSwitcherTitle <: GtkWidget end - mutable struct AdwViewSwitcherTitleLeaf <: AdwViewSwitcherTitle - handle::Ptr{GObject} - function AdwViewSwitcherTitleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwViewSwitcherTitleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwViewSwitcherTitle] = AdwViewSwitcherTitleLeaf - (GLib.g_type(::Type{T}) where T <: AdwViewSwitcherTitle) = begin - ccall(("adw_view_switcher_title_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwViewSwitcherTitle GtkWidget libadwaita adw_view_switcher_title_get_type begin function GLib.signalnames(::Type{AdwViewSwitcherTitle}) signalnames(supertype(AdwViewSwitcherTitle)) end end - begin - abstract type AdwWindowTitle <: GtkWidget end - mutable struct AdwWindowTitleLeaf <: AdwWindowTitle - handle::Ptr{GObject} - function AdwWindowTitleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct AdwWindowTitleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:AdwWindowTitle] = AdwWindowTitleLeaf - (GLib.g_type(::Type{T}) where T <: AdwWindowTitle) = begin - ccall(("adw_window_title_get_type", libadwaita), GType, ()) - end - end + GLib.@Gobject AdwWindowTitle GtkWidget libadwaita adw_window_title_get_type begin function GLib.signalnames(::Type{AdwWindowTitle}) signalnames(supertype(AdwWindowTitle)) diff --git a/GI/src/giimport.jl b/GI/src/giimport.jl index 499de495..c2367800 100644 --- a/GI/src/giimport.jl +++ b/GI/src/giimport.jl @@ -221,23 +221,15 @@ function gobject_decl(objectinfo) println("get_g_type returns void -- not in library? : ", get_name(objectinfo)) end + type_init = Symbol(get_type_init(objectinfo)) + libs=get_shlibs(GINamespace(get_namespace(objectinfo))) + lib=libs[findfirst(find_symbol(type_init),libs)] + exprs=Expr[] decl=quote - abstract type $oname <: $pname end - mutable struct $leafname <: $oname - handle::Ptr{GObject} - function $leafname(handle::Ptr{GObject}, owns=false) - if handle == C_NULL - error($("Cannot construct $leafname with a NULL pointer")) - end - GLib.gobject_maybe_sink(handle,owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[$(QuoteNode(oname))] = $leafname - $(unblock(typeinit_def(objectinfo, oname))) + @GLib.Gobject $oname $pname $(symbol_from_lib(lib)) $type_init end - push!(exprs, decl) + push!(exprs, MacroTools.striplines(unblock(decl))) # if there are signals, add "signal_return_type" method, and "signal_arg_types" method signals = get_all_signals(objectinfo) sigdict = signal_dict_incl_parents(objectinfo) @@ -310,19 +302,20 @@ end function decl(interfaceinfo::GIInterfaceInfo) g_type = get_g_type(interfaceinfo) + + type_init = Symbol(get_type_init(interfaceinfo)) + libs=get_shlibs(GINamespace(get_namespace(interfaceinfo))) + lib=libs[findfirst(find_symbol(type_init),libs)] + iname = Symbol(GLib.g_type_name(g_type)) if iname === :void println("get_g_type returns void -- not in library? : ", get_name(interfaceinfo)) end decl=quote - struct $iname <: GInterface - handle::Ptr{GObject} - gc::Any - $iname(x::GObject) = new(unsafe_convert(Ptr{GObject}, x), x) - end + @GLib.Giface $iname $(symbol_from_lib(lib)) $type_init end - unblock(decl) + MacroTools.striplines(unblock(decl)) end function get_closure(callbackinfo::GICallbackInfo) diff --git a/Project.toml b/Project.toml index 263d9d9c..ad7941bd 100644 --- a/Project.toml +++ b/Project.toml @@ -1,6 +1,6 @@ name = "Gtk4" uuid = "9db2cae5-386f-4011-9d63-a5602296539b" -version = "0.7.1" +version = "0.7.2" [deps] BitFlags = "d1d4a3ce-64b1-5f1a-9ba4-7e7e69966f35" diff --git a/examples/custom_widget.jl b/examples/custom_widget.jl index cce2380d..3d88ac92 100644 --- a/examples/custom_widget.jl +++ b/examples/custom_widget.jl @@ -38,27 +38,12 @@ function GLib.g_type(::Type{T}) where T <: MyWidget if gt > 0 return gt else - base_gtype = GLib.g_type(GtkWidget) - tq=GLib.G_.type_query(base_gtype) - typeinfo = _GTypeInfo(tq.class_size, - C_NULL, # base_init - C_NULL, # base_finalize - @cfunction(object_class_init, Cvoid, (Ptr{_GObjectClass}, Ptr{Cvoid})), - C_NULL, # class_finalize - C_NULL, # class_data - tq.instance_size, - 0, # n_preallocs - C_NULL, # instance_init - C_NULL) # value_table - return GLib.G_.type_register_static(base_gtype,:MyWidget,Ref(typeinfo),GLib.TypeFlags_FINAL) + object_class_init_cfunc = @cfunction(object_class_init, Cvoid, (Ptr{_GObjectClass}, Ptr{Cvoid})) + return GLib.register_subtype(GtkWidget, :MyWidget, object_class_init_cfunc) end end -function MyWidget() - gtype = GLib.g_type(MyWidget) - h = ccall(("g_object_new", GLib.libgobject), Ptr{GObject}, (UInt64, Ptr{Cvoid}), gtype, C_NULL) - MyWidget(h) -end +MyWidget() = GLib.gobject_new(MyWidget) w = MyWidget() diff --git a/src/GLib/gio.jl b/src/GLib/gio.jl index 75150283..7e8c4c50 100644 --- a/src/GLib/gio.jl +++ b/src/GLib/gio.jl @@ -50,3 +50,16 @@ function cancel_after_delay(timeout) end cancellable end + +mutable struct _GActionInterface + g_iface::_GTypeInterface + get_name::Ptr{Cvoid} + get_parameter_type::Ptr{Cvoid} + get_state_type::Ptr{Cvoid} + get_state_hint::Ptr{Cvoid} + get_enabled::Ptr{Cvoid} + get_state::Ptr{Cvoid} + change_state::Ptr{Cvoid} + activate::Ptr{Cvoid} +end + diff --git a/src/GLib/gobject.jl b/src/GLib/gobject.jl index ac2ca6b2..4134ed2a 100644 --- a/src/GLib/gobject.jl +++ b/src/GLib/gobject.jl @@ -152,6 +152,8 @@ Related GTK function: [`g_binding_unbind`](https://docs.gtk.org/gobject/method.B """ unbind_property(b::GBinding) = G_.unbind(b) +## Below is experimental and unstable! + mutable struct _GObjectClass g_type_class::_GTypeClass construct_properties::Ptr{GLib._GSList{Ptr{Nothing}}} @@ -171,3 +173,29 @@ mutable struct _GObjectClass pdummy2::Ptr{Nothing} pdummy3::Ptr{Nothing} end + +function register_subtype(::Type{T}, typename::Symbol, object_class_init_cfunc) where T<:GObject + base_gtype = g_type(T) + tq=G_.type_query(base_gtype) + typeinfo = _GTypeInfo(tq.class_size, + C_NULL, # base_init + C_NULL, # base_finalize + object_class_init_cfunc, + C_NULL, # class_finalize + C_NULL, # class_data + tq.instance_size, + 0, # n_preallocs + C_NULL, # instance_init + C_NULL) # value_table + G_.type_register_static(base_gtype,typename,Ref(typeinfo),TypeFlags_FINAL) +end + +function override_property(class::Ptr{_GObjectClass}, property_id, name::AbstractString) + ccall((:g_object_class_override_property, libgobject), Cvoid, (Ptr{_GObjectClass}, Cuint, Cstring), class, property_id, name) +end + +function gobject_new(juliatype, args...) + gtype = GLib.g_type(juliatype) + h=ccall(("g_object_new", GLib.libgobject), Ptr{GObject}, (UInt64, Ptr{Cvoid}), gtype, C_NULL) + juliatype(h, args...) +end diff --git a/src/GLib/gtype.jl b/src/GLib/gtype.jl index 519a8b71..99c88d63 100644 --- a/src/GLib/gtype.jl +++ b/src/GLib/gtype.jl @@ -60,6 +60,61 @@ const fundamental_types = ( g_type_from_name(name::Symbol) = ccall((:g_type_from_name, libgobject), GType, (Ptr{UInt8},), name) const fundamental_ids = tuple(GType[g_type_from_name(name) for (name, c, j, f, v) in fundamental_types]...) +function get_gtype_decl(name::Symbol, lib, callname::Symbol) + :(GLib.g_type(::Type{T}) where T <: $(esc(name)) = + ccall(($(String(callname)), $(esc(lib))), GType, ())) +end + +function get_interface_decl(iname::Symbol) + quote + struct $(esc(iname)) <: GInterface + handle::Ptr{GObject} + gc::Any + $(esc(iname))(x::GObject) = new(unsafe_convert(Ptr{GObject}, x), x) + end + end +end + +function get_object_decl(iname::Symbol,parentname::Symbol) + leafname = Symbol(String(iname),"Leaf") + undeferrmessage = "Cannot construct $leafname with a NULL pointer" + quote + abstract type $(esc(iname)) <: $(esc(parentname)) end + mutable struct $(esc(leafname)) <: $(esc(iname)) + handle::Ptr{GObject} + function $(esc(leafname))(handle::Ptr{GObject}, owns = false) + if handle == C_NULL + error($undeferrmessage) + end + GLib.gobject_maybe_sink(handle, owns) + return gobject_ref(new(handle)) + end + end + gtype_wrapper_cache[$(QuoteNode(iname))] = $(esc(leafname)) + end +end + +macro Giface(iname, lib, callname) + gtype_decl = get_gtype_decl(iname, lib, callname) + interf_decl = get_interface_decl(iname) + ex=quote + $(interf_decl) + $(gtype_decl) + end + Base.remove_linenums!(ex) +end + +macro Gobject(iname, pname, lib, callname) + gtype_decl = get_gtype_decl(iname, lib, callname) + obj_decl = get_object_decl(iname, pname) + ex=quote + $(obj_decl) + $(gtype_decl) + end + Base.remove_linenums!(ex) +end + + """ g_type(x) @@ -288,12 +343,7 @@ function delref(@nospecialize(x::GObject)) # internal helper function exiting[] && return # unnecessary to cleanup if we are about to die anyways if gc_preserve_glib_lock[] || g_yielded[] - lock(await_lock) - try - push!(await_finalize, x) - finally - unlock(await_lock) - end + @lock await_lock push!(await_finalize, x) return # avoid running finalizers at random times end finalize_gc_unref(x) @@ -318,12 +368,7 @@ function gobject_ref(x::T) where T <: GObject if ccall((:g_object_get_qdata, libgobject), Ptr{Cvoid}, (Ptr{GObject}, UInt32), x, jlref_quark::UInt32) != C_NULL # have set up metadata for this before, but its weakref has been cleared. restore the ref. - lock(await_lock) - try - delete!(await_finalize, x) - finally - unlock(await_lock) - end + @lock await_lock delete!(await_finalize, x) finalizer(delref, x) gc_preserve_glib[WeakRef(x)] = false # record the existence of the object, but allow the finalizer else @@ -357,14 +402,11 @@ function run_delayed_finalizers() filter!(x->!(isa(x.first,WeakRef) && x.first.value === nothing),gc_preserve_glib) gc_preserve_glib_lock[] = false end - lock(await_lock) - try + @lock await_lock begin while !isempty(await_finalize) x = pop!(await_finalize) finalize_gc_unref(x) end - finally - unlock(await_lock) end topfinalizer[] = true end diff --git a/src/GLib/gvariant.jl b/src/GLib/gvariant.jl index d9403c1d..425b4e31 100644 --- a/src/GLib/gvariant.jl +++ b/src/GLib/gvariant.jl @@ -74,3 +74,7 @@ end GVariantType(t::Type{T}) where T = G_.VariantType_new(variant_type_string(t)) Base.:(==)(lhs::GVariantType, rhs::GVariantType) = G_.equal(lhs,rhs) + +function show(io::IO, gvt::GVariantType) + print(io, "GVariantType(\""*G_.dup_string(gvt)*"\")") +end diff --git a/src/gen/gdk4_structs b/src/gen/gdk4_structs index ebaaa1c7..d1520655 100644 --- a/src/gen/gdk4_structs +++ b/src/gen/gdk4_structs @@ -318,59 +318,13 @@ $(Expr(:toplevel, quote @doc "See the [GTK docs](https://docs.gtk.org/gdk4/struct.TextureDownloader.html)." GdkTextureDownloader @doc "See the [GTK docs](https://docs.gtk.org/gdk4/struct.TimeCoord.html)." GdkTimeCoord @doc "See the [GTK docs](https://docs.gtk.org/gdk4/struct.ToplevelLayout.html)." GdkToplevelLayout - struct GdkDevicePad <: GInterface - handle::Ptr{GObject} - gc::Any - GdkDevicePad(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GdkDragSurface <: GInterface - handle::Ptr{GObject} - gc::Any - GdkDragSurface(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GdkPaintable <: GInterface - handle::Ptr{GObject} - gc::Any - GdkPaintable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GdkPopup <: GInterface - handle::Ptr{GObject} - gc::Any - GdkPopup(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GdkToplevel <: GInterface - handle::Ptr{GObject} - gc::Any - GdkToplevel(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end + GLib.@Giface GdkDevicePad libgtk4 gdk_device_pad_get_type + GLib.@Giface GdkDragSurface libgtk4 gdk_drag_surface_get_type + GLib.@Giface GdkPaintable libgtk4 gdk_paintable_get_type + GLib.@Giface GdkPopup libgtk4 gdk_popup_get_type + GLib.@Giface GdkToplevel libgtk4 gdk_toplevel_get_type const gtype_wrapper_cache = Dict{Symbol, Type}() - begin - abstract type GdkAppLaunchContext <: GAppLaunchContext end - mutable struct GdkAppLaunchContextLeaf <: GdkAppLaunchContext - handle::Ptr{GObject} - function GdkAppLaunchContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkAppLaunchContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkAppLaunchContext] = GdkAppLaunchContextLeaf - (GLib.g_type(::Type{T}) where T <: GdkAppLaunchContext) = begin - ccall(("gdk_app_launch_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkAppLaunchContext GAppLaunchContext libgtk4 gdk_app_launch_context_get_type begin function GLib.signalnames(::Type{GdkAppLaunchContext}) signalnames(supertype(GdkAppLaunchContext)) @@ -398,67 +352,19 @@ $(Expr(:toplevel, quote handle::Ptr{GdkEvent} end end - begin - abstract type GdkDrawContext <: GObject end - mutable struct GdkDrawContextLeaf <: GdkDrawContext - handle::Ptr{GObject} - function GdkDrawContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkDrawContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkDrawContext] = GdkDrawContextLeaf - (GLib.g_type(::Type{T}) where T <: GdkDrawContext) = begin - ccall(("gdk_draw_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkDrawContext GObject libgtk4 gdk_draw_context_get_type begin function GLib.signalnames(::Type{GdkDrawContext}) signalnames(supertype(GdkDrawContext)) end end - begin - abstract type GdkCairoContext <: GdkDrawContext end - mutable struct GdkCairoContextLeaf <: GdkCairoContext - handle::Ptr{GObject} - function GdkCairoContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkCairoContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkCairoContext] = GdkCairoContextLeaf - (GLib.g_type(::Type{T}) where T <: GdkCairoContext) = begin - ccall(("gdk_cairo_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkCairoContext GdkDrawContext libgtk4 gdk_cairo_context_get_type begin function GLib.signalnames(::Type{GdkCairoContext}) signalnames(supertype(GdkCairoContext)) end end - begin - abstract type GdkClipboard <: GObject end - mutable struct GdkClipboardLeaf <: GdkClipboard - handle::Ptr{GObject} - function GdkClipboardLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkClipboardLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkClipboard] = GdkClipboardLeaf - (GLib.g_type(::Type{T}) where T <: GdkClipboard) = begin - ccall(("gdk_clipboard_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkClipboard GObject libgtk4 gdk_clipboard_get_type begin function GLib.signalnames(::Type{GdkClipboard}) vcat([:changed], signalnames(supertype(GdkClipboard))) @@ -472,45 +378,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkContentDeserializer <: GObject end - mutable struct GdkContentDeserializerLeaf <: GdkContentDeserializer - handle::Ptr{GObject} - function GdkContentDeserializerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkContentDeserializerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkContentDeserializer] = GdkContentDeserializerLeaf - (GLib.g_type(::Type{T}) where T <: GdkContentDeserializer) = begin - ccall(("gdk_content_deserializer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkContentDeserializer GObject libgtk4 gdk_content_deserializer_get_type begin function GLib.signalnames(::Type{GdkContentDeserializer}) signalnames(supertype(GdkContentDeserializer)) end end - begin - abstract type GdkContentProvider <: GObject end - mutable struct GdkContentProviderLeaf <: GdkContentProvider - handle::Ptr{GObject} - function GdkContentProviderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkContentProviderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkContentProvider] = GdkContentProviderLeaf - (GLib.g_type(::Type{T}) where T <: GdkContentProvider) = begin - ccall(("gdk_content_provider_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkContentProvider GObject libgtk4 gdk_content_provider_get_type begin function GLib.signalnames(::Type{GdkContentProvider}) vcat([:content_changed], signalnames(supertype(GdkContentProvider))) @@ -524,23 +398,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkContentSerializer <: GObject end - mutable struct GdkContentSerializerLeaf <: GdkContentSerializer - handle::Ptr{GObject} - function GdkContentSerializerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkContentSerializerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkContentSerializer] = GdkContentSerializerLeaf - (GLib.g_type(::Type{T}) where T <: GdkContentSerializer) = begin - ccall(("gdk_content_serializer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkContentSerializer GObject libgtk4 gdk_content_serializer_get_type begin function GLib.signalnames(::Type{GdkContentSerializer}) signalnames(supertype(GdkContentSerializer)) @@ -554,23 +412,7 @@ $(Expr(:toplevel, quote handle::Ptr{GdkEvent} end end - begin - abstract type GdkCursor <: GObject end - mutable struct GdkCursorLeaf <: GdkCursor - handle::Ptr{GObject} - function GdkCursorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkCursorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkCursor] = GdkCursorLeaf - (GLib.g_type(::Type{T}) where T <: GdkCursor) = begin - ccall(("gdk_cursor_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkCursor GObject libgtk4 gdk_cursor_get_type begin function GLib.signalnames(::Type{GdkCursor}) signalnames(supertype(GdkCursor)) @@ -592,23 +434,7 @@ $(Expr(:toplevel, quote handle::Ptr{GdkEvent} end end - begin - abstract type GdkDevice <: GObject end - mutable struct GdkDeviceLeaf <: GdkDevice - handle::Ptr{GObject} - function GdkDeviceLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkDeviceLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkDevice] = GdkDeviceLeaf - (GLib.g_type(::Type{T}) where T <: GdkDevice) = begin - ccall(("gdk_device_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkDevice GObject libgtk4 gdk_device_get_type begin function GLib.signalnames(::Type{GdkDevice}) vcat([:changed, :tool_changed], signalnames(supertype(GdkDevice))) @@ -622,45 +448,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkDeviceTool <: GObject end - mutable struct GdkDeviceToolLeaf <: GdkDeviceTool - handle::Ptr{GObject} - function GdkDeviceToolLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkDeviceToolLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkDeviceTool] = GdkDeviceToolLeaf - (GLib.g_type(::Type{T}) where T <: GdkDeviceTool) = begin - ccall(("gdk_device_tool_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkDeviceTool GObject libgtk4 gdk_device_tool_get_type begin function GLib.signalnames(::Type{GdkDeviceTool}) signalnames(supertype(GdkDeviceTool)) end end - begin - abstract type GdkDisplay <: GObject end - mutable struct GdkDisplayLeaf <: GdkDisplay - handle::Ptr{GObject} - function GdkDisplayLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkDisplayLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkDisplay] = GdkDisplayLeaf - (GLib.g_type(::Type{T}) where T <: GdkDisplay) = begin - ccall(("gdk_display_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkDisplay GObject libgtk4 gdk_display_get_type begin function GLib.signalnames(::Type{GdkDisplay}) vcat([:closed, :opened, :seat_added, :seat_removed, :setting_changed], signalnames(supertype(GdkDisplay))) @@ -674,23 +468,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkDisplayManager <: GObject end - mutable struct GdkDisplayManagerLeaf <: GdkDisplayManager - handle::Ptr{GObject} - function GdkDisplayManagerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkDisplayManagerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkDisplayManager] = GdkDisplayManagerLeaf - (GLib.g_type(::Type{T}) where T <: GdkDisplayManager) = begin - ccall(("gdk_display_manager_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkDisplayManager GObject libgtk4 gdk_display_manager_get_type begin function GLib.signalnames(::Type{GdkDisplayManager}) vcat([:display_opened], signalnames(supertype(GdkDisplayManager))) @@ -704,23 +482,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkTexture <: GObject end - mutable struct GdkTextureLeaf <: GdkTexture - handle::Ptr{GObject} - function GdkTextureLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkTextureLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkTexture] = GdkTextureLeaf - (GLib.g_type(::Type{T}) where T <: GdkTexture) = begin - ccall(("gdk_texture_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkTexture GObject libgtk4 gdk_texture_get_type begin function GLib.signalnames(::Type{GdkTexture}) vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GdkTexture))) @@ -734,23 +496,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkDmabufTexture <: GdkTexture end - mutable struct GdkDmabufTextureLeaf <: GdkDmabufTexture - handle::Ptr{GObject} - function GdkDmabufTextureLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkDmabufTextureLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkDmabufTexture] = GdkDmabufTextureLeaf - (GLib.g_type(::Type{T}) where T <: GdkDmabufTexture) = begin - ccall(("gdk_dmabuf_texture_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkDmabufTexture GdkTexture libgtk4 gdk_dmabuf_texture_get_type begin function GLib.signalnames(::Type{GdkDmabufTexture}) vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GdkDmabufTexture))) @@ -764,45 +510,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkDmabufTextureBuilder <: GObject end - mutable struct GdkDmabufTextureBuilderLeaf <: GdkDmabufTextureBuilder - handle::Ptr{GObject} - function GdkDmabufTextureBuilderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkDmabufTextureBuilderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkDmabufTextureBuilder] = GdkDmabufTextureBuilderLeaf - (GLib.g_type(::Type{T}) where T <: GdkDmabufTextureBuilder) = begin - ccall(("gdk_dmabuf_texture_builder_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkDmabufTextureBuilder GObject libgtk4 gdk_dmabuf_texture_builder_get_type begin function GLib.signalnames(::Type{GdkDmabufTextureBuilder}) signalnames(supertype(GdkDmabufTextureBuilder)) end end - begin - abstract type GdkDrag <: GObject end - mutable struct GdkDragLeaf <: GdkDrag - handle::Ptr{GObject} - function GdkDragLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkDragLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkDrag] = GdkDragLeaf - (GLib.g_type(::Type{T}) where T <: GdkDrag) = begin - ccall(("gdk_drag_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkDrag GObject libgtk4 gdk_drag_get_type begin function GLib.signalnames(::Type{GdkDrag}) vcat([:cancel, :dnd_finished, :drop_performed], signalnames(supertype(GdkDrag))) @@ -816,23 +530,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkDrop <: GObject end - mutable struct GdkDropLeaf <: GdkDrop - handle::Ptr{GObject} - function GdkDropLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkDropLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkDrop] = GdkDropLeaf - (GLib.g_type(::Type{T}) where T <: GdkDrop) = begin - ccall(("gdk_drop_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkDrop GObject libgtk4 gdk_drop_get_type begin function GLib.signalnames(::Type{GdkDrop}) signalnames(supertype(GdkDrop)) @@ -846,23 +544,7 @@ $(Expr(:toplevel, quote handle::Ptr{GdkEvent} end end - begin - abstract type GdkFrameClock <: GObject end - mutable struct GdkFrameClockLeaf <: GdkFrameClock - handle::Ptr{GObject} - function GdkFrameClockLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkFrameClockLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkFrameClock] = GdkFrameClockLeaf - (GLib.g_type(::Type{T}) where T <: GdkFrameClock) = begin - ccall(("gdk_frame_clock_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkFrameClock GObject libgtk4 gdk_frame_clock_get_type begin function GLib.signalnames(::Type{GdkFrameClock}) vcat([:after_paint, :before_paint, :flush_events, :layout, :paint, :resume_events, :update], signalnames(supertype(GdkFrameClock))) @@ -876,45 +558,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkGLContext <: GdkDrawContext end - mutable struct GdkGLContextLeaf <: GdkGLContext - handle::Ptr{GObject} - function GdkGLContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkGLContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkGLContext] = GdkGLContextLeaf - (GLib.g_type(::Type{T}) where T <: GdkGLContext) = begin - ccall(("gdk_gl_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkGLContext GdkDrawContext libgtk4 gdk_gl_context_get_type begin function GLib.signalnames(::Type{GdkGLContext}) signalnames(supertype(GdkGLContext)) end end - begin - abstract type GdkGLTexture <: GdkTexture end - mutable struct GdkGLTextureLeaf <: GdkGLTexture - handle::Ptr{GObject} - function GdkGLTextureLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkGLTextureLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkGLTexture] = GdkGLTextureLeaf - (GLib.g_type(::Type{T}) where T <: GdkGLTexture) = begin - ccall(("gdk_gl_texture_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkGLTexture GdkTexture libgtk4 gdk_gl_texture_get_type begin function GLib.signalnames(::Type{GdkGLTexture}) vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GdkGLTexture))) @@ -928,23 +578,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkGLTextureBuilder <: GObject end - mutable struct GdkGLTextureBuilderLeaf <: GdkGLTextureBuilder - handle::Ptr{GObject} - function GdkGLTextureBuilderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkGLTextureBuilderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkGLTextureBuilder] = GdkGLTextureBuilderLeaf - (GLib.g_type(::Type{T}) where T <: GdkGLTextureBuilder) = begin - ccall(("gdk_gl_texture_builder_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkGLTextureBuilder GObject libgtk4 gdk_gl_texture_builder_get_type begin function GLib.signalnames(::Type{GdkGLTextureBuilder}) signalnames(supertype(GdkGLTextureBuilder)) @@ -966,23 +600,7 @@ $(Expr(:toplevel, quote handle::Ptr{GdkEvent} end end - begin - abstract type GdkMemoryTexture <: GdkTexture end - mutable struct GdkMemoryTextureLeaf <: GdkMemoryTexture - handle::Ptr{GObject} - function GdkMemoryTextureLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkMemoryTextureLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkMemoryTexture] = GdkMemoryTextureLeaf - (GLib.g_type(::Type{T}) where T <: GdkMemoryTexture) = begin - ccall(("gdk_memory_texture_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkMemoryTexture GdkTexture libgtk4 gdk_memory_texture_get_type begin function GLib.signalnames(::Type{GdkMemoryTexture}) vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GdkMemoryTexture))) @@ -996,23 +614,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkMonitor <: GObject end - mutable struct GdkMonitorLeaf <: GdkMonitor - handle::Ptr{GObject} - function GdkMonitorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkMonitorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkMonitor] = GdkMonitorLeaf - (GLib.g_type(::Type{T}) where T <: GdkMonitor) = begin - ccall(("gdk_monitor_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkMonitor GObject libgtk4 gdk_monitor_get_type begin function GLib.signalnames(::Type{GdkMonitor}) vcat([:invalidate], signalnames(supertype(GdkMonitor))) @@ -1058,23 +660,7 @@ $(Expr(:toplevel, quote handle::Ptr{GdkEvent} end end - begin - abstract type GdkSeat <: GObject end - mutable struct GdkSeatLeaf <: GdkSeat - handle::Ptr{GObject} - function GdkSeatLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkSeatLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkSeat] = GdkSeatLeaf - (GLib.g_type(::Type{T}) where T <: GdkSeat) = begin - ccall(("gdk_seat_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkSeat GObject libgtk4 gdk_seat_get_type begin function GLib.signalnames(::Type{GdkSeat}) vcat([:device_added, :device_removed, :tool_added, :tool_removed], signalnames(supertype(GdkSeat))) @@ -1088,45 +674,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkSnapshot <: GObject end - mutable struct GdkSnapshotLeaf <: GdkSnapshot - handle::Ptr{GObject} - function GdkSnapshotLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkSnapshotLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkSnapshot] = GdkSnapshotLeaf - (GLib.g_type(::Type{T}) where T <: GdkSnapshot) = begin - ccall(("gdk_snapshot_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkSnapshot GObject libgtk4 gdk_snapshot_get_type begin function GLib.signalnames(::Type{GdkSnapshot}) signalnames(supertype(GdkSnapshot)) end end - begin - abstract type GdkSurface <: GObject end - mutable struct GdkSurfaceLeaf <: GdkSurface - handle::Ptr{GObject} - function GdkSurfaceLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkSurfaceLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkSurface] = GdkSurfaceLeaf - (GLib.g_type(::Type{T}) where T <: GdkSurface) = begin - ccall(("gdk_surface_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkSurface GObject libgtk4 gdk_surface_get_type begin function GLib.signalnames(::Type{GdkSurface}) vcat([:enter_monitor, :event, :layout, :leave_monitor, :render], signalnames(supertype(GdkSurface))) @@ -1156,23 +710,7 @@ $(Expr(:toplevel, quote handle::Ptr{GdkEvent} end end - begin - abstract type GdkVulkanContext <: GdkDrawContext end - mutable struct GdkVulkanContextLeaf <: GdkVulkanContext - handle::Ptr{GObject} - function GdkVulkanContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkVulkanContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkVulkanContext] = GdkVulkanContextLeaf - (GLib.g_type(::Type{T}) where T <: GdkVulkanContext) = begin - ccall(("gdk_vulkan_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GdkVulkanContext GdkDrawContext libgtk4 gdk_vulkan_context_get_type begin function GLib.signalnames(::Type{GdkVulkanContext}) vcat([:images_updated], signalnames(supertype(GdkVulkanContext))) diff --git a/src/gen/gdkpixbuf_structs b/src/gen/gdkpixbuf_structs index b6291dd3..d8d41601 100644 --- a/src/gen/gdkpixbuf_structs +++ b/src/gen/gdkpixbuf_structs @@ -71,89 +71,25 @@ $(Expr(:toplevel, quote end @doc "See the [GTK docs](https://docs.gtk.org/gdk-pixbuf/struct.PixbufFormat.html)." GdkPixbufFormat const gtype_wrapper_cache = Dict{Symbol, Type}() - begin - abstract type GdkPixbuf <: GObject end - mutable struct GdkPixbufLeaf <: GdkPixbuf - handle::Ptr{GObject} - function GdkPixbufLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkPixbufLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkPixbuf] = GdkPixbufLeaf - (GLib.g_type(::Type{T}) where T <: GdkPixbuf) = begin - ccall(("gdk_pixbuf_get_type", libgdkpixbuf), GType, ()) - end - end + GLib.@Gobject GdkPixbuf GObject libgdkpixbuf gdk_pixbuf_get_type begin function GLib.signalnames(::Type{GdkPixbuf}) signalnames(supertype(GdkPixbuf)) end end - begin - abstract type GdkPixbufAnimation <: GObject end - mutable struct GdkPixbufAnimationLeaf <: GdkPixbufAnimation - handle::Ptr{GObject} - function GdkPixbufAnimationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkPixbufAnimationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkPixbufAnimation] = GdkPixbufAnimationLeaf - (GLib.g_type(::Type{T}) where T <: GdkPixbufAnimation) = begin - ccall(("gdk_pixbuf_animation_get_type", libgdkpixbuf), GType, ()) - end - end + GLib.@Gobject GdkPixbufAnimation GObject libgdkpixbuf gdk_pixbuf_animation_get_type begin function GLib.signalnames(::Type{GdkPixbufAnimation}) signalnames(supertype(GdkPixbufAnimation)) end end - begin - abstract type GdkPixbufAnimationIter <: GObject end - mutable struct GdkPixbufAnimationIterLeaf <: GdkPixbufAnimationIter - handle::Ptr{GObject} - function GdkPixbufAnimationIterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkPixbufAnimationIterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkPixbufAnimationIter] = GdkPixbufAnimationIterLeaf - (GLib.g_type(::Type{T}) where T <: GdkPixbufAnimationIter) = begin - ccall(("gdk_pixbuf_animation_iter_get_type", libgdkpixbuf), GType, ()) - end - end + GLib.@Gobject GdkPixbufAnimationIter GObject libgdkpixbuf gdk_pixbuf_animation_iter_get_type begin function GLib.signalnames(::Type{GdkPixbufAnimationIter}) signalnames(supertype(GdkPixbufAnimationIter)) end end - begin - abstract type GdkPixbufLoader <: GObject end - mutable struct GdkPixbufLoaderLeaf <: GdkPixbufLoader - handle::Ptr{GObject} - function GdkPixbufLoaderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkPixbufLoaderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkPixbufLoader] = GdkPixbufLoaderLeaf - (GLib.g_type(::Type{T}) where T <: GdkPixbufLoader) = begin - ccall(("gdk_pixbuf_loader_get_type", libgdkpixbuf), GType, ()) - end - end + GLib.@Gobject GdkPixbufLoader GObject libgdkpixbuf gdk_pixbuf_loader_get_type begin function GLib.signalnames(::Type{GdkPixbufLoader}) vcat([:area_prepared, :area_updated, :closed, :size_prepared], signalnames(supertype(GdkPixbufLoader))) @@ -167,67 +103,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GdkPixbufNonAnim <: GdkPixbufAnimation end - mutable struct GdkPixbufNonAnimLeaf <: GdkPixbufNonAnim - handle::Ptr{GObject} - function GdkPixbufNonAnimLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkPixbufNonAnimLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkPixbufNonAnim] = GdkPixbufNonAnimLeaf - (GLib.g_type(::Type{T}) where T <: GdkPixbufNonAnim) = begin - ccall(("gdk_pixbuf_non_anim_get_type", libgdkpixbuf), GType, ()) - end - end + GLib.@Gobject GdkPixbufNonAnim GdkPixbufAnimation libgdkpixbuf gdk_pixbuf_non_anim_get_type begin function GLib.signalnames(::Type{GdkPixbufNonAnim}) signalnames(supertype(GdkPixbufNonAnim)) end end - begin - abstract type GdkPixbufSimpleAnim <: GdkPixbufAnimation end - mutable struct GdkPixbufSimpleAnimLeaf <: GdkPixbufSimpleAnim - handle::Ptr{GObject} - function GdkPixbufSimpleAnimLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkPixbufSimpleAnimLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkPixbufSimpleAnim] = GdkPixbufSimpleAnimLeaf - (GLib.g_type(::Type{T}) where T <: GdkPixbufSimpleAnim) = begin - ccall(("gdk_pixbuf_simple_anim_get_type", libgdkpixbuf), GType, ()) - end - end + GLib.@Gobject GdkPixbufSimpleAnim GdkPixbufAnimation libgdkpixbuf gdk_pixbuf_simple_anim_get_type begin function GLib.signalnames(::Type{GdkPixbufSimpleAnim}) signalnames(supertype(GdkPixbufSimpleAnim)) end end - begin - abstract type GdkPixbufSimpleAnimIter <: GdkPixbufAnimationIter end - mutable struct GdkPixbufSimpleAnimIterLeaf <: GdkPixbufSimpleAnimIter - handle::Ptr{GObject} - function GdkPixbufSimpleAnimIterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GdkPixbufSimpleAnimIterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GdkPixbufSimpleAnimIter] = GdkPixbufSimpleAnimIterLeaf - (GLib.g_type(::Type{T}) where T <: GdkPixbufSimpleAnimIter) = begin - ccall(("gdk_pixbuf_simple_anim_iter_get_type", libgdkpixbuf), GType, ()) - end - end + GLib.@Gobject GdkPixbufSimpleAnimIter GdkPixbufAnimationIter libgdkpixbuf gdk_pixbuf_simple_anim_iter_get_type begin function GLib.signalnames(::Type{GdkPixbufSimpleAnimIter}) signalnames(supertype(GdkPixbufSimpleAnimIter)) diff --git a/src/gen/gio_structs b/src/gen/gio_structs index 646cc38b..61b9fcd0 100644 --- a/src/gen/gio_structs +++ b/src/gen/gio_structs @@ -258,289 +258,45 @@ $(Expr(:toplevel, quote @doc "See the [GTK docs](https://docs.gtk.org/gio/struct.SettingsSchemaKey.html)." GSettingsSchemaKey @doc "See the [GTK docs](https://docs.gtk.org/gio/struct.SettingsSchemaSource.html)." GSettingsSchemaSource @doc "See the [GTK docs](https://docs.gtk.org/gio/struct.SrvTarget.html)." GSrvTarget - struct GAction <: GInterface - handle::Ptr{GObject} - gc::Any - GAction(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GActionGroup <: GInterface - handle::Ptr{GObject} - gc::Any - GActionGroup(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GActionMap <: GInterface - handle::Ptr{GObject} - gc::Any - GActionMap(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GAppInfo <: GInterface - handle::Ptr{GObject} - gc::Any - GAppInfo(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GAsyncInitable <: GInterface - handle::Ptr{GObject} - gc::Any - GAsyncInitable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GAsyncResult <: GInterface - handle::Ptr{GObject} - gc::Any - GAsyncResult(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GConverter <: GInterface - handle::Ptr{GObject} - gc::Any - GConverter(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GDBusInterface <: GInterface - handle::Ptr{GObject} - gc::Any - GDBusInterface(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GDBusObject <: GInterface - handle::Ptr{GObject} - gc::Any - GDBusObject(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GDBusObjectManager <: GInterface - handle::Ptr{GObject} - gc::Any - GDBusObjectManager(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GDatagramBased <: GInterface - handle::Ptr{GObject} - gc::Any - GDatagramBased(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GDebugController <: GInterface - handle::Ptr{GObject} - gc::Any - GDebugController(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GDrive <: GInterface - handle::Ptr{GObject} - gc::Any - GDrive(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GDtlsClientConnection <: GInterface - handle::Ptr{GObject} - gc::Any - GDtlsClientConnection(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GDtlsConnection <: GInterface - handle::Ptr{GObject} - gc::Any - GDtlsConnection(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GDtlsServerConnection <: GInterface - handle::Ptr{GObject} - gc::Any - GDtlsServerConnection(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GFile <: GInterface - handle::Ptr{GObject} - gc::Any - GFile(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GFileDescriptorBased <: GInterface - handle::Ptr{GObject} - gc::Any - GFileDescriptorBased(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GIcon <: GInterface - handle::Ptr{GObject} - gc::Any - GIcon(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GInitable <: GInterface - handle::Ptr{GObject} - gc::Any - GInitable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GListModel <: GInterface - handle::Ptr{GObject} - gc::Any - GListModel(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GLoadableIcon <: GInterface - handle::Ptr{GObject} - gc::Any - GLoadableIcon(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GMemoryMonitor <: GInterface - handle::Ptr{GObject} - gc::Any - GMemoryMonitor(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GMount <: GInterface - handle::Ptr{GObject} - gc::Any - GMount(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GNetworkMonitor <: GInterface - handle::Ptr{GObject} - gc::Any - GNetworkMonitor(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GPollableInputStream <: GInterface - handle::Ptr{GObject} - gc::Any - GPollableInputStream(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GPollableOutputStream <: GInterface - handle::Ptr{GObject} - gc::Any - GPollableOutputStream(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GPowerProfileMonitor <: GInterface - handle::Ptr{GObject} - gc::Any - GPowerProfileMonitor(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GProxy <: GInterface - handle::Ptr{GObject} - gc::Any - GProxy(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GProxyResolver <: GInterface - handle::Ptr{GObject} - gc::Any - GProxyResolver(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GRemoteActionGroup <: GInterface - handle::Ptr{GObject} - gc::Any - GRemoteActionGroup(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GSeekable <: GInterface - handle::Ptr{GObject} - gc::Any - GSeekable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GSocketConnectable <: GInterface - handle::Ptr{GObject} - gc::Any - GSocketConnectable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GTlsBackend <: GInterface - handle::Ptr{GObject} - gc::Any - GTlsBackend(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GTlsClientConnection <: GInterface - handle::Ptr{GObject} - gc::Any - GTlsClientConnection(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GTlsFileDatabase <: GInterface - handle::Ptr{GObject} - gc::Any - GTlsFileDatabase(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GTlsServerConnection <: GInterface - handle::Ptr{GObject} - gc::Any - GTlsServerConnection(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GVolume <: GInterface - handle::Ptr{GObject} - gc::Any - GVolume(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - begin - abstract type GAppInfoMonitor <: GObject end - mutable struct GAppInfoMonitorLeaf <: GAppInfoMonitor - handle::Ptr{GObject} - function GAppInfoMonitorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GAppInfoMonitorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GAppInfoMonitor] = GAppInfoMonitorLeaf - (GLib.g_type(::Type{T}) where T <: GAppInfoMonitor) = begin - ccall(("g_app_info_monitor_get_type", libgio), GType, ()) - end - end + GLib.@Giface GAction libgio g_action_get_type + GLib.@Giface GActionGroup libgio g_action_group_get_type + GLib.@Giface GActionMap libgio g_action_map_get_type + GLib.@Giface GAppInfo libgio g_app_info_get_type + GLib.@Giface GAsyncInitable libgio g_async_initable_get_type + GLib.@Giface GAsyncResult libgio g_async_result_get_type + GLib.@Giface GConverter libgio g_converter_get_type + GLib.@Giface GDBusInterface libgio g_dbus_interface_get_type + GLib.@Giface GDBusObject libgio g_dbus_object_get_type + GLib.@Giface GDBusObjectManager libgio g_dbus_object_manager_get_type + GLib.@Giface GDatagramBased libgio g_datagram_based_get_type + GLib.@Giface GDebugController libgio g_debug_controller_get_type + GLib.@Giface GDrive libgio g_drive_get_type + GLib.@Giface GDtlsClientConnection libgio g_dtls_client_connection_get_type + GLib.@Giface GDtlsConnection libgio g_dtls_connection_get_type + GLib.@Giface GDtlsServerConnection libgio g_dtls_server_connection_get_type + GLib.@Giface GFile libgio g_file_get_type + GLib.@Giface GFileDescriptorBased libgio g_file_descriptor_based_get_type + GLib.@Giface GIcon libgio g_icon_get_type + GLib.@Giface GInitable libgio g_initable_get_type + GLib.@Giface GListModel libgio g_list_model_get_type + GLib.@Giface GLoadableIcon libgio g_loadable_icon_get_type + GLib.@Giface GMemoryMonitor libgio g_memory_monitor_get_type + GLib.@Giface GMount libgio g_mount_get_type + GLib.@Giface GNetworkMonitor libgio g_network_monitor_get_type + GLib.@Giface GPollableInputStream libgio g_pollable_input_stream_get_type + GLib.@Giface GPollableOutputStream libgio g_pollable_output_stream_get_type + GLib.@Giface GPowerProfileMonitor libgio g_power_profile_monitor_get_type + GLib.@Giface GProxy libgio g_proxy_get_type + GLib.@Giface GProxyResolver libgio g_proxy_resolver_get_type + GLib.@Giface GRemoteActionGroup libgio g_remote_action_group_get_type + GLib.@Giface GSeekable libgio g_seekable_get_type + GLib.@Giface GSocketConnectable libgio g_socket_connectable_get_type + GLib.@Giface GTlsBackend libgio g_tls_backend_get_type + GLib.@Giface GTlsClientConnection libgio g_tls_client_connection_get_type + GLib.@Giface GTlsFileDatabase libgio g_tls_file_database_get_type + GLib.@Giface GTlsServerConnection libgio g_tls_server_connection_get_type + GLib.@Giface GVolume libgio g_volume_get_type + GLib.@Gobject GAppInfoMonitor GObject libgio g_app_info_monitor_get_type begin function GLib.signalnames(::Type{GAppInfoMonitor}) vcat([:changed], signalnames(supertype(GAppInfoMonitor))) @@ -554,23 +310,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GAppLaunchContext <: GObject end - mutable struct GAppLaunchContextLeaf <: GAppLaunchContext - handle::Ptr{GObject} - function GAppLaunchContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GAppLaunchContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GAppLaunchContext] = GAppLaunchContextLeaf - (GLib.g_type(::Type{T}) where T <: GAppLaunchContext) = begin - ccall(("g_app_launch_context_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GAppLaunchContext GObject libgio g_app_launch_context_get_type begin function GLib.signalnames(::Type{GAppLaunchContext}) vcat([:launch_failed, :launch_started, :launched], signalnames(supertype(GAppLaunchContext))) @@ -584,23 +324,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GApplication <: GObject end - mutable struct GApplicationLeaf <: GApplication - handle::Ptr{GObject} - function GApplicationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GApplicationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GApplication] = GApplicationLeaf - (GLib.g_type(::Type{T}) where T <: GApplication) = begin - ccall(("g_application_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GApplication GObject libgio g_application_get_type begin function GLib.signalnames(::Type{GApplication}) vcat([:activate, :command_line, :handle_local_options, :name_lost, :open, :shutdown, :startup, :action_added, :action_enabled_changed, :action_removed, :action_state_changed], signalnames(supertype(GApplication))) @@ -614,199 +338,55 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GApplicationCommandLine <: GObject end - mutable struct GApplicationCommandLineLeaf <: GApplicationCommandLine - handle::Ptr{GObject} - function GApplicationCommandLineLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GApplicationCommandLineLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GApplicationCommandLine] = GApplicationCommandLineLeaf - (GLib.g_type(::Type{T}) where T <: GApplicationCommandLine) = begin - ccall(("g_application_command_line_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GApplicationCommandLine GObject libgio g_application_command_line_get_type begin function GLib.signalnames(::Type{GApplicationCommandLine}) signalnames(supertype(GApplicationCommandLine)) end end - begin - abstract type GInputStream <: GObject end - mutable struct GInputStreamLeaf <: GInputStream - handle::Ptr{GObject} - function GInputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GInputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GInputStream] = GInputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GInputStream) = begin - ccall(("g_input_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GInputStream GObject libgio g_input_stream_get_type begin function GLib.signalnames(::Type{GInputStream}) signalnames(supertype(GInputStream)) end end - begin - abstract type GFilterInputStream <: GInputStream end - mutable struct GFilterInputStreamLeaf <: GFilterInputStream - handle::Ptr{GObject} - function GFilterInputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFilterInputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFilterInputStream] = GFilterInputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GFilterInputStream) = begin - ccall(("g_filter_input_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFilterInputStream GInputStream libgio g_filter_input_stream_get_type begin function GLib.signalnames(::Type{GFilterInputStream}) signalnames(supertype(GFilterInputStream)) end end - begin - abstract type GBufferedInputStream <: GFilterInputStream end - mutable struct GBufferedInputStreamLeaf <: GBufferedInputStream - handle::Ptr{GObject} - function GBufferedInputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GBufferedInputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GBufferedInputStream] = GBufferedInputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GBufferedInputStream) = begin - ccall(("g_buffered_input_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GBufferedInputStream GFilterInputStream libgio g_buffered_input_stream_get_type begin function GLib.signalnames(::Type{GBufferedInputStream}) signalnames(supertype(GBufferedInputStream)) end end - begin - abstract type GOutputStream <: GObject end - mutable struct GOutputStreamLeaf <: GOutputStream - handle::Ptr{GObject} - function GOutputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GOutputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GOutputStream] = GOutputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GOutputStream) = begin - ccall(("g_output_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GOutputStream GObject libgio g_output_stream_get_type begin function GLib.signalnames(::Type{GOutputStream}) signalnames(supertype(GOutputStream)) end end - begin - abstract type GFilterOutputStream <: GOutputStream end - mutable struct GFilterOutputStreamLeaf <: GFilterOutputStream - handle::Ptr{GObject} - function GFilterOutputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFilterOutputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFilterOutputStream] = GFilterOutputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GFilterOutputStream) = begin - ccall(("g_filter_output_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFilterOutputStream GOutputStream libgio g_filter_output_stream_get_type begin function GLib.signalnames(::Type{GFilterOutputStream}) signalnames(supertype(GFilterOutputStream)) end end - begin - abstract type GBufferedOutputStream <: GFilterOutputStream end - mutable struct GBufferedOutputStreamLeaf <: GBufferedOutputStream - handle::Ptr{GObject} - function GBufferedOutputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GBufferedOutputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GBufferedOutputStream] = GBufferedOutputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GBufferedOutputStream) = begin - ccall(("g_buffered_output_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GBufferedOutputStream GFilterOutputStream libgio g_buffered_output_stream_get_type begin function GLib.signalnames(::Type{GBufferedOutputStream}) signalnames(supertype(GBufferedOutputStream)) end end - begin - abstract type GBytesIcon <: GObject end - mutable struct GBytesIconLeaf <: GBytesIcon - handle::Ptr{GObject} - function GBytesIconLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GBytesIconLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GBytesIcon] = GBytesIconLeaf - (GLib.g_type(::Type{T}) where T <: GBytesIcon) = begin - ccall(("g_bytes_icon_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GBytesIcon GObject libgio g_bytes_icon_get_type begin function GLib.signalnames(::Type{GBytesIcon}) signalnames(supertype(GBytesIcon)) end end - begin - abstract type GCancellable <: GObject end - mutable struct GCancellableLeaf <: GCancellable - handle::Ptr{GObject} - function GCancellableLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GCancellableLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GCancellable] = GCancellableLeaf - (GLib.g_type(::Type{T}) where T <: GCancellable) = begin - ccall(("g_cancellable_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GCancellable GObject libgio g_cancellable_get_type begin function GLib.signalnames(::Type{GCancellable}) vcat([:cancelled], signalnames(supertype(GCancellable))) @@ -820,111 +400,31 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GCharsetConverter <: GObject end - mutable struct GCharsetConverterLeaf <: GCharsetConverter - handle::Ptr{GObject} - function GCharsetConverterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GCharsetConverterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GCharsetConverter] = GCharsetConverterLeaf - (GLib.g_type(::Type{T}) where T <: GCharsetConverter) = begin - ccall(("g_charset_converter_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GCharsetConverter GObject libgio g_charset_converter_get_type begin function GLib.signalnames(::Type{GCharsetConverter}) signalnames(supertype(GCharsetConverter)) end end - begin - abstract type GConverterInputStream <: GFilterInputStream end - mutable struct GConverterInputStreamLeaf <: GConverterInputStream - handle::Ptr{GObject} - function GConverterInputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GConverterInputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GConverterInputStream] = GConverterInputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GConverterInputStream) = begin - ccall(("g_converter_input_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GConverterInputStream GFilterInputStream libgio g_converter_input_stream_get_type begin function GLib.signalnames(::Type{GConverterInputStream}) signalnames(supertype(GConverterInputStream)) end end - begin - abstract type GConverterOutputStream <: GFilterOutputStream end - mutable struct GConverterOutputStreamLeaf <: GConverterOutputStream - handle::Ptr{GObject} - function GConverterOutputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GConverterOutputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GConverterOutputStream] = GConverterOutputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GConverterOutputStream) = begin - ccall(("g_converter_output_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GConverterOutputStream GFilterOutputStream libgio g_converter_output_stream_get_type begin function GLib.signalnames(::Type{GConverterOutputStream}) signalnames(supertype(GConverterOutputStream)) end end - begin - abstract type GCredentials <: GObject end - mutable struct GCredentialsLeaf <: GCredentials - handle::Ptr{GObject} - function GCredentialsLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GCredentialsLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GCredentials] = GCredentialsLeaf - (GLib.g_type(::Type{T}) where T <: GCredentials) = begin - ccall(("g_credentials_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GCredentials GObject libgio g_credentials_get_type begin function GLib.signalnames(::Type{GCredentials}) signalnames(supertype(GCredentials)) end end - begin - abstract type GDBusActionGroup <: GObject end - mutable struct GDBusActionGroupLeaf <: GDBusActionGroup - handle::Ptr{GObject} - function GDBusActionGroupLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusActionGroupLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusActionGroup] = GDBusActionGroupLeaf - (GLib.g_type(::Type{T}) where T <: GDBusActionGroup) = begin - ccall(("g_dbus_action_group_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusActionGroup GObject libgio g_dbus_action_group_get_type begin function GLib.signalnames(::Type{GDBusActionGroup}) vcat([:action_added, :action_enabled_changed, :action_removed, :action_state_changed], signalnames(supertype(GDBusActionGroup))) @@ -938,23 +438,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GDBusAuthObserver <: GObject end - mutable struct GDBusAuthObserverLeaf <: GDBusAuthObserver - handle::Ptr{GObject} - function GDBusAuthObserverLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusAuthObserverLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusAuthObserver] = GDBusAuthObserverLeaf - (GLib.g_type(::Type{T}) where T <: GDBusAuthObserver) = begin - ccall(("g_dbus_auth_observer_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusAuthObserver GObject libgio g_dbus_auth_observer_get_type begin function GLib.signalnames(::Type{GDBusAuthObserver}) vcat([:allow_mechanism, :authorize_authenticated_peer], signalnames(supertype(GDBusAuthObserver))) @@ -968,23 +452,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GDBusConnection <: GObject end - mutable struct GDBusConnectionLeaf <: GDBusConnection - handle::Ptr{GObject} - function GDBusConnectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusConnectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusConnection] = GDBusConnectionLeaf - (GLib.g_type(::Type{T}) where T <: GDBusConnection) = begin - ccall(("g_dbus_connection_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusConnection GObject libgio g_dbus_connection_get_type begin function GLib.signalnames(::Type{GDBusConnection}) vcat([:closed], signalnames(supertype(GDBusConnection))) @@ -998,23 +466,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GMenuModel <: GObject end - mutable struct GMenuModelLeaf <: GMenuModel - handle::Ptr{GObject} - function GMenuModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GMenuModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GMenuModel] = GMenuModelLeaf - (GLib.g_type(::Type{T}) where T <: GMenuModel) = begin - ccall(("g_menu_model_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GMenuModel GObject libgio g_menu_model_get_type begin function GLib.signalnames(::Type{GMenuModel}) vcat([:items_changed], signalnames(supertype(GMenuModel))) @@ -1028,89 +480,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GDBusMenuModel <: GMenuModel end - mutable struct GDBusMenuModelLeaf <: GDBusMenuModel - handle::Ptr{GObject} - function GDBusMenuModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusMenuModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusMenuModel] = GDBusMenuModelLeaf - (GLib.g_type(::Type{T}) where T <: GDBusMenuModel) = begin - ccall(("g_dbus_menu_model_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusMenuModel GMenuModel libgio g_dbus_menu_model_get_type begin function GLib.signalnames(::Type{GDBusMenuModel}) signalnames(supertype(GDBusMenuModel)) end end - begin - abstract type GDBusMessage <: GObject end - mutable struct GDBusMessageLeaf <: GDBusMessage - handle::Ptr{GObject} - function GDBusMessageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusMessageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusMessage] = GDBusMessageLeaf - (GLib.g_type(::Type{T}) where T <: GDBusMessage) = begin - ccall(("g_dbus_message_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusMessage GObject libgio g_dbus_message_get_type begin function GLib.signalnames(::Type{GDBusMessage}) signalnames(supertype(GDBusMessage)) end end - begin - abstract type GDBusMethodInvocation <: GObject end - mutable struct GDBusMethodInvocationLeaf <: GDBusMethodInvocation - handle::Ptr{GObject} - function GDBusMethodInvocationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusMethodInvocationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusMethodInvocation] = GDBusMethodInvocationLeaf - (GLib.g_type(::Type{T}) where T <: GDBusMethodInvocation) = begin - ccall(("g_dbus_method_invocation_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusMethodInvocation GObject libgio g_dbus_method_invocation_get_type begin function GLib.signalnames(::Type{GDBusMethodInvocation}) signalnames(supertype(GDBusMethodInvocation)) end end - begin - abstract type GDBusObjectManagerClient <: GObject end - mutable struct GDBusObjectManagerClientLeaf <: GDBusObjectManagerClient - handle::Ptr{GObject} - function GDBusObjectManagerClientLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusObjectManagerClientLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusObjectManagerClient] = GDBusObjectManagerClientLeaf - (GLib.g_type(::Type{T}) where T <: GDBusObjectManagerClient) = begin - ccall(("g_dbus_object_manager_client_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusObjectManagerClient GObject libgio g_dbus_object_manager_client_get_type begin function GLib.signalnames(::Type{GDBusObjectManagerClient}) vcat([:interface_proxy_properties_changed, :interface_proxy_signal, :interface_added, :interface_removed, :object_added, :object_removed], signalnames(supertype(GDBusObjectManagerClient))) @@ -1124,23 +512,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GDBusObjectProxy <: GObject end - mutable struct GDBusObjectProxyLeaf <: GDBusObjectProxy - handle::Ptr{GObject} - function GDBusObjectProxyLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusObjectProxyLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusObjectProxy] = GDBusObjectProxyLeaf - (GLib.g_type(::Type{T}) where T <: GDBusObjectProxy) = begin - ccall(("g_dbus_object_proxy_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusObjectProxy GObject libgio g_dbus_object_proxy_get_type begin function GLib.signalnames(::Type{GDBusObjectProxy}) vcat([:interface_added, :interface_removed], signalnames(supertype(GDBusObjectProxy))) @@ -1154,23 +526,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GDBusProxy <: GObject end - mutable struct GDBusProxyLeaf <: GDBusProxy - handle::Ptr{GObject} - function GDBusProxyLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusProxyLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusProxy] = GDBusProxyLeaf - (GLib.g_type(::Type{T}) where T <: GDBusProxy) = begin - ccall(("g_dbus_proxy_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusProxy GObject libgio g_dbus_proxy_get_type begin function GLib.signalnames(::Type{GDBusProxy}) vcat([:g_properties_changed, :g_signal], signalnames(supertype(GDBusProxy))) @@ -1184,23 +540,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GDBusServer <: GObject end - mutable struct GDBusServerLeaf <: GDBusServer - handle::Ptr{GObject} - function GDBusServerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDBusServerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDBusServer] = GDBusServerLeaf - (GLib.g_type(::Type{T}) where T <: GDBusServer) = begin - ccall(("g_dbus_server_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDBusServer GObject libgio g_dbus_server_get_type begin function GLib.signalnames(::Type{GDBusServer}) vcat([:new_connection], signalnames(supertype(GDBusServer))) @@ -1214,265 +554,73 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GDataInputStream <: GBufferedInputStream end - mutable struct GDataInputStreamLeaf <: GDataInputStream - handle::Ptr{GObject} - function GDataInputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDataInputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDataInputStream] = GDataInputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GDataInputStream) = begin - ccall(("g_data_input_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDataInputStream GBufferedInputStream libgio g_data_input_stream_get_type begin function GLib.signalnames(::Type{GDataInputStream}) signalnames(supertype(GDataInputStream)) end end - begin - abstract type GDataOutputStream <: GFilterOutputStream end - mutable struct GDataOutputStreamLeaf <: GDataOutputStream - handle::Ptr{GObject} - function GDataOutputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDataOutputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDataOutputStream] = GDataOutputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GDataOutputStream) = begin - ccall(("g_data_output_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDataOutputStream GFilterOutputStream libgio g_data_output_stream_get_type begin function GLib.signalnames(::Type{GDataOutputStream}) signalnames(supertype(GDataOutputStream)) end end - begin - abstract type GDesktopAppInfo <: GObject end - mutable struct GDesktopAppInfoLeaf <: GDesktopAppInfo - handle::Ptr{GObject} - function GDesktopAppInfoLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GDesktopAppInfoLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GDesktopAppInfo] = GDesktopAppInfoLeaf - (GLib.g_type(::Type{T}) where T <: GDesktopAppInfo) = begin - ccall(("g_desktop_app_info_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GDesktopAppInfo GObject libgio g_desktop_app_info_get_type begin function GLib.signalnames(::Type{GDesktopAppInfo}) signalnames(supertype(GDesktopAppInfo)) end end - begin - abstract type GEmblem <: GObject end - mutable struct GEmblemLeaf <: GEmblem - handle::Ptr{GObject} - function GEmblemLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GEmblemLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GEmblem] = GEmblemLeaf - (GLib.g_type(::Type{T}) where T <: GEmblem) = begin - ccall(("g_emblem_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GEmblem GObject libgio g_emblem_get_type begin function GLib.signalnames(::Type{GEmblem}) signalnames(supertype(GEmblem)) end end - begin - abstract type GEmblemedIcon <: GObject end - mutable struct GEmblemedIconLeaf <: GEmblemedIcon - handle::Ptr{GObject} - function GEmblemedIconLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GEmblemedIconLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GEmblemedIcon] = GEmblemedIconLeaf - (GLib.g_type(::Type{T}) where T <: GEmblemedIcon) = begin - ccall(("g_emblemed_icon_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GEmblemedIcon GObject libgio g_emblemed_icon_get_type begin function GLib.signalnames(::Type{GEmblemedIcon}) signalnames(supertype(GEmblemedIcon)) end end - begin - abstract type GFileEnumerator <: GObject end - mutable struct GFileEnumeratorLeaf <: GFileEnumerator - handle::Ptr{GObject} - function GFileEnumeratorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFileEnumeratorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFileEnumerator] = GFileEnumeratorLeaf - (GLib.g_type(::Type{T}) where T <: GFileEnumerator) = begin - ccall(("g_file_enumerator_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFileEnumerator GObject libgio g_file_enumerator_get_type begin function GLib.signalnames(::Type{GFileEnumerator}) signalnames(supertype(GFileEnumerator)) end end - begin - abstract type GIOStream <: GObject end - mutable struct GIOStreamLeaf <: GIOStream - handle::Ptr{GObject} - function GIOStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GIOStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GIOStream] = GIOStreamLeaf - (GLib.g_type(::Type{T}) where T <: GIOStream) = begin - ccall(("g_io_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GIOStream GObject libgio g_io_stream_get_type begin function GLib.signalnames(::Type{GIOStream}) signalnames(supertype(GIOStream)) end end - begin - abstract type GFileIOStream <: GIOStream end - mutable struct GFileIOStreamLeaf <: GFileIOStream - handle::Ptr{GObject} - function GFileIOStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFileIOStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFileIOStream] = GFileIOStreamLeaf - (GLib.g_type(::Type{T}) where T <: GFileIOStream) = begin - ccall(("g_file_io_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFileIOStream GIOStream libgio g_file_io_stream_get_type begin function GLib.signalnames(::Type{GFileIOStream}) signalnames(supertype(GFileIOStream)) end end - begin - abstract type GFileIcon <: GObject end - mutable struct GFileIconLeaf <: GFileIcon - handle::Ptr{GObject} - function GFileIconLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFileIconLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFileIcon] = GFileIconLeaf - (GLib.g_type(::Type{T}) where T <: GFileIcon) = begin - ccall(("g_file_icon_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFileIcon GObject libgio g_file_icon_get_type begin function GLib.signalnames(::Type{GFileIcon}) signalnames(supertype(GFileIcon)) end end - begin - abstract type GFileInfo <: GObject end - mutable struct GFileInfoLeaf <: GFileInfo - handle::Ptr{GObject} - function GFileInfoLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFileInfoLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFileInfo] = GFileInfoLeaf - (GLib.g_type(::Type{T}) where T <: GFileInfo) = begin - ccall(("g_file_info_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFileInfo GObject libgio g_file_info_get_type begin function GLib.signalnames(::Type{GFileInfo}) signalnames(supertype(GFileInfo)) end end - begin - abstract type GFileInputStream <: GInputStream end - mutable struct GFileInputStreamLeaf <: GFileInputStream - handle::Ptr{GObject} - function GFileInputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFileInputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFileInputStream] = GFileInputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GFileInputStream) = begin - ccall(("g_file_input_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFileInputStream GInputStream libgio g_file_input_stream_get_type begin function GLib.signalnames(::Type{GFileInputStream}) signalnames(supertype(GFileInputStream)) end end - begin - abstract type GFileMonitor <: GObject end - mutable struct GFileMonitorLeaf <: GFileMonitor - handle::Ptr{GObject} - function GFileMonitorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFileMonitorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFileMonitor] = GFileMonitorLeaf - (GLib.g_type(::Type{T}) where T <: GFileMonitor) = begin - ccall(("g_file_monitor_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFileMonitor GObject libgio g_file_monitor_get_type begin function GLib.signalnames(::Type{GFileMonitor}) vcat([:changed], signalnames(supertype(GFileMonitor))) @@ -1486,45 +634,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GFileOutputStream <: GOutputStream end - mutable struct GFileOutputStreamLeaf <: GFileOutputStream - handle::Ptr{GObject} - function GFileOutputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFileOutputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFileOutputStream] = GFileOutputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GFileOutputStream) = begin - ccall(("g_file_output_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFileOutputStream GOutputStream libgio g_file_output_stream_get_type begin function GLib.signalnames(::Type{GFileOutputStream}) signalnames(supertype(GFileOutputStream)) end end - begin - abstract type GFilenameCompleter <: GObject end - mutable struct GFilenameCompleterLeaf <: GFilenameCompleter - handle::Ptr{GObject} - function GFilenameCompleterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GFilenameCompleterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GFilenameCompleter] = GFilenameCompleterLeaf - (GLib.g_type(::Type{T}) where T <: GFilenameCompleter) = begin - ccall(("g_filename_completer_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GFilenameCompleter GObject libgio g_filename_completer_get_type begin function GLib.signalnames(::Type{GFilenameCompleter}) vcat([:got_completion_data], signalnames(supertype(GFilenameCompleter))) @@ -1538,133 +654,37 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GIOModule <: GTypeModule end - mutable struct GIOModuleLeaf <: GIOModule - handle::Ptr{GObject} - function GIOModuleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GIOModuleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GIOModule] = GIOModuleLeaf - (GLib.g_type(::Type{T}) where T <: GIOModule) = begin - ccall(("g_io_module_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GIOModule GTypeModule libgio g_io_module_get_type begin function GLib.signalnames(::Type{GIOModule}) signalnames(supertype(GIOModule)) end end - begin - abstract type GInetAddress <: GObject end - mutable struct GInetAddressLeaf <: GInetAddress - handle::Ptr{GObject} - function GInetAddressLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GInetAddressLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GInetAddress] = GInetAddressLeaf - (GLib.g_type(::Type{T}) where T <: GInetAddress) = begin - ccall(("g_inet_address_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GInetAddress GObject libgio g_inet_address_get_type begin function GLib.signalnames(::Type{GInetAddress}) signalnames(supertype(GInetAddress)) end end - begin - abstract type GInetAddressMask <: GObject end - mutable struct GInetAddressMaskLeaf <: GInetAddressMask - handle::Ptr{GObject} - function GInetAddressMaskLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GInetAddressMaskLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GInetAddressMask] = GInetAddressMaskLeaf - (GLib.g_type(::Type{T}) where T <: GInetAddressMask) = begin - ccall(("g_inet_address_mask_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GInetAddressMask GObject libgio g_inet_address_mask_get_type begin function GLib.signalnames(::Type{GInetAddressMask}) signalnames(supertype(GInetAddressMask)) end end - begin - abstract type GSocketAddress <: GObject end - mutable struct GSocketAddressLeaf <: GSocketAddress - handle::Ptr{GObject} - function GSocketAddressLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSocketAddressLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSocketAddress] = GSocketAddressLeaf - (GLib.g_type(::Type{T}) where T <: GSocketAddress) = begin - ccall(("g_socket_address_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSocketAddress GObject libgio g_socket_address_get_type begin function GLib.signalnames(::Type{GSocketAddress}) signalnames(supertype(GSocketAddress)) end end - begin - abstract type GInetSocketAddress <: GSocketAddress end - mutable struct GInetSocketAddressLeaf <: GInetSocketAddress - handle::Ptr{GObject} - function GInetSocketAddressLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GInetSocketAddressLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GInetSocketAddress] = GInetSocketAddressLeaf - (GLib.g_type(::Type{T}) where T <: GInetSocketAddress) = begin - ccall(("g_inet_socket_address_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GInetSocketAddress GSocketAddress libgio g_inet_socket_address_get_type begin function GLib.signalnames(::Type{GInetSocketAddress}) signalnames(supertype(GInetSocketAddress)) end end - begin - abstract type GListStore <: GObject end - mutable struct GListStoreLeaf <: GListStore - handle::Ptr{GObject} - function GListStoreLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GListStoreLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GListStore] = GListStoreLeaf - (GLib.g_type(::Type{T}) where T <: GListStore) = begin - ccall(("g_list_store_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GListStore GObject libgio g_list_store_get_type begin function GLib.signalnames(::Type{GListStore}) vcat([:items_changed], signalnames(supertype(GListStore))) @@ -1678,155 +698,43 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GMemoryInputStream <: GInputStream end - mutable struct GMemoryInputStreamLeaf <: GMemoryInputStream - handle::Ptr{GObject} - function GMemoryInputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GMemoryInputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GMemoryInputStream] = GMemoryInputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GMemoryInputStream) = begin - ccall(("g_memory_input_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GMemoryInputStream GInputStream libgio g_memory_input_stream_get_type begin function GLib.signalnames(::Type{GMemoryInputStream}) signalnames(supertype(GMemoryInputStream)) end end - begin - abstract type GMemoryOutputStream <: GOutputStream end - mutable struct GMemoryOutputStreamLeaf <: GMemoryOutputStream - handle::Ptr{GObject} - function GMemoryOutputStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GMemoryOutputStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GMemoryOutputStream] = GMemoryOutputStreamLeaf - (GLib.g_type(::Type{T}) where T <: GMemoryOutputStream) = begin - ccall(("g_memory_output_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GMemoryOutputStream GOutputStream libgio g_memory_output_stream_get_type begin function GLib.signalnames(::Type{GMemoryOutputStream}) signalnames(supertype(GMemoryOutputStream)) end end - begin - abstract type GMenu <: GMenuModel end - mutable struct GMenuLeaf <: GMenu - handle::Ptr{GObject} - function GMenuLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GMenuLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GMenu] = GMenuLeaf - (GLib.g_type(::Type{T}) where T <: GMenu) = begin - ccall(("g_menu_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GMenu GMenuModel libgio g_menu_get_type begin function GLib.signalnames(::Type{GMenu}) signalnames(supertype(GMenu)) end end - begin - abstract type GMenuAttributeIter <: GObject end - mutable struct GMenuAttributeIterLeaf <: GMenuAttributeIter - handle::Ptr{GObject} - function GMenuAttributeIterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GMenuAttributeIterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GMenuAttributeIter] = GMenuAttributeIterLeaf - (GLib.g_type(::Type{T}) where T <: GMenuAttributeIter) = begin - ccall(("g_menu_attribute_iter_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GMenuAttributeIter GObject libgio g_menu_attribute_iter_get_type begin function GLib.signalnames(::Type{GMenuAttributeIter}) signalnames(supertype(GMenuAttributeIter)) end end - begin - abstract type GMenuItem <: GObject end - mutable struct GMenuItemLeaf <: GMenuItem - handle::Ptr{GObject} - function GMenuItemLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GMenuItemLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GMenuItem] = GMenuItemLeaf - (GLib.g_type(::Type{T}) where T <: GMenuItem) = begin - ccall(("g_menu_item_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GMenuItem GObject libgio g_menu_item_get_type begin function GLib.signalnames(::Type{GMenuItem}) signalnames(supertype(GMenuItem)) end end - begin - abstract type GMenuLinkIter <: GObject end - mutable struct GMenuLinkIterLeaf <: GMenuLinkIter - handle::Ptr{GObject} - function GMenuLinkIterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GMenuLinkIterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GMenuLinkIter] = GMenuLinkIterLeaf - (GLib.g_type(::Type{T}) where T <: GMenuLinkIter) = begin - ccall(("g_menu_link_iter_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GMenuLinkIter GObject libgio g_menu_link_iter_get_type begin function GLib.signalnames(::Type{GMenuLinkIter}) signalnames(supertype(GMenuLinkIter)) end end - begin - abstract type GMountOperation <: GObject end - mutable struct GMountOperationLeaf <: GMountOperation - handle::Ptr{GObject} - function GMountOperationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GMountOperationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GMountOperation] = GMountOperationLeaf - (GLib.g_type(::Type{T}) where T <: GMountOperation) = begin - ccall(("g_mount_operation_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GMountOperation GObject libgio g_mount_operation_get_type begin function GLib.signalnames(::Type{GMountOperation}) vcat([:aborted, :ask_password, :ask_question, :reply, :show_processes, :show_unmount_progress], signalnames(supertype(GMountOperation))) @@ -1840,45 +748,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GNativeSocketAddress <: GSocketAddress end - mutable struct GNativeSocketAddressLeaf <: GNativeSocketAddress - handle::Ptr{GObject} - function GNativeSocketAddressLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GNativeSocketAddressLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GNativeSocketAddress] = GNativeSocketAddressLeaf - (GLib.g_type(::Type{T}) where T <: GNativeSocketAddress) = begin - ccall(("g_native_socket_address_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GNativeSocketAddress GSocketAddress libgio g_native_socket_address_get_type begin function GLib.signalnames(::Type{GNativeSocketAddress}) signalnames(supertype(GNativeSocketAddress)) end end - begin - abstract type GVolumeMonitor <: GObject end - mutable struct GVolumeMonitorLeaf <: GVolumeMonitor - handle::Ptr{GObject} - function GVolumeMonitorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GVolumeMonitorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GVolumeMonitor] = GVolumeMonitorLeaf - (GLib.g_type(::Type{T}) where T <: GVolumeMonitor) = begin - ccall(("g_volume_monitor_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GVolumeMonitor GObject libgio g_volume_monitor_get_type begin function GLib.signalnames(::Type{GVolumeMonitor}) vcat([:drive_changed, :drive_connected, :drive_disconnected, :drive_eject_button, :drive_stop_button, :mount_added, :mount_changed, :mount_pre_unmount, :mount_removed, :volume_added, :volume_changed, :volume_removed], signalnames(supertype(GVolumeMonitor))) @@ -1887,226 +763,66 @@ $(Expr(:toplevel, quote function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GVolumeMonitor eval((d[name])[1]) end - function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GVolumeMonitor - Tuple(eval.((d[name])[2])) - end - end - end - begin - abstract type GNativeVolumeMonitor <: GVolumeMonitor end - mutable struct GNativeVolumeMonitorLeaf <: GNativeVolumeMonitor - handle::Ptr{GObject} - function GNativeVolumeMonitorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GNativeVolumeMonitorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GNativeVolumeMonitor] = GNativeVolumeMonitorLeaf - (GLib.g_type(::Type{T}) where T <: GNativeVolumeMonitor) = begin - ccall(("g_native_volume_monitor_get_type", libgio), GType, ()) + function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GVolumeMonitor + Tuple(eval.((d[name])[2])) end + end end + GLib.@Gobject GNativeVolumeMonitor GVolumeMonitor libgio g_native_volume_monitor_get_type begin function GLib.signalnames(::Type{GNativeVolumeMonitor}) signalnames(supertype(GNativeVolumeMonitor)) end end - begin - abstract type GNetworkAddress <: GObject end - mutable struct GNetworkAddressLeaf <: GNetworkAddress - handle::Ptr{GObject} - function GNetworkAddressLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GNetworkAddressLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GNetworkAddress] = GNetworkAddressLeaf - (GLib.g_type(::Type{T}) where T <: GNetworkAddress) = begin - ccall(("g_network_address_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GNetworkAddress GObject libgio g_network_address_get_type begin function GLib.signalnames(::Type{GNetworkAddress}) signalnames(supertype(GNetworkAddress)) end end - begin - abstract type GNetworkService <: GObject end - mutable struct GNetworkServiceLeaf <: GNetworkService - handle::Ptr{GObject} - function GNetworkServiceLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GNetworkServiceLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GNetworkService] = GNetworkServiceLeaf - (GLib.g_type(::Type{T}) where T <: GNetworkService) = begin - ccall(("g_network_service_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GNetworkService GObject libgio g_network_service_get_type begin function GLib.signalnames(::Type{GNetworkService}) signalnames(supertype(GNetworkService)) end end - begin - abstract type GNotification <: GObject end - mutable struct GNotificationLeaf <: GNotification - handle::Ptr{GObject} - function GNotificationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GNotificationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GNotification] = GNotificationLeaf - (GLib.g_type(::Type{T}) where T <: GNotification) = begin - ccall(("g_notification_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GNotification GObject libgio g_notification_get_type begin function GLib.signalnames(::Type{GNotification}) signalnames(supertype(GNotification)) end end - begin - abstract type GPermission <: GObject end - mutable struct GPermissionLeaf <: GPermission - handle::Ptr{GObject} - function GPermissionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GPermissionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GPermission] = GPermissionLeaf - (GLib.g_type(::Type{T}) where T <: GPermission) = begin - ccall(("g_permission_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GPermission GObject libgio g_permission_get_type begin function GLib.signalnames(::Type{GPermission}) signalnames(supertype(GPermission)) end end - begin - abstract type GPropertyAction <: GObject end - mutable struct GPropertyActionLeaf <: GPropertyAction - handle::Ptr{GObject} - function GPropertyActionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GPropertyActionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GPropertyAction] = GPropertyActionLeaf - (GLib.g_type(::Type{T}) where T <: GPropertyAction) = begin - ccall(("g_property_action_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GPropertyAction GObject libgio g_property_action_get_type begin function GLib.signalnames(::Type{GPropertyAction}) signalnames(supertype(GPropertyAction)) end end - begin - abstract type GProxyAddress <: GInetSocketAddress end - mutable struct GProxyAddressLeaf <: GProxyAddress - handle::Ptr{GObject} - function GProxyAddressLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GProxyAddressLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GProxyAddress] = GProxyAddressLeaf - (GLib.g_type(::Type{T}) where T <: GProxyAddress) = begin - ccall(("g_proxy_address_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GProxyAddress GInetSocketAddress libgio g_proxy_address_get_type begin function GLib.signalnames(::Type{GProxyAddress}) signalnames(supertype(GProxyAddress)) end end - begin - abstract type GSocketAddressEnumerator <: GObject end - mutable struct GSocketAddressEnumeratorLeaf <: GSocketAddressEnumerator - handle::Ptr{GObject} - function GSocketAddressEnumeratorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSocketAddressEnumeratorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSocketAddressEnumerator] = GSocketAddressEnumeratorLeaf - (GLib.g_type(::Type{T}) where T <: GSocketAddressEnumerator) = begin - ccall(("g_socket_address_enumerator_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSocketAddressEnumerator GObject libgio g_socket_address_enumerator_get_type begin function GLib.signalnames(::Type{GSocketAddressEnumerator}) signalnames(supertype(GSocketAddressEnumerator)) end end - begin - abstract type GProxyAddressEnumerator <: GSocketAddressEnumerator end - mutable struct GProxyAddressEnumeratorLeaf <: GProxyAddressEnumerator - handle::Ptr{GObject} - function GProxyAddressEnumeratorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GProxyAddressEnumeratorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GProxyAddressEnumerator] = GProxyAddressEnumeratorLeaf - (GLib.g_type(::Type{T}) where T <: GProxyAddressEnumerator) = begin - ccall(("g_proxy_address_enumerator_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GProxyAddressEnumerator GSocketAddressEnumerator libgio g_proxy_address_enumerator_get_type begin function GLib.signalnames(::Type{GProxyAddressEnumerator}) signalnames(supertype(GProxyAddressEnumerator)) end end - begin - abstract type GResolver <: GObject end - mutable struct GResolverLeaf <: GResolver - handle::Ptr{GObject} - function GResolverLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GResolverLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GResolver] = GResolverLeaf - (GLib.g_type(::Type{T}) where T <: GResolver) = begin - ccall(("g_resolver_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GResolver GObject libgio g_resolver_get_type begin function GLib.signalnames(::Type{GResolver}) vcat([:reload], signalnames(supertype(GResolver))) @@ -2120,23 +836,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GSettings <: GObject end - mutable struct GSettingsLeaf <: GSettings - handle::Ptr{GObject} - function GSettingsLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSettingsLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSettings] = GSettingsLeaf - (GLib.g_type(::Type{T}) where T <: GSettings) = begin - ccall(("g_settings_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSettings GObject libgio g_settings_get_type begin function GLib.signalnames(::Type{GSettings}) vcat([:change_event, :changed, :writable_change_event, :writable_changed], signalnames(supertype(GSettings))) @@ -2150,45 +850,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GSettingsBackend <: GObject end - mutable struct GSettingsBackendLeaf <: GSettingsBackend - handle::Ptr{GObject} - function GSettingsBackendLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSettingsBackendLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSettingsBackend] = GSettingsBackendLeaf - (GLib.g_type(::Type{T}) where T <: GSettingsBackend) = begin - ccall(("g_settings_backend_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSettingsBackend GObject libgio g_settings_backend_get_type begin function GLib.signalnames(::Type{GSettingsBackend}) signalnames(supertype(GSettingsBackend)) end end - begin - abstract type GSimpleAction <: GObject end - mutable struct GSimpleActionLeaf <: GSimpleAction - handle::Ptr{GObject} - function GSimpleActionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSimpleActionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSimpleAction] = GSimpleActionLeaf - (GLib.g_type(::Type{T}) where T <: GSimpleAction) = begin - ccall(("g_simple_action_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSimpleAction GObject libgio g_simple_action_get_type begin function GLib.signalnames(::Type{GSimpleAction}) vcat([:activate, :change_state], signalnames(supertype(GSimpleAction))) @@ -2202,23 +870,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GSimpleActionGroup <: GObject end - mutable struct GSimpleActionGroupLeaf <: GSimpleActionGroup - handle::Ptr{GObject} - function GSimpleActionGroupLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSimpleActionGroupLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSimpleActionGroup] = GSimpleActionGroupLeaf - (GLib.g_type(::Type{T}) where T <: GSimpleActionGroup) = begin - ccall(("g_simple_action_group_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSimpleActionGroup GObject libgio g_simple_action_group_get_type begin function GLib.signalnames(::Type{GSimpleActionGroup}) vcat([:action_added, :action_enabled_changed, :action_removed, :action_state_changed], signalnames(supertype(GSimpleActionGroup))) @@ -2232,133 +884,37 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GSimpleAsyncResult <: GObject end - mutable struct GSimpleAsyncResultLeaf <: GSimpleAsyncResult - handle::Ptr{GObject} - function GSimpleAsyncResultLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSimpleAsyncResultLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSimpleAsyncResult] = GSimpleAsyncResultLeaf - (GLib.g_type(::Type{T}) where T <: GSimpleAsyncResult) = begin - ccall(("g_simple_async_result_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSimpleAsyncResult GObject libgio g_simple_async_result_get_type begin function GLib.signalnames(::Type{GSimpleAsyncResult}) signalnames(supertype(GSimpleAsyncResult)) end end - begin - abstract type GSimpleIOStream <: GIOStream end - mutable struct GSimpleIOStreamLeaf <: GSimpleIOStream - handle::Ptr{GObject} - function GSimpleIOStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSimpleIOStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSimpleIOStream] = GSimpleIOStreamLeaf - (GLib.g_type(::Type{T}) where T <: GSimpleIOStream) = begin - ccall(("g_simple_io_stream_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSimpleIOStream GIOStream libgio g_simple_io_stream_get_type begin function GLib.signalnames(::Type{GSimpleIOStream}) signalnames(supertype(GSimpleIOStream)) end end - begin - abstract type GSimplePermission <: GPermission end - mutable struct GSimplePermissionLeaf <: GSimplePermission - handle::Ptr{GObject} - function GSimplePermissionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSimplePermissionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSimplePermission] = GSimplePermissionLeaf - (GLib.g_type(::Type{T}) where T <: GSimplePermission) = begin - ccall(("g_simple_permission_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSimplePermission GPermission libgio g_simple_permission_get_type begin function GLib.signalnames(::Type{GSimplePermission}) signalnames(supertype(GSimplePermission)) end end - begin - abstract type GSimpleProxyResolver <: GObject end - mutable struct GSimpleProxyResolverLeaf <: GSimpleProxyResolver - handle::Ptr{GObject} - function GSimpleProxyResolverLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSimpleProxyResolverLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSimpleProxyResolver] = GSimpleProxyResolverLeaf - (GLib.g_type(::Type{T}) where T <: GSimpleProxyResolver) = begin - ccall(("g_simple_proxy_resolver_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSimpleProxyResolver GObject libgio g_simple_proxy_resolver_get_type begin function GLib.signalnames(::Type{GSimpleProxyResolver}) signalnames(supertype(GSimpleProxyResolver)) end end - begin - abstract type GSocket <: GObject end - mutable struct GSocketLeaf <: GSocket - handle::Ptr{GObject} - function GSocketLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSocketLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSocket] = GSocketLeaf - (GLib.g_type(::Type{T}) where T <: GSocket) = begin - ccall(("g_socket_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSocket GObject libgio g_socket_get_type begin function GLib.signalnames(::Type{GSocket}) signalnames(supertype(GSocket)) end end - begin - abstract type GSocketClient <: GObject end - mutable struct GSocketClientLeaf <: GSocketClient - handle::Ptr{GObject} - function GSocketClientLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSocketClientLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSocketClient] = GSocketClientLeaf - (GLib.g_type(::Type{T}) where T <: GSocketClient) = begin - ccall(("g_socket_client_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSocketClient GObject libgio g_socket_client_get_type begin function GLib.signalnames(::Type{GSocketClient}) vcat([:event], signalnames(supertype(GSocketClient))) @@ -2372,67 +928,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GSocketConnection <: GIOStream end - mutable struct GSocketConnectionLeaf <: GSocketConnection - handle::Ptr{GObject} - function GSocketConnectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSocketConnectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSocketConnection] = GSocketConnectionLeaf - (GLib.g_type(::Type{T}) where T <: GSocketConnection) = begin - ccall(("g_socket_connection_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSocketConnection GIOStream libgio g_socket_connection_get_type begin function GLib.signalnames(::Type{GSocketConnection}) signalnames(supertype(GSocketConnection)) end end - begin - abstract type GSocketControlMessage <: GObject end - mutable struct GSocketControlMessageLeaf <: GSocketControlMessage - handle::Ptr{GObject} - function GSocketControlMessageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSocketControlMessageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSocketControlMessage] = GSocketControlMessageLeaf - (GLib.g_type(::Type{T}) where T <: GSocketControlMessage) = begin - ccall(("g_socket_control_message_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSocketControlMessage GObject libgio g_socket_control_message_get_type begin function GLib.signalnames(::Type{GSocketControlMessage}) signalnames(supertype(GSocketControlMessage)) end end - begin - abstract type GSocketListener <: GObject end - mutable struct GSocketListenerLeaf <: GSocketListener - handle::Ptr{GObject} - function GSocketListenerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSocketListenerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSocketListener] = GSocketListenerLeaf - (GLib.g_type(::Type{T}) where T <: GSocketListener) = begin - ccall(("g_socket_listener_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSocketListener GObject libgio g_socket_listener_get_type begin function GLib.signalnames(::Type{GSocketListener}) vcat([:event], signalnames(supertype(GSocketListener))) @@ -2446,23 +954,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GSocketService <: GSocketListener end - mutable struct GSocketServiceLeaf <: GSocketService - handle::Ptr{GObject} - function GSocketServiceLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSocketServiceLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSocketService] = GSocketServiceLeaf - (GLib.g_type(::Type{T}) where T <: GSocketService) = begin - ccall(("g_socket_service_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSocketService GSocketListener libgio g_socket_service_get_type begin function GLib.signalnames(::Type{GSocketService}) vcat([:incoming], signalnames(supertype(GSocketService))) @@ -2476,199 +968,55 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GSubprocess <: GObject end - mutable struct GSubprocessLeaf <: GSubprocess - handle::Ptr{GObject} - function GSubprocessLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSubprocessLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSubprocess] = GSubprocessLeaf - (GLib.g_type(::Type{T}) where T <: GSubprocess) = begin - ccall(("g_subprocess_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSubprocess GObject libgio g_subprocess_get_type begin function GLib.signalnames(::Type{GSubprocess}) signalnames(supertype(GSubprocess)) end end - begin - abstract type GSubprocessLauncher <: GObject end - mutable struct GSubprocessLauncherLeaf <: GSubprocessLauncher - handle::Ptr{GObject} - function GSubprocessLauncherLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GSubprocessLauncherLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GSubprocessLauncher] = GSubprocessLauncherLeaf - (GLib.g_type(::Type{T}) where T <: GSubprocessLauncher) = begin - ccall(("g_subprocess_launcher_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GSubprocessLauncher GObject libgio g_subprocess_launcher_get_type begin function GLib.signalnames(::Type{GSubprocessLauncher}) signalnames(supertype(GSubprocessLauncher)) end end - begin - abstract type GTask <: GObject end - mutable struct GTaskLeaf <: GTask - handle::Ptr{GObject} - function GTaskLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTaskLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTask] = GTaskLeaf - (GLib.g_type(::Type{T}) where T <: GTask) = begin - ccall(("g_task_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GTask GObject libgio g_task_get_type begin function GLib.signalnames(::Type{GTask}) signalnames(supertype(GTask)) end end - begin - abstract type GTcpConnection <: GSocketConnection end - mutable struct GTcpConnectionLeaf <: GTcpConnection - handle::Ptr{GObject} - function GTcpConnectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTcpConnectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTcpConnection] = GTcpConnectionLeaf - (GLib.g_type(::Type{T}) where T <: GTcpConnection) = begin - ccall(("g_tcp_connection_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GTcpConnection GSocketConnection libgio g_tcp_connection_get_type begin function GLib.signalnames(::Type{GTcpConnection}) signalnames(supertype(GTcpConnection)) end end - begin - abstract type GTcpWrapperConnection <: GTcpConnection end - mutable struct GTcpWrapperConnectionLeaf <: GTcpWrapperConnection - handle::Ptr{GObject} - function GTcpWrapperConnectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTcpWrapperConnectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTcpWrapperConnection] = GTcpWrapperConnectionLeaf - (GLib.g_type(::Type{T}) where T <: GTcpWrapperConnection) = begin - ccall(("g_tcp_wrapper_connection_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GTcpWrapperConnection GTcpConnection libgio g_tcp_wrapper_connection_get_type begin function GLib.signalnames(::Type{GTcpWrapperConnection}) signalnames(supertype(GTcpWrapperConnection)) end end - begin - abstract type GTestDBus <: GObject end - mutable struct GTestDBusLeaf <: GTestDBus - handle::Ptr{GObject} - function GTestDBusLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTestDBusLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTestDBus] = GTestDBusLeaf - (GLib.g_type(::Type{T}) where T <: GTestDBus) = begin - ccall(("g_test_dbus_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GTestDBus GObject libgio g_test_dbus_get_type begin function GLib.signalnames(::Type{GTestDBus}) signalnames(supertype(GTestDBus)) end end - begin - abstract type GThemedIcon <: GObject end - mutable struct GThemedIconLeaf <: GThemedIcon - handle::Ptr{GObject} - function GThemedIconLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GThemedIconLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GThemedIcon] = GThemedIconLeaf - (GLib.g_type(::Type{T}) where T <: GThemedIcon) = begin - ccall(("g_themed_icon_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GThemedIcon GObject libgio g_themed_icon_get_type begin function GLib.signalnames(::Type{GThemedIcon}) signalnames(supertype(GThemedIcon)) end end - begin - abstract type GThreadedResolver <: GResolver end - mutable struct GThreadedResolverLeaf <: GThreadedResolver - handle::Ptr{GObject} - function GThreadedResolverLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GThreadedResolverLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GThreadedResolver] = GThreadedResolverLeaf - (GLib.g_type(::Type{T}) where T <: GThreadedResolver) = begin - ccall(("g_threaded_resolver_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GThreadedResolver GResolver libgio g_threaded_resolver_get_type begin function GLib.signalnames(::Type{GThreadedResolver}) signalnames(supertype(GThreadedResolver)) end end - begin - abstract type GThreadedSocketService <: GSocketService end - mutable struct GThreadedSocketServiceLeaf <: GThreadedSocketService - handle::Ptr{GObject} - function GThreadedSocketServiceLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GThreadedSocketServiceLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GThreadedSocketService] = GThreadedSocketServiceLeaf - (GLib.g_type(::Type{T}) where T <: GThreadedSocketService) = begin - ccall(("g_threaded_socket_service_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GThreadedSocketService GSocketService libgio g_threaded_socket_service_get_type begin function GLib.signalnames(::Type{GThreadedSocketService}) vcat([:run], signalnames(supertype(GThreadedSocketService))) @@ -2682,45 +1030,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GTlsCertificate <: GObject end - mutable struct GTlsCertificateLeaf <: GTlsCertificate - handle::Ptr{GObject} - function GTlsCertificateLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTlsCertificateLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTlsCertificate] = GTlsCertificateLeaf - (GLib.g_type(::Type{T}) where T <: GTlsCertificate) = begin - ccall(("g_tls_certificate_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GTlsCertificate GObject libgio g_tls_certificate_get_type begin function GLib.signalnames(::Type{GTlsCertificate}) signalnames(supertype(GTlsCertificate)) end end - begin - abstract type GTlsConnection <: GIOStream end - mutable struct GTlsConnectionLeaf <: GTlsConnection - handle::Ptr{GObject} - function GTlsConnectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTlsConnectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTlsConnection] = GTlsConnectionLeaf - (GLib.g_type(::Type{T}) where T <: GTlsConnection) = begin - ccall(("g_tls_connection_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GTlsConnection GIOStream libgio g_tls_connection_get_type begin function GLib.signalnames(::Type{GTlsConnection}) vcat([:accept_certificate], signalnames(supertype(GTlsConnection))) @@ -2734,177 +1050,49 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GTlsDatabase <: GObject end - mutable struct GTlsDatabaseLeaf <: GTlsDatabase - handle::Ptr{GObject} - function GTlsDatabaseLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTlsDatabaseLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTlsDatabase] = GTlsDatabaseLeaf - (GLib.g_type(::Type{T}) where T <: GTlsDatabase) = begin - ccall(("g_tls_database_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GTlsDatabase GObject libgio g_tls_database_get_type begin function GLib.signalnames(::Type{GTlsDatabase}) signalnames(supertype(GTlsDatabase)) end end - begin - abstract type GTlsInteraction <: GObject end - mutable struct GTlsInteractionLeaf <: GTlsInteraction - handle::Ptr{GObject} - function GTlsInteractionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTlsInteractionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTlsInteraction] = GTlsInteractionLeaf - (GLib.g_type(::Type{T}) where T <: GTlsInteraction) = begin - ccall(("g_tls_interaction_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GTlsInteraction GObject libgio g_tls_interaction_get_type begin function GLib.signalnames(::Type{GTlsInteraction}) signalnames(supertype(GTlsInteraction)) end end - begin - abstract type GTlsPassword <: GObject end - mutable struct GTlsPasswordLeaf <: GTlsPassword - handle::Ptr{GObject} - function GTlsPasswordLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTlsPasswordLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTlsPassword] = GTlsPasswordLeaf - (GLib.g_type(::Type{T}) where T <: GTlsPassword) = begin - ccall(("g_tls_password_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GTlsPassword GObject libgio g_tls_password_get_type begin function GLib.signalnames(::Type{GTlsPassword}) signalnames(supertype(GTlsPassword)) end end - begin - abstract type GUnixConnection <: GSocketConnection end - mutable struct GUnixConnectionLeaf <: GUnixConnection - handle::Ptr{GObject} - function GUnixConnectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GUnixConnectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GUnixConnection] = GUnixConnectionLeaf - (GLib.g_type(::Type{T}) where T <: GUnixConnection) = begin - ccall(("g_unix_connection_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GUnixConnection GSocketConnection libgio g_unix_connection_get_type begin function GLib.signalnames(::Type{GUnixConnection}) signalnames(supertype(GUnixConnection)) end end - begin - abstract type GUnixCredentialsMessage <: GSocketControlMessage end - mutable struct GUnixCredentialsMessageLeaf <: GUnixCredentialsMessage - handle::Ptr{GObject} - function GUnixCredentialsMessageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GUnixCredentialsMessageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GUnixCredentialsMessage] = GUnixCredentialsMessageLeaf - (GLib.g_type(::Type{T}) where T <: GUnixCredentialsMessage) = begin - ccall(("g_unix_credentials_message_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GUnixCredentialsMessage GSocketControlMessage libgio g_unix_credentials_message_get_type begin function GLib.signalnames(::Type{GUnixCredentialsMessage}) signalnames(supertype(GUnixCredentialsMessage)) end end - begin - abstract type GVfs <: GObject end - mutable struct GVfsLeaf <: GVfs - handle::Ptr{GObject} - function GVfsLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GVfsLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GVfs] = GVfsLeaf - (GLib.g_type(::Type{T}) where T <: GVfs) = begin - ccall(("g_vfs_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GVfs GObject libgio g_vfs_get_type begin function GLib.signalnames(::Type{GVfs}) signalnames(supertype(GVfs)) end end - begin - abstract type GZlibCompressor <: GObject end - mutable struct GZlibCompressorLeaf <: GZlibCompressor - handle::Ptr{GObject} - function GZlibCompressorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GZlibCompressorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GZlibCompressor] = GZlibCompressorLeaf - (GLib.g_type(::Type{T}) where T <: GZlibCompressor) = begin - ccall(("g_zlib_compressor_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GZlibCompressor GObject libgio g_zlib_compressor_get_type begin function GLib.signalnames(::Type{GZlibCompressor}) signalnames(supertype(GZlibCompressor)) end end - begin - abstract type GZlibDecompressor <: GObject end - mutable struct GZlibDecompressorLeaf <: GZlibDecompressor - handle::Ptr{GObject} - function GZlibDecompressorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GZlibDecompressorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GZlibDecompressor] = GZlibDecompressorLeaf - (GLib.g_type(::Type{T}) where T <: GZlibDecompressor) = begin - ccall(("g_zlib_decompressor_get_type", libgio), GType, ()) - end - end + GLib.@Gobject GZlibDecompressor GObject libgio g_zlib_decompressor_get_type begin function GLib.signalnames(::Type{GZlibDecompressor}) signalnames(supertype(GZlibDecompressor)) diff --git a/src/gen/gobject_structs b/src/gen/gobject_structs index 09132db1..2a467335 100644 --- a/src/gen/gobject_structs +++ b/src/gen/gobject_structs @@ -362,75 +362,21 @@ $(Expr(:toplevel, quote @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.TypeInfo.html)." GTypeInfo @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.TypePluginClass.html)." GTypePluginClass @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.TypeQuery.html)." GTypeQuery - struct GTypePlugin <: GInterface - handle::Ptr{GObject} - gc::Any - GTypePlugin(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end + GLib.@Giface GTypePlugin libgobject g_type_plugin_get_type const gtype_wrapper_cache = Dict{Symbol, Type}() - begin - abstract type GBinding <: GObject end - mutable struct GBindingLeaf <: GBinding - handle::Ptr{GObject} - function GBindingLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GBindingLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GBinding] = GBindingLeaf - (GLib.g_type(::Type{T}) where T <: GBinding) = begin - ccall(("g_binding_get_type", libgobject), GType, ()) - end - end + GLib.@Gobject GBinding GObject libgobject g_binding_get_type begin function GLib.signalnames(::Type{GBinding}) signalnames(supertype(GBinding)) end end - begin - abstract type GInitiallyUnowned <: GObject end - mutable struct GInitiallyUnownedLeaf <: GInitiallyUnowned - handle::Ptr{GObject} - function GInitiallyUnownedLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GInitiallyUnownedLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GInitiallyUnowned] = GInitiallyUnownedLeaf - (GLib.g_type(::Type{T}) where T <: GInitiallyUnowned) = begin - ccall(("g_initially_unowned_get_type", libgobject), GType, ()) - end - end + GLib.@Gobject GInitiallyUnowned GObject libgobject g_initially_unowned_get_type begin function GLib.signalnames(::Type{GInitiallyUnowned}) signalnames(supertype(GInitiallyUnowned)) end end - begin - abstract type GTypeModule <: GObject end - mutable struct GTypeModuleLeaf <: GTypeModule - handle::Ptr{GObject} - function GTypeModuleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GTypeModuleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GTypeModule] = GTypeModuleLeaf - (GLib.g_type(::Type{T}) where T <: GTypeModule) = begin - ccall(("g_type_module_get_type", libgobject), GType, ()) - end - end + GLib.@Gobject GTypeModule GObject libgobject g_type_module_get_type begin function GLib.signalnames(::Type{GTypeModule}) signalnames(supertype(GTypeModule)) diff --git a/src/gen/gsk4_structs b/src/gen/gsk4_structs index aca6a8a1..fbae3b45 100644 --- a/src/gen/gsk4_structs +++ b/src/gen/gsk4_structs @@ -161,45 +161,13 @@ $(Expr(:toplevel, quote handle::Ptr{GskRenderNode} end end - begin - abstract type GskRenderer <: GObject end - mutable struct GskRendererLeaf <: GskRenderer - handle::Ptr{GObject} - function GskRendererLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GskRendererLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GskRenderer] = GskRendererLeaf - (GLib.g_type(::Type{T}) where T <: GskRenderer) = begin - ccall(("gsk_renderer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GskRenderer GObject libgtk4 gsk_renderer_get_type begin function GLib.signalnames(::Type{GskRenderer}) signalnames(supertype(GskRenderer)) end end - begin - abstract type GskBroadwayRenderer <: GskRenderer end - mutable struct GskBroadwayRendererLeaf <: GskBroadwayRenderer - handle::Ptr{GObject} - function GskBroadwayRendererLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GskBroadwayRendererLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GskBroadwayRenderer] = GskBroadwayRendererLeaf - (GLib.g_type(::Type{T}) where T <: GskBroadwayRenderer) = begin - ccall(("gsk_broadway_renderer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GskBroadwayRenderer GskRenderer libgtk4 gsk_broadway_renderer_get_type begin function GLib.signalnames(::Type{GskBroadwayRenderer}) signalnames(supertype(GskBroadwayRenderer)) @@ -213,23 +181,7 @@ $(Expr(:toplevel, quote handle::Ptr{GskRenderNode} end end - begin - abstract type GskCairoRenderer <: GskRenderer end - mutable struct GskCairoRendererLeaf <: GskCairoRenderer - handle::Ptr{GObject} - function GskCairoRendererLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GskCairoRendererLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GskCairoRenderer] = GskCairoRendererLeaf - (GLib.g_type(::Type{T}) where T <: GskCairoRenderer) = begin - ccall(("gsk_cairo_renderer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GskCairoRenderer GskRenderer libgtk4 gsk_cairo_renderer_get_type begin function GLib.signalnames(::Type{GskCairoRenderer}) signalnames(supertype(GskCairoRenderer)) @@ -291,45 +243,13 @@ $(Expr(:toplevel, quote handle::Ptr{GskRenderNode} end end - begin - abstract type GskGLRenderer <: GskRenderer end - mutable struct GskGLRendererLeaf <: GskGLRenderer - handle::Ptr{GObject} - function GskGLRendererLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GskGLRendererLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GskGLRenderer] = GskGLRendererLeaf - (GLib.g_type(::Type{T}) where T <: GskGLRenderer) = begin - ccall(("gsk_gl_renderer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GskGLRenderer GskRenderer libgtk4 gsk_gl_renderer_get_type begin function GLib.signalnames(::Type{GskGLRenderer}) signalnames(supertype(GskGLRenderer)) end end - begin - abstract type GskGLShader <: GObject end - mutable struct GskGLShaderLeaf <: GskGLShader - handle::Ptr{GObject} - function GskGLShaderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GskGLShaderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GskGLShader] = GskGLShaderLeaf - (GLib.g_type(::Type{T}) where T <: GskGLShader) = begin - ccall(("gsk_gl_shader_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GskGLShader GObject libgtk4 gsk_gl_shader_get_type begin function GLib.signalnames(::Type{GskGLShader}) signalnames(supertype(GskGLShader)) @@ -367,23 +287,7 @@ $(Expr(:toplevel, quote handle::Ptr{GskRenderNode} end end - begin - abstract type GskNglRenderer <: GskRenderer end - mutable struct GskNglRendererLeaf <: GskNglRenderer - handle::Ptr{GObject} - function GskNglRendererLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GskNglRendererLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GskNglRenderer] = GskNglRendererLeaf - (GLib.g_type(::Type{T}) where T <: GskNglRenderer) = begin - ccall(("gsk_ngl_renderer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GskNglRenderer GskRenderer libgtk4 gsk_ngl_renderer_get_type begin function GLib.signalnames(::Type{GskNglRenderer}) signalnames(supertype(GskNglRenderer)) @@ -485,23 +389,7 @@ $(Expr(:toplevel, quote handle::Ptr{GskRenderNode} end end - begin - abstract type GskVulkanRenderer <: GskRenderer end - mutable struct GskVulkanRendererLeaf <: GskVulkanRenderer - handle::Ptr{GObject} - function GskVulkanRendererLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GskVulkanRendererLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GskVulkanRenderer] = GskVulkanRendererLeaf - (GLib.g_type(::Type{T}) where T <: GskVulkanRenderer) = begin - ccall(("gsk_vulkan_renderer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GskVulkanRenderer GskRenderer libgtk4 gsk_vulkan_renderer_get_type begin function GLib.signalnames(::Type{GskVulkanRenderer}) signalnames(supertype(GskVulkanRenderer)) diff --git a/src/gen/gtk4_structs b/src/gen/gtk4_structs index d3fed9a3..04ccd1b6 100644 --- a/src/gen/gtk4_structs +++ b/src/gen/gtk4_structs @@ -533,219 +533,35 @@ $(Expr(:toplevel, quote @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.TextIter.html)." GtkTextIter @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.TreeIter.html)." GtkTreeIter @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.TreePath.html)." GtkTreePath - struct GtkAccessible <: GInterface - handle::Ptr{GObject} - gc::Any - GtkAccessible(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkAccessibleRange <: GInterface - handle::Ptr{GObject} - gc::Any - GtkAccessibleRange(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkAccessibleText <: GInterface - handle::Ptr{GObject} - gc::Any - GtkAccessibleText(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkActionable <: GInterface - handle::Ptr{GObject} - gc::Any - GtkActionable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkAppChooser <: GInterface - handle::Ptr{GObject} - gc::Any - GtkAppChooser(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkBuildable <: GInterface - handle::Ptr{GObject} - gc::Any - GtkBuildable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkBuilderScope <: GInterface - handle::Ptr{GObject} - gc::Any - GtkBuilderScope(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkCellEditable <: GInterface - handle::Ptr{GObject} - gc::Any - GtkCellEditable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkCellLayout <: GInterface - handle::Ptr{GObject} - gc::Any - GtkCellLayout(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkColorChooser <: GInterface - handle::Ptr{GObject} - gc::Any - GtkColorChooser(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkConstraintTarget <: GInterface - handle::Ptr{GObject} - gc::Any - GtkConstraintTarget(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkEditable <: GInterface - handle::Ptr{GObject} - gc::Any - GtkEditable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkFileChooser <: GInterface - handle::Ptr{GObject} - gc::Any - GtkFileChooser(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkFontChooser <: GInterface - handle::Ptr{GObject} - gc::Any - GtkFontChooser(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkNative <: GInterface - handle::Ptr{GObject} - gc::Any - GtkNative(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkOrientable <: GInterface - handle::Ptr{GObject} - gc::Any - GtkOrientable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkPrintOperationPreview <: GInterface - handle::Ptr{GObject} - gc::Any - GtkPrintOperationPreview(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkRoot <: GInterface - handle::Ptr{GObject} - gc::Any - GtkRoot(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkScrollable <: GInterface - handle::Ptr{GObject} - gc::Any - GtkScrollable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkSectionModel <: GInterface - handle::Ptr{GObject} - gc::Any - GtkSectionModel(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkSelectionModel <: GInterface - handle::Ptr{GObject} - gc::Any - GtkSelectionModel(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkShortcutManager <: GInterface - handle::Ptr{GObject} - gc::Any - GtkShortcutManager(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkStyleProvider <: GInterface - handle::Ptr{GObject} - gc::Any - GtkStyleProvider(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkSymbolicPaintable <: GInterface - handle::Ptr{GObject} - gc::Any - GtkSymbolicPaintable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkTreeDragDest <: GInterface - handle::Ptr{GObject} - gc::Any - GtkTreeDragDest(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkTreeDragSource <: GInterface - handle::Ptr{GObject} - gc::Any - GtkTreeDragSource(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkTreeModel <: GInterface - handle::Ptr{GObject} - gc::Any - GtkTreeModel(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct GtkTreeSortable <: GInterface - handle::Ptr{GObject} - gc::Any - GtkTreeSortable(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - begin - abstract type GtkATContext <: GObject end - mutable struct GtkATContextLeaf <: GtkATContext - handle::Ptr{GObject} - function GtkATContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkATContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkATContext] = GtkATContextLeaf - (GLib.g_type(::Type{T}) where T <: GtkATContext) = begin - ccall(("gtk_at_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Giface GtkAccessible libgtk4 gtk_accessible_get_type + GLib.@Giface GtkAccessibleRange libgtk4 gtk_accessible_range_get_type + GLib.@Giface GtkAccessibleText libgtk4 gtk_accessible_text_get_type + GLib.@Giface GtkActionable libgtk4 gtk_actionable_get_type + GLib.@Giface GtkAppChooser libgtk4 gtk_app_chooser_get_type + GLib.@Giface GtkBuildable libgtk4 gtk_buildable_get_type + GLib.@Giface GtkBuilderScope libgtk4 gtk_builder_scope_get_type + GLib.@Giface GtkCellEditable libgtk4 gtk_cell_editable_get_type + GLib.@Giface GtkCellLayout libgtk4 gtk_cell_layout_get_type + GLib.@Giface GtkColorChooser libgtk4 gtk_color_chooser_get_type + GLib.@Giface GtkConstraintTarget libgtk4 gtk_constraint_target_get_type + GLib.@Giface GtkEditable libgtk4 gtk_editable_get_type + GLib.@Giface GtkFileChooser libgtk4 gtk_file_chooser_get_type + GLib.@Giface GtkFontChooser libgtk4 gtk_font_chooser_get_type + GLib.@Giface GtkNative libgtk4 gtk_native_get_type + GLib.@Giface GtkOrientable libgtk4 gtk_orientable_get_type + GLib.@Giface GtkPrintOperationPreview libgtk4 gtk_print_operation_preview_get_type + GLib.@Giface GtkRoot libgtk4 gtk_root_get_type + GLib.@Giface GtkScrollable libgtk4 gtk_scrollable_get_type + GLib.@Giface GtkSectionModel libgtk4 gtk_section_model_get_type + GLib.@Giface GtkSelectionModel libgtk4 gtk_selection_model_get_type + GLib.@Giface GtkShortcutManager libgtk4 gtk_shortcut_manager_get_type + GLib.@Giface GtkStyleProvider libgtk4 gtk_style_provider_get_type + GLib.@Giface GtkSymbolicPaintable libgtk4 gtk_symbolic_paintable_get_type + GLib.@Giface GtkTreeDragDest libgtk4 gtk_tree_drag_dest_get_type + GLib.@Giface GtkTreeDragSource libgtk4 gtk_tree_drag_source_get_type + GLib.@Giface GtkTreeModel libgtk4 gtk_tree_model_get_type + GLib.@Giface GtkTreeSortable libgtk4 gtk_tree_sortable_get_type + GLib.@Gobject GtkATContext GObject libgtk4 gtk_at_context_get_type begin function GLib.signalnames(::Type{GtkATContext}) vcat([:state_change], signalnames(supertype(GtkATContext))) @@ -759,23 +575,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkWidget <: GInitiallyUnowned end - mutable struct GtkWidgetLeaf <: GtkWidget - handle::Ptr{GObject} - function GtkWidgetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkWidgetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkWidget] = GtkWidgetLeaf - (GLib.g_type(::Type{T}) where T <: GtkWidget) = begin - ccall(("gtk_widget_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkWidget GInitiallyUnowned libgtk4 gtk_widget_get_type begin function GLib.signalnames(::Type{GtkWidget}) vcat([:destroy, :direction_changed, :hide, :keynav_failed, :map, :mnemonic_activate, :move_focus, :query_tooltip, :realize, :show, :state_flags_changed, :unmap, :unrealize], signalnames(supertype(GtkWidget))) @@ -789,23 +589,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkWindow <: GtkWidget end - mutable struct GtkWindowLeaf <: GtkWindow - handle::Ptr{GObject} - function GtkWindowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkWindowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkWindow] = GtkWindowLeaf - (GLib.g_type(::Type{T}) where T <: GtkWindow) = begin - ccall(("gtk_window_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkWindow GtkWidget libgtk4 gtk_window_get_type begin function GLib.signalnames(::Type{GtkWindow}) vcat([:activate_default, :activate_focus, :close_request, :enable_debugging, :keys_changed], signalnames(supertype(GtkWindow))) @@ -819,23 +603,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkAboutDialog <: GtkWindow end - mutable struct GtkAboutDialogLeaf <: GtkAboutDialog - handle::Ptr{GObject} - function GtkAboutDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAboutDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAboutDialog] = GtkAboutDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkAboutDialog) = begin - ccall(("gtk_about_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAboutDialog GtkWindow libgtk4 gtk_about_dialog_get_type begin function GLib.signalnames(::Type{GtkAboutDialog}) vcat([:activate_link], signalnames(supertype(GtkAboutDialog))) @@ -849,89 +617,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkActionBar <: GtkWidget end - mutable struct GtkActionBarLeaf <: GtkActionBar - handle::Ptr{GObject} - function GtkActionBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkActionBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkActionBar] = GtkActionBarLeaf - (GLib.g_type(::Type{T}) where T <: GtkActionBar) = begin - ccall(("gtk_action_bar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkActionBar GtkWidget libgtk4 gtk_action_bar_get_type begin function GLib.signalnames(::Type{GtkActionBar}) signalnames(supertype(GtkActionBar)) end end - begin - abstract type GtkShortcutAction <: GObject end - mutable struct GtkShortcutActionLeaf <: GtkShortcutAction - handle::Ptr{GObject} - function GtkShortcutActionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkShortcutActionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkShortcutAction] = GtkShortcutActionLeaf - (GLib.g_type(::Type{T}) where T <: GtkShortcutAction) = begin - ccall(("gtk_shortcut_action_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkShortcutAction GObject libgtk4 gtk_shortcut_action_get_type begin function GLib.signalnames(::Type{GtkShortcutAction}) signalnames(supertype(GtkShortcutAction)) end end - begin - abstract type GtkActivateAction <: GtkShortcutAction end - mutable struct GtkActivateActionLeaf <: GtkActivateAction - handle::Ptr{GObject} - function GtkActivateActionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkActivateActionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkActivateAction] = GtkActivateActionLeaf - (GLib.g_type(::Type{T}) where T <: GtkActivateAction) = begin - ccall(("gtk_activate_action_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkActivateAction GtkShortcutAction libgtk4 gtk_activate_action_get_type begin function GLib.signalnames(::Type{GtkActivateAction}) signalnames(supertype(GtkActivateAction)) end end - begin - abstract type GtkAdjustment <: GInitiallyUnowned end - mutable struct GtkAdjustmentLeaf <: GtkAdjustment - handle::Ptr{GObject} - function GtkAdjustmentLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAdjustmentLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAdjustment] = GtkAdjustmentLeaf - (GLib.g_type(::Type{T}) where T <: GtkAdjustment) = begin - ccall(("gtk_adjustment_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAdjustment GInitiallyUnowned libgtk4 gtk_adjustment_get_type begin function GLib.signalnames(::Type{GtkAdjustment}) vcat([:changed, :value_changed], signalnames(supertype(GtkAdjustment))) @@ -945,89 +649,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkAlertDialog <: GObject end - mutable struct GtkAlertDialogLeaf <: GtkAlertDialog - handle::Ptr{GObject} - function GtkAlertDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAlertDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAlertDialog] = GtkAlertDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkAlertDialog) = begin - ccall(("gtk_alert_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAlertDialog GObject libgtk4 gtk_alert_dialog_get_type begin function GLib.signalnames(::Type{GtkAlertDialog}) signalnames(supertype(GtkAlertDialog)) end end - begin - abstract type GtkShortcutTrigger <: GObject end - mutable struct GtkShortcutTriggerLeaf <: GtkShortcutTrigger - handle::Ptr{GObject} - function GtkShortcutTriggerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkShortcutTriggerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkShortcutTrigger] = GtkShortcutTriggerLeaf - (GLib.g_type(::Type{T}) where T <: GtkShortcutTrigger) = begin - ccall(("gtk_shortcut_trigger_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkShortcutTrigger GObject libgtk4 gtk_shortcut_trigger_get_type begin function GLib.signalnames(::Type{GtkShortcutTrigger}) signalnames(supertype(GtkShortcutTrigger)) end end - begin - abstract type GtkAlternativeTrigger <: GtkShortcutTrigger end - mutable struct GtkAlternativeTriggerLeaf <: GtkAlternativeTrigger - handle::Ptr{GObject} - function GtkAlternativeTriggerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAlternativeTriggerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAlternativeTrigger] = GtkAlternativeTriggerLeaf - (GLib.g_type(::Type{T}) where T <: GtkAlternativeTrigger) = begin - ccall(("gtk_alternative_trigger_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAlternativeTrigger GtkShortcutTrigger libgtk4 gtk_alternative_trigger_get_type begin function GLib.signalnames(::Type{GtkAlternativeTrigger}) signalnames(supertype(GtkAlternativeTrigger)) end end - begin - abstract type GtkFilter <: GObject end - mutable struct GtkFilterLeaf <: GtkFilter - handle::Ptr{GObject} - function GtkFilterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFilterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFilter] = GtkFilterLeaf - (GLib.g_type(::Type{T}) where T <: GtkFilter) = begin - ccall(("gtk_filter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFilter GObject libgtk4 gtk_filter_get_type begin function GLib.signalnames(::Type{GtkFilter}) vcat([:changed], signalnames(supertype(GtkFilter))) @@ -1041,23 +681,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkMultiFilter <: GtkFilter end - mutable struct GtkMultiFilterLeaf <: GtkMultiFilter - handle::Ptr{GObject} - function GtkMultiFilterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMultiFilterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMultiFilter] = GtkMultiFilterLeaf - (GLib.g_type(::Type{T}) where T <: GtkMultiFilter) = begin - ccall(("gtk_multi_filter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMultiFilter GtkFilter libgtk4 gtk_multi_filter_get_type begin function GLib.signalnames(::Type{GtkMultiFilter}) vcat([:items_changed], signalnames(supertype(GtkMultiFilter))) @@ -1071,23 +695,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkAnyFilter <: GtkMultiFilter end - mutable struct GtkAnyFilterLeaf <: GtkAnyFilter - handle::Ptr{GObject} - function GtkAnyFilterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAnyFilterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAnyFilter] = GtkAnyFilterLeaf - (GLib.g_type(::Type{T}) where T <: GtkAnyFilter) = begin - ccall(("gtk_any_filter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAnyFilter GtkMultiFilter libgtk4 gtk_any_filter_get_type begin function GLib.signalnames(::Type{GtkAnyFilter}) vcat([:items_changed], signalnames(supertype(GtkAnyFilter))) @@ -1101,23 +709,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkAppChooserButton <: GtkWidget end - mutable struct GtkAppChooserButtonLeaf <: GtkAppChooserButton - handle::Ptr{GObject} - function GtkAppChooserButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAppChooserButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAppChooserButton] = GtkAppChooserButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkAppChooserButton) = begin - ccall(("gtk_app_chooser_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAppChooserButton GtkWidget libgtk4 gtk_app_chooser_button_get_type begin function GLib.signalnames(::Type{GtkAppChooserButton}) vcat([:activate, :changed, :custom_item_activated], signalnames(supertype(GtkAppChooserButton))) @@ -1131,23 +723,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkDialog <: GtkWindow end - mutable struct GtkDialogLeaf <: GtkDialog - handle::Ptr{GObject} - function GtkDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkDialog] = GtkDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkDialog) = begin - ccall(("gtk_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkDialog GtkWindow libgtk4 gtk_dialog_get_type begin function GLib.signalnames(::Type{GtkDialog}) vcat([:close, :response], signalnames(supertype(GtkDialog))) @@ -1161,45 +737,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkAppChooserDialog <: GtkDialog end - mutable struct GtkAppChooserDialogLeaf <: GtkAppChooserDialog - handle::Ptr{GObject} - function GtkAppChooserDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAppChooserDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAppChooserDialog] = GtkAppChooserDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkAppChooserDialog) = begin - ccall(("gtk_app_chooser_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAppChooserDialog GtkDialog libgtk4 gtk_app_chooser_dialog_get_type begin function GLib.signalnames(::Type{GtkAppChooserDialog}) signalnames(supertype(GtkAppChooserDialog)) end end - begin - abstract type GtkAppChooserWidget <: GtkWidget end - mutable struct GtkAppChooserWidgetLeaf <: GtkAppChooserWidget - handle::Ptr{GObject} - function GtkAppChooserWidgetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAppChooserWidgetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAppChooserWidget] = GtkAppChooserWidgetLeaf - (GLib.g_type(::Type{T}) where T <: GtkAppChooserWidget) = begin - ccall(("gtk_app_chooser_widget_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAppChooserWidget GtkWidget libgtk4 gtk_app_chooser_widget_get_type begin function GLib.signalnames(::Type{GtkAppChooserWidget}) vcat([:application_activated, :application_selected], signalnames(supertype(GtkAppChooserWidget))) @@ -1213,23 +757,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkApplication <: GApplication end - mutable struct GtkApplicationLeaf <: GtkApplication - handle::Ptr{GObject} - function GtkApplicationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkApplicationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkApplication] = GtkApplicationLeaf - (GLib.g_type(::Type{T}) where T <: GtkApplication) = begin - ccall(("gtk_application_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkApplication GApplication libgtk4 gtk_application_get_type begin function GLib.signalnames(::Type{GtkApplication}) vcat([:query_end, :window_added, :window_removed, :action_added, :action_enabled_changed, :action_removed, :action_state_changed], signalnames(supertype(GtkApplication))) @@ -1243,23 +771,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkApplicationWindow <: GtkWindow end - mutable struct GtkApplicationWindowLeaf <: GtkApplicationWindow - handle::Ptr{GObject} - function GtkApplicationWindowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkApplicationWindowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkApplicationWindow] = GtkApplicationWindowLeaf - (GLib.g_type(::Type{T}) where T <: GtkApplicationWindow) = begin - ccall(("gtk_application_window_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkApplicationWindow GtkWindow libgtk4 gtk_application_window_get_type begin function GLib.signalnames(::Type{GtkApplicationWindow}) vcat([:action_added, :action_enabled_changed, :action_removed, :action_state_changed], signalnames(supertype(GtkApplicationWindow))) @@ -1273,45 +785,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkAspectFrame <: GtkWidget end - mutable struct GtkAspectFrameLeaf <: GtkAspectFrame - handle::Ptr{GObject} - function GtkAspectFrameLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAspectFrameLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAspectFrame] = GtkAspectFrameLeaf - (GLib.g_type(::Type{T}) where T <: GtkAspectFrame) = begin - ccall(("gtk_aspect_frame_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAspectFrame GtkWidget libgtk4 gtk_aspect_frame_get_type begin function GLib.signalnames(::Type{GtkAspectFrame}) signalnames(supertype(GtkAspectFrame)) end end - begin - abstract type GtkAssistant <: GtkWindow end - mutable struct GtkAssistantLeaf <: GtkAssistant - handle::Ptr{GObject} - function GtkAssistantLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAssistantLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAssistant] = GtkAssistantLeaf - (GLib.g_type(::Type{T}) where T <: GtkAssistant) = begin - ccall(("gtk_assistant_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAssistant GtkWindow libgtk4 gtk_assistant_get_type begin function GLib.signalnames(::Type{GtkAssistant}) vcat([:apply, :cancel, :close, :escape, :prepare], signalnames(supertype(GtkAssistant))) @@ -1325,89 +805,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkAssistantPage <: GObject end - mutable struct GtkAssistantPageLeaf <: GtkAssistantPage - handle::Ptr{GObject} - function GtkAssistantPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkAssistantPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkAssistantPage] = GtkAssistantPageLeaf - (GLib.g_type(::Type{T}) where T <: GtkAssistantPage) = begin - ccall(("gtk_assistant_page_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkAssistantPage GObject libgtk4 gtk_assistant_page_get_type begin function GLib.signalnames(::Type{GtkAssistantPage}) signalnames(supertype(GtkAssistantPage)) end end - begin - abstract type GtkLayoutManager <: GObject end - mutable struct GtkLayoutManagerLeaf <: GtkLayoutManager - handle::Ptr{GObject} - function GtkLayoutManagerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkLayoutManagerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkLayoutManager] = GtkLayoutManagerLeaf - (GLib.g_type(::Type{T}) where T <: GtkLayoutManager) = begin - ccall(("gtk_layout_manager_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkLayoutManager GObject libgtk4 gtk_layout_manager_get_type begin function GLib.signalnames(::Type{GtkLayoutManager}) signalnames(supertype(GtkLayoutManager)) end end - begin - abstract type GtkBinLayout <: GtkLayoutManager end - mutable struct GtkBinLayoutLeaf <: GtkBinLayout - handle::Ptr{GObject} - function GtkBinLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkBinLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkBinLayout] = GtkBinLayoutLeaf - (GLib.g_type(::Type{T}) where T <: GtkBinLayout) = begin - ccall(("gtk_bin_layout_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkBinLayout GtkLayoutManager libgtk4 gtk_bin_layout_get_type begin function GLib.signalnames(::Type{GtkBinLayout}) signalnames(supertype(GtkBinLayout)) end end - begin - abstract type GtkBookmarkList <: GObject end - mutable struct GtkBookmarkListLeaf <: GtkBookmarkList - handle::Ptr{GObject} - function GtkBookmarkListLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkBookmarkListLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkBookmarkList] = GtkBookmarkListLeaf - (GLib.g_type(::Type{T}) where T <: GtkBookmarkList) = begin - ccall(("gtk_bookmark_list_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkBookmarkList GObject libgtk4 gtk_bookmark_list_get_type begin function GLib.signalnames(::Type{GtkBookmarkList}) vcat([:items_changed], signalnames(supertype(GtkBookmarkList))) @@ -1421,177 +837,49 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkBoolFilter <: GtkFilter end - mutable struct GtkBoolFilterLeaf <: GtkBoolFilter - handle::Ptr{GObject} - function GtkBoolFilterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkBoolFilterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkBoolFilter] = GtkBoolFilterLeaf - (GLib.g_type(::Type{T}) where T <: GtkBoolFilter) = begin - ccall(("gtk_bool_filter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkBoolFilter GtkFilter libgtk4 gtk_bool_filter_get_type begin function GLib.signalnames(::Type{GtkBoolFilter}) signalnames(supertype(GtkBoolFilter)) end end - begin - abstract type GtkBox <: GtkWidget end - mutable struct GtkBoxLeaf <: GtkBox - handle::Ptr{GObject} - function GtkBoxLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkBoxLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkBox] = GtkBoxLeaf - (GLib.g_type(::Type{T}) where T <: GtkBox) = begin - ccall(("gtk_box_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkBox GtkWidget libgtk4 gtk_box_get_type begin function GLib.signalnames(::Type{GtkBox}) signalnames(supertype(GtkBox)) end end - begin - abstract type GtkBoxLayout <: GtkLayoutManager end - mutable struct GtkBoxLayoutLeaf <: GtkBoxLayout - handle::Ptr{GObject} - function GtkBoxLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkBoxLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkBoxLayout] = GtkBoxLayoutLeaf - (GLib.g_type(::Type{T}) where T <: GtkBoxLayout) = begin - ccall(("gtk_box_layout_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkBoxLayout GtkLayoutManager libgtk4 gtk_box_layout_get_type begin function GLib.signalnames(::Type{GtkBoxLayout}) signalnames(supertype(GtkBoxLayout)) end end - begin - abstract type GtkBuilder <: GObject end - mutable struct GtkBuilderLeaf <: GtkBuilder - handle::Ptr{GObject} - function GtkBuilderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkBuilderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkBuilder] = GtkBuilderLeaf - (GLib.g_type(::Type{T}) where T <: GtkBuilder) = begin - ccall(("gtk_builder_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkBuilder GObject libgtk4 gtk_builder_get_type begin function GLib.signalnames(::Type{GtkBuilder}) signalnames(supertype(GtkBuilder)) end end - begin - abstract type GtkBuilderCScope <: GObject end - mutable struct GtkBuilderCScopeLeaf <: GtkBuilderCScope - handle::Ptr{GObject} - function GtkBuilderCScopeLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkBuilderCScopeLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkBuilderCScope] = GtkBuilderCScopeLeaf - (GLib.g_type(::Type{T}) where T <: GtkBuilderCScope) = begin - ccall(("gtk_builder_cscope_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkBuilderCScope GObject libgtk4 gtk_builder_cscope_get_type begin function GLib.signalnames(::Type{GtkBuilderCScope}) signalnames(supertype(GtkBuilderCScope)) end end - begin - abstract type GtkListItemFactory <: GObject end - mutable struct GtkListItemFactoryLeaf <: GtkListItemFactory - handle::Ptr{GObject} - function GtkListItemFactoryLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkListItemFactoryLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkListItemFactory] = GtkListItemFactoryLeaf - (GLib.g_type(::Type{T}) where T <: GtkListItemFactory) = begin - ccall(("gtk_list_item_factory_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkListItemFactory GObject libgtk4 gtk_list_item_factory_get_type begin function GLib.signalnames(::Type{GtkListItemFactory}) signalnames(supertype(GtkListItemFactory)) end end - begin - abstract type GtkBuilderListItemFactory <: GtkListItemFactory end - mutable struct GtkBuilderListItemFactoryLeaf <: GtkBuilderListItemFactory - handle::Ptr{GObject} - function GtkBuilderListItemFactoryLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkBuilderListItemFactoryLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkBuilderListItemFactory] = GtkBuilderListItemFactoryLeaf - (GLib.g_type(::Type{T}) where T <: GtkBuilderListItemFactory) = begin - ccall(("gtk_builder_list_item_factory_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkBuilderListItemFactory GtkListItemFactory libgtk4 gtk_builder_list_item_factory_get_type begin function GLib.signalnames(::Type{GtkBuilderListItemFactory}) signalnames(supertype(GtkBuilderListItemFactory)) end end - begin - abstract type GtkButton <: GtkWidget end - mutable struct GtkButtonLeaf <: GtkButton - handle::Ptr{GObject} - function GtkButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkButton] = GtkButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkButton) = begin - ccall(("gtk_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkButton GtkWidget libgtk4 gtk_button_get_type begin function GLib.signalnames(::Type{GtkButton}) vcat([:activate, :clicked], signalnames(supertype(GtkButton))) @@ -1605,23 +893,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkCalendar <: GtkWidget end - mutable struct GtkCalendarLeaf <: GtkCalendar - handle::Ptr{GObject} - function GtkCalendarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCalendarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCalendar] = GtkCalendarLeaf - (GLib.g_type(::Type{T}) where T <: GtkCalendar) = begin - ccall(("gtk_calendar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCalendar GtkWidget libgtk4 gtk_calendar_get_type begin function GLib.signalnames(::Type{GtkCalendar}) vcat([:day_selected, :next_month, :next_year, :prev_month, :prev_year], signalnames(supertype(GtkCalendar))) @@ -1635,45 +907,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkCallbackAction <: GtkShortcutAction end - mutable struct GtkCallbackActionLeaf <: GtkCallbackAction - handle::Ptr{GObject} - function GtkCallbackActionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCallbackActionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCallbackAction] = GtkCallbackActionLeaf - (GLib.g_type(::Type{T}) where T <: GtkCallbackAction) = begin - ccall(("gtk_callback_action_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCallbackAction GtkShortcutAction libgtk4 gtk_callback_action_get_type begin function GLib.signalnames(::Type{GtkCallbackAction}) signalnames(supertype(GtkCallbackAction)) end end - begin - abstract type GtkCellArea <: GInitiallyUnowned end - mutable struct GtkCellAreaLeaf <: GtkCellArea - handle::Ptr{GObject} - function GtkCellAreaLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellAreaLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellArea] = GtkCellAreaLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellArea) = begin - ccall(("gtk_cell_area_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellArea GInitiallyUnowned libgtk4 gtk_cell_area_get_type begin function GLib.signalnames(::Type{GtkCellArea}) vcat([:add_editable, :apply_attributes, :focus_changed, :remove_editable], signalnames(supertype(GtkCellArea))) @@ -1687,67 +927,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkCellAreaBox <: GtkCellArea end - mutable struct GtkCellAreaBoxLeaf <: GtkCellAreaBox - handle::Ptr{GObject} - function GtkCellAreaBoxLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellAreaBoxLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellAreaBox] = GtkCellAreaBoxLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellAreaBox) = begin - ccall(("gtk_cell_area_box_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellAreaBox GtkCellArea libgtk4 gtk_cell_area_box_get_type begin function GLib.signalnames(::Type{GtkCellAreaBox}) signalnames(supertype(GtkCellAreaBox)) end end - begin - abstract type GtkCellAreaContext <: GObject end - mutable struct GtkCellAreaContextLeaf <: GtkCellAreaContext - handle::Ptr{GObject} - function GtkCellAreaContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellAreaContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellAreaContext] = GtkCellAreaContextLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellAreaContext) = begin - ccall(("gtk_cell_area_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellAreaContext GObject libgtk4 gtk_cell_area_context_get_type begin function GLib.signalnames(::Type{GtkCellAreaContext}) signalnames(supertype(GtkCellAreaContext)) end end - begin - abstract type GtkCellRenderer <: GInitiallyUnowned end - mutable struct GtkCellRendererLeaf <: GtkCellRenderer - handle::Ptr{GObject} - function GtkCellRendererLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellRendererLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellRenderer] = GtkCellRendererLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellRenderer) = begin - ccall(("gtk_cell_renderer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellRenderer GInitiallyUnowned libgtk4 gtk_cell_renderer_get_type begin function GLib.signalnames(::Type{GtkCellRenderer}) vcat([:editing_canceled, :editing_started], signalnames(supertype(GtkCellRenderer))) @@ -1761,23 +953,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkCellRendererText <: GtkCellRenderer end - mutable struct GtkCellRendererTextLeaf <: GtkCellRendererText - handle::Ptr{GObject} - function GtkCellRendererTextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellRendererTextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellRendererText] = GtkCellRendererTextLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellRendererText) = begin - ccall(("gtk_cell_renderer_text_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellRendererText GtkCellRenderer libgtk4 gtk_cell_renderer_text_get_type begin function GLib.signalnames(::Type{GtkCellRendererText}) vcat([:edited], signalnames(supertype(GtkCellRendererText))) @@ -1791,23 +967,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkCellRendererAccel <: GtkCellRendererText end - mutable struct GtkCellRendererAccelLeaf <: GtkCellRendererAccel - handle::Ptr{GObject} - function GtkCellRendererAccelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellRendererAccelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellRendererAccel] = GtkCellRendererAccelLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellRendererAccel) = begin - ccall(("gtk_cell_renderer_accel_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellRendererAccel GtkCellRendererText libgtk4 gtk_cell_renderer_accel_get_type begin function GLib.signalnames(::Type{GtkCellRendererAccel}) vcat([:accel_cleared, :accel_edited], signalnames(supertype(GtkCellRendererAccel))) @@ -1821,23 +981,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkCellRendererCombo <: GtkCellRendererText end - mutable struct GtkCellRendererComboLeaf <: GtkCellRendererCombo - handle::Ptr{GObject} - function GtkCellRendererComboLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellRendererComboLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellRendererCombo] = GtkCellRendererComboLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellRendererCombo) = begin - ccall(("gtk_cell_renderer_combo_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellRendererCombo GtkCellRendererText libgtk4 gtk_cell_renderer_combo_get_type begin function GLib.signalnames(::Type{GtkCellRendererCombo}) vcat([:changed], signalnames(supertype(GtkCellRendererCombo))) @@ -1851,111 +995,31 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkCellRendererPixbuf <: GtkCellRenderer end - mutable struct GtkCellRendererPixbufLeaf <: GtkCellRendererPixbuf - handle::Ptr{GObject} - function GtkCellRendererPixbufLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellRendererPixbufLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellRendererPixbuf] = GtkCellRendererPixbufLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellRendererPixbuf) = begin - ccall(("gtk_cell_renderer_pixbuf_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellRendererPixbuf GtkCellRenderer libgtk4 gtk_cell_renderer_pixbuf_get_type begin function GLib.signalnames(::Type{GtkCellRendererPixbuf}) signalnames(supertype(GtkCellRendererPixbuf)) end end + GLib.@Gobject GtkCellRendererProgress GtkCellRenderer libgtk4 gtk_cell_renderer_progress_get_type begin - abstract type GtkCellRendererProgress <: GtkCellRenderer end - mutable struct GtkCellRendererProgressLeaf <: GtkCellRendererProgress - handle::Ptr{GObject} - function GtkCellRendererProgressLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellRendererProgressLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellRendererProgress] = GtkCellRendererProgressLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellRendererProgress) = begin - ccall(("gtk_cell_renderer_progress_get_type", libgtk4), GType, ()) - end - end - begin - function GLib.signalnames(::Type{GtkCellRendererProgress}) - signalnames(supertype(GtkCellRendererProgress)) - end - end - begin - abstract type GtkCellRendererSpin <: GtkCellRendererText end - mutable struct GtkCellRendererSpinLeaf <: GtkCellRendererSpin - handle::Ptr{GObject} - function GtkCellRendererSpinLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellRendererSpinLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellRendererSpin] = GtkCellRendererSpinLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellRendererSpin) = begin - ccall(("gtk_cell_renderer_spin_get_type", libgtk4), GType, ()) - end - end - begin - function GLib.signalnames(::Type{GtkCellRendererSpin}) - signalnames(supertype(GtkCellRendererSpin)) + function GLib.signalnames(::Type{GtkCellRendererProgress}) + signalnames(supertype(GtkCellRendererProgress)) end end + GLib.@Gobject GtkCellRendererSpin GtkCellRendererText libgtk4 gtk_cell_renderer_spin_get_type begin - abstract type GtkCellRendererSpinner <: GtkCellRenderer end - mutable struct GtkCellRendererSpinnerLeaf <: GtkCellRendererSpinner - handle::Ptr{GObject} - function GtkCellRendererSpinnerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellRendererSpinnerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end + function GLib.signalnames(::Type{GtkCellRendererSpin}) + signalnames(supertype(GtkCellRendererSpin)) end - gtype_wrapper_cache[:GtkCellRendererSpinner] = GtkCellRendererSpinnerLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellRendererSpinner) = begin - ccall(("gtk_cell_renderer_spinner_get_type", libgtk4), GType, ()) - end end + GLib.@Gobject GtkCellRendererSpinner GtkCellRenderer libgtk4 gtk_cell_renderer_spinner_get_type begin function GLib.signalnames(::Type{GtkCellRendererSpinner}) signalnames(supertype(GtkCellRendererSpinner)) end end - begin - abstract type GtkCellRendererToggle <: GtkCellRenderer end - mutable struct GtkCellRendererToggleLeaf <: GtkCellRendererToggle - handle::Ptr{GObject} - function GtkCellRendererToggleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellRendererToggleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellRendererToggle] = GtkCellRendererToggleLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellRendererToggle) = begin - ccall(("gtk_cell_renderer_toggle_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellRendererToggle GtkCellRenderer libgtk4 gtk_cell_renderer_toggle_get_type begin function GLib.signalnames(::Type{GtkCellRendererToggle}) vcat([:toggled], signalnames(supertype(GtkCellRendererToggle))) @@ -1969,89 +1033,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkCellView <: GtkWidget end - mutable struct GtkCellViewLeaf <: GtkCellView - handle::Ptr{GObject} - function GtkCellViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCellViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCellView] = GtkCellViewLeaf - (GLib.g_type(::Type{T}) where T <: GtkCellView) = begin - ccall(("gtk_cell_view_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCellView GtkWidget libgtk4 gtk_cell_view_get_type begin function GLib.signalnames(::Type{GtkCellView}) signalnames(supertype(GtkCellView)) end end - begin - abstract type GtkCenterBox <: GtkWidget end - mutable struct GtkCenterBoxLeaf <: GtkCenterBox - handle::Ptr{GObject} - function GtkCenterBoxLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCenterBoxLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCenterBox] = GtkCenterBoxLeaf - (GLib.g_type(::Type{T}) where T <: GtkCenterBox) = begin - ccall(("gtk_center_box_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCenterBox GtkWidget libgtk4 gtk_center_box_get_type begin function GLib.signalnames(::Type{GtkCenterBox}) signalnames(supertype(GtkCenterBox)) end end - begin - abstract type GtkCenterLayout <: GtkLayoutManager end - mutable struct GtkCenterLayoutLeaf <: GtkCenterLayout - handle::Ptr{GObject} - function GtkCenterLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCenterLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCenterLayout] = GtkCenterLayoutLeaf - (GLib.g_type(::Type{T}) where T <: GtkCenterLayout) = begin - ccall(("gtk_center_layout_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCenterLayout GtkLayoutManager libgtk4 gtk_center_layout_get_type begin function GLib.signalnames(::Type{GtkCenterLayout}) signalnames(supertype(GtkCenterLayout)) end end - begin - abstract type GtkCheckButton <: GtkWidget end - mutable struct GtkCheckButtonLeaf <: GtkCheckButton - handle::Ptr{GObject} - function GtkCheckButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCheckButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCheckButton] = GtkCheckButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkCheckButton) = begin - ccall(("gtk_check_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCheckButton GtkWidget libgtk4 gtk_check_button_get_type begin function GLib.signalnames(::Type{GtkCheckButton}) vcat([:activate, :toggled], signalnames(supertype(GtkCheckButton))) @@ -2065,23 +1065,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkColorButton <: GtkWidget end - mutable struct GtkColorButtonLeaf <: GtkColorButton - handle::Ptr{GObject} - function GtkColorButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColorButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColorButton] = GtkColorButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkColorButton) = begin - ccall(("gtk_color_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColorButton GtkWidget libgtk4 gtk_color_button_get_type begin function GLib.signalnames(::Type{GtkColorButton}) vcat([:activate, :color_set, :color_activated], signalnames(supertype(GtkColorButton))) @@ -2095,23 +1079,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkColorChooserDialog <: GtkDialog end - mutable struct GtkColorChooserDialogLeaf <: GtkColorChooserDialog - handle::Ptr{GObject} - function GtkColorChooserDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColorChooserDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColorChooserDialog] = GtkColorChooserDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkColorChooserDialog) = begin - ccall(("gtk_color_chooser_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColorChooserDialog GtkDialog libgtk4 gtk_color_chooser_dialog_get_type begin function GLib.signalnames(::Type{GtkColorChooserDialog}) vcat([:color_activated], signalnames(supertype(GtkColorChooserDialog))) @@ -2125,23 +1093,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkColorChooserWidget <: GtkWidget end - mutable struct GtkColorChooserWidgetLeaf <: GtkColorChooserWidget - handle::Ptr{GObject} - function GtkColorChooserWidgetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColorChooserWidgetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColorChooserWidget] = GtkColorChooserWidgetLeaf - (GLib.g_type(::Type{T}) where T <: GtkColorChooserWidget) = begin - ccall(("gtk_color_chooser_widget_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColorChooserWidget GtkWidget libgtk4 gtk_color_chooser_widget_get_type begin function GLib.signalnames(::Type{GtkColorChooserWidget}) vcat([:color_activated], signalnames(supertype(GtkColorChooserWidget))) @@ -2155,45 +1107,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkColorDialog <: GObject end - mutable struct GtkColorDialogLeaf <: GtkColorDialog - handle::Ptr{GObject} - function GtkColorDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColorDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColorDialog] = GtkColorDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkColorDialog) = begin - ccall(("gtk_color_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColorDialog GObject libgtk4 gtk_color_dialog_get_type begin function GLib.signalnames(::Type{GtkColorDialog}) signalnames(supertype(GtkColorDialog)) end end - begin - abstract type GtkColorDialogButton <: GtkWidget end - mutable struct GtkColorDialogButtonLeaf <: GtkColorDialogButton - handle::Ptr{GObject} - function GtkColorDialogButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColorDialogButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColorDialogButton] = GtkColorDialogButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkColorDialogButton) = begin - ccall(("gtk_color_dialog_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColorDialogButton GtkWidget libgtk4 gtk_color_dialog_button_get_type begin function GLib.signalnames(::Type{GtkColorDialogButton}) vcat([:activate], signalnames(supertype(GtkColorDialogButton))) @@ -2207,23 +1127,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkColumnView <: GtkWidget end - mutable struct GtkColumnViewLeaf <: GtkColumnView - handle::Ptr{GObject} - function GtkColumnViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColumnViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColumnView] = GtkColumnViewLeaf - (GLib.g_type(::Type{T}) where T <: GtkColumnView) = begin - ccall(("gtk_column_view_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColumnView GtkWidget libgtk4 gtk_column_view_get_type begin function GLib.signalnames(::Type{GtkColumnView}) vcat([:activate], signalnames(supertype(GtkColumnView))) @@ -2237,111 +1141,31 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkListItem <: GObject end - mutable struct GtkListItemLeaf <: GtkListItem - handle::Ptr{GObject} - function GtkListItemLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkListItemLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkListItem] = GtkListItemLeaf - (GLib.g_type(::Type{T}) where T <: GtkListItem) = begin - ccall(("gtk_list_item_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkListItem GObject libgtk4 gtk_list_item_get_type begin function GLib.signalnames(::Type{GtkListItem}) signalnames(supertype(GtkListItem)) end end - begin - abstract type GtkColumnViewCell <: GtkListItem end - mutable struct GtkColumnViewCellLeaf <: GtkColumnViewCell - handle::Ptr{GObject} - function GtkColumnViewCellLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColumnViewCellLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColumnViewCell] = GtkColumnViewCellLeaf - (GLib.g_type(::Type{T}) where T <: GtkColumnViewCell) = begin - ccall(("gtk_column_view_cell_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColumnViewCell GtkListItem libgtk4 gtk_column_view_cell_get_type begin function GLib.signalnames(::Type{GtkColumnViewCell}) signalnames(supertype(GtkColumnViewCell)) end end - begin - abstract type GtkColumnViewColumn <: GObject end - mutable struct GtkColumnViewColumnLeaf <: GtkColumnViewColumn - handle::Ptr{GObject} - function GtkColumnViewColumnLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColumnViewColumnLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColumnViewColumn] = GtkColumnViewColumnLeaf - (GLib.g_type(::Type{T}) where T <: GtkColumnViewColumn) = begin - ccall(("gtk_column_view_column_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColumnViewColumn GObject libgtk4 gtk_column_view_column_get_type begin function GLib.signalnames(::Type{GtkColumnViewColumn}) signalnames(supertype(GtkColumnViewColumn)) end end - begin - abstract type GtkColumnViewRow <: GObject end - mutable struct GtkColumnViewRowLeaf <: GtkColumnViewRow - handle::Ptr{GObject} - function GtkColumnViewRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColumnViewRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColumnViewRow] = GtkColumnViewRowLeaf - (GLib.g_type(::Type{T}) where T <: GtkColumnViewRow) = begin - ccall(("gtk_column_view_row_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColumnViewRow GObject libgtk4 gtk_column_view_row_get_type begin function GLib.signalnames(::Type{GtkColumnViewRow}) signalnames(supertype(GtkColumnViewRow)) end end - begin - abstract type GtkSorter <: GObject end - mutable struct GtkSorterLeaf <: GtkSorter - handle::Ptr{GObject} - function GtkSorterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSorterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSorter] = GtkSorterLeaf - (GLib.g_type(::Type{T}) where T <: GtkSorter) = begin - ccall(("gtk_sorter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSorter GObject libgtk4 gtk_sorter_get_type begin function GLib.signalnames(::Type{GtkSorter}) vcat([:changed], signalnames(supertype(GtkSorter))) @@ -2355,45 +1179,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkColumnViewSorter <: GtkSorter end - mutable struct GtkColumnViewSorterLeaf <: GtkColumnViewSorter - handle::Ptr{GObject} - function GtkColumnViewSorterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkColumnViewSorterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkColumnViewSorter] = GtkColumnViewSorterLeaf - (GLib.g_type(::Type{T}) where T <: GtkColumnViewSorter) = begin - ccall(("gtk_column_view_sorter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkColumnViewSorter GtkSorter libgtk4 gtk_column_view_sorter_get_type begin function GLib.signalnames(::Type{GtkColumnViewSorter}) signalnames(supertype(GtkColumnViewSorter)) end end - begin - abstract type GtkComboBox <: GtkWidget end - mutable struct GtkComboBoxLeaf <: GtkComboBox - handle::Ptr{GObject} - function GtkComboBoxLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkComboBoxLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkComboBox] = GtkComboBoxLeaf - (GLib.g_type(::Type{T}) where T <: GtkComboBox) = begin - ccall(("gtk_combo_box_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkComboBox GtkWidget libgtk4 gtk_combo_box_get_type begin function GLib.signalnames(::Type{GtkComboBox}) vcat([:activate, :changed, :format_entry_text, :move_active, :popdown, :popup, :editing_done, :remove_widget], signalnames(supertype(GtkComboBox))) @@ -2407,23 +1199,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkComboBoxText <: GtkComboBox end - mutable struct GtkComboBoxTextLeaf <: GtkComboBoxText - handle::Ptr{GObject} - function GtkComboBoxTextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkComboBoxTextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkComboBoxText] = GtkComboBoxTextLeaf - (GLib.g_type(::Type{T}) where T <: GtkComboBoxText) = begin - ccall(("gtk_combo_box_text_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkComboBoxText GtkComboBox libgtk4 gtk_combo_box_text_get_type begin function GLib.signalnames(::Type{GtkComboBoxText}) vcat([:editing_done, :remove_widget], signalnames(supertype(GtkComboBoxText))) @@ -2459,133 +1235,37 @@ $(Expr(:toplevel, quote handle::Ptr{GtkExpression} end end - begin - abstract type GtkConstraint <: GObject end - mutable struct GtkConstraintLeaf <: GtkConstraint - handle::Ptr{GObject} - function GtkConstraintLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkConstraintLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkConstraint] = GtkConstraintLeaf - (GLib.g_type(::Type{T}) where T <: GtkConstraint) = begin - ccall(("gtk_constraint_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkConstraint GObject libgtk4 gtk_constraint_get_type begin function GLib.signalnames(::Type{GtkConstraint}) signalnames(supertype(GtkConstraint)) end end - begin - abstract type GtkConstraintGuide <: GObject end - mutable struct GtkConstraintGuideLeaf <: GtkConstraintGuide - handle::Ptr{GObject} - function GtkConstraintGuideLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkConstraintGuideLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkConstraintGuide] = GtkConstraintGuideLeaf - (GLib.g_type(::Type{T}) where T <: GtkConstraintGuide) = begin - ccall(("gtk_constraint_guide_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkConstraintGuide GObject libgtk4 gtk_constraint_guide_get_type begin function GLib.signalnames(::Type{GtkConstraintGuide}) signalnames(supertype(GtkConstraintGuide)) end end - begin - abstract type GtkConstraintLayout <: GtkLayoutManager end - mutable struct GtkConstraintLayoutLeaf <: GtkConstraintLayout - handle::Ptr{GObject} - function GtkConstraintLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkConstraintLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkConstraintLayout] = GtkConstraintLayoutLeaf - (GLib.g_type(::Type{T}) where T <: GtkConstraintLayout) = begin - ccall(("gtk_constraint_layout_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkConstraintLayout GtkLayoutManager libgtk4 gtk_constraint_layout_get_type begin function GLib.signalnames(::Type{GtkConstraintLayout}) signalnames(supertype(GtkConstraintLayout)) end end - begin - abstract type GtkLayoutChild <: GObject end - mutable struct GtkLayoutChildLeaf <: GtkLayoutChild - handle::Ptr{GObject} - function GtkLayoutChildLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkLayoutChildLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkLayoutChild] = GtkLayoutChildLeaf - (GLib.g_type(::Type{T}) where T <: GtkLayoutChild) = begin - ccall(("gtk_layout_child_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkLayoutChild GObject libgtk4 gtk_layout_child_get_type begin function GLib.signalnames(::Type{GtkLayoutChild}) signalnames(supertype(GtkLayoutChild)) end end - begin - abstract type GtkConstraintLayoutChild <: GtkLayoutChild end - mutable struct GtkConstraintLayoutChildLeaf <: GtkConstraintLayoutChild - handle::Ptr{GObject} - function GtkConstraintLayoutChildLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkConstraintLayoutChildLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkConstraintLayoutChild] = GtkConstraintLayoutChildLeaf - (GLib.g_type(::Type{T}) where T <: GtkConstraintLayoutChild) = begin - ccall(("gtk_constraint_layout_child_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkConstraintLayoutChild GtkLayoutChild libgtk4 gtk_constraint_layout_child_get_type begin function GLib.signalnames(::Type{GtkConstraintLayoutChild}) signalnames(supertype(GtkConstraintLayoutChild)) end end - begin - abstract type GtkCssProvider <: GObject end - mutable struct GtkCssProviderLeaf <: GtkCssProvider - handle::Ptr{GObject} - function GtkCssProviderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCssProviderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCssProvider] = GtkCssProviderLeaf - (GLib.g_type(::Type{T}) where T <: GtkCssProvider) = begin - ccall(("gtk_css_provider_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCssProvider GObject libgtk4 gtk_css_provider_get_type begin function GLib.signalnames(::Type{GtkCssProvider}) vcat([:parsing_error, :gtk_private_changed], signalnames(supertype(GtkCssProvider))) @@ -2599,89 +1279,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkCustomFilter <: GtkFilter end - mutable struct GtkCustomFilterLeaf <: GtkCustomFilter - handle::Ptr{GObject} - function GtkCustomFilterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCustomFilterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCustomFilter] = GtkCustomFilterLeaf - (GLib.g_type(::Type{T}) where T <: GtkCustomFilter) = begin - ccall(("gtk_custom_filter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCustomFilter GtkFilter libgtk4 gtk_custom_filter_get_type begin function GLib.signalnames(::Type{GtkCustomFilter}) signalnames(supertype(GtkCustomFilter)) end end - begin - abstract type GtkCustomLayout <: GtkLayoutManager end - mutable struct GtkCustomLayoutLeaf <: GtkCustomLayout - handle::Ptr{GObject} - function GtkCustomLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCustomLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCustomLayout] = GtkCustomLayoutLeaf - (GLib.g_type(::Type{T}) where T <: GtkCustomLayout) = begin - ccall(("gtk_custom_layout_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCustomLayout GtkLayoutManager libgtk4 gtk_custom_layout_get_type begin function GLib.signalnames(::Type{GtkCustomLayout}) signalnames(supertype(GtkCustomLayout)) end end - begin - abstract type GtkCustomSorter <: GtkSorter end - mutable struct GtkCustomSorterLeaf <: GtkCustomSorter - handle::Ptr{GObject} - function GtkCustomSorterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkCustomSorterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkCustomSorter] = GtkCustomSorterLeaf - (GLib.g_type(::Type{T}) where T <: GtkCustomSorter) = begin - ccall(("gtk_custom_sorter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkCustomSorter GtkSorter libgtk4 gtk_custom_sorter_get_type begin function GLib.signalnames(::Type{GtkCustomSorter}) signalnames(supertype(GtkCustomSorter)) end end - begin - abstract type GtkDirectoryList <: GObject end - mutable struct GtkDirectoryListLeaf <: GtkDirectoryList - handle::Ptr{GObject} - function GtkDirectoryListLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkDirectoryListLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkDirectoryList] = GtkDirectoryListLeaf - (GLib.g_type(::Type{T}) where T <: GtkDirectoryList) = begin - ccall(("gtk_directory_list_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkDirectoryList GObject libgtk4 gtk_directory_list_get_type begin function GLib.signalnames(::Type{GtkDirectoryList}) vcat([:items_changed], signalnames(supertype(GtkDirectoryList))) @@ -2695,67 +1311,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkDragIcon <: GtkWidget end - mutable struct GtkDragIconLeaf <: GtkDragIcon - handle::Ptr{GObject} - function GtkDragIconLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkDragIconLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkDragIcon] = GtkDragIconLeaf - (GLib.g_type(::Type{T}) where T <: GtkDragIcon) = begin - ccall(("gtk_drag_icon_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkDragIcon GtkWidget libgtk4 gtk_drag_icon_get_type begin function GLib.signalnames(::Type{GtkDragIcon}) signalnames(supertype(GtkDragIcon)) end end - begin - abstract type GtkEventController <: GObject end - mutable struct GtkEventControllerLeaf <: GtkEventController - handle::Ptr{GObject} - function GtkEventControllerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEventControllerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEventController] = GtkEventControllerLeaf - (GLib.g_type(::Type{T}) where T <: GtkEventController) = begin - ccall(("gtk_event_controller_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEventController GObject libgtk4 gtk_event_controller_get_type begin function GLib.signalnames(::Type{GtkEventController}) signalnames(supertype(GtkEventController)) end end - begin - abstract type GtkGesture <: GtkEventController end - mutable struct GtkGestureLeaf <: GtkGesture - handle::Ptr{GObject} - function GtkGestureLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGestureLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGesture] = GtkGestureLeaf - (GLib.g_type(::Type{T}) where T <: GtkGesture) = begin - ccall(("gtk_gesture_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGesture GtkEventController libgtk4 gtk_gesture_get_type begin function GLib.signalnames(::Type{GtkGesture}) vcat([:begin, :cancel, :end, :sequence_state_changed, :update], signalnames(supertype(GtkGesture))) @@ -2769,45 +1337,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkGestureSingle <: GtkGesture end - mutable struct GtkGestureSingleLeaf <: GtkGestureSingle - handle::Ptr{GObject} - function GtkGestureSingleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGestureSingleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGestureSingle] = GtkGestureSingleLeaf - (GLib.g_type(::Type{T}) where T <: GtkGestureSingle) = begin - ccall(("gtk_gesture_single_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGestureSingle GtkGesture libgtk4 gtk_gesture_single_get_type begin function GLib.signalnames(::Type{GtkGestureSingle}) signalnames(supertype(GtkGestureSingle)) end end - begin - abstract type GtkDragSource <: GtkGestureSingle end - mutable struct GtkDragSourceLeaf <: GtkDragSource - handle::Ptr{GObject} - function GtkDragSourceLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkDragSourceLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkDragSource] = GtkDragSourceLeaf - (GLib.g_type(::Type{T}) where T <: GtkDragSource) = begin - ccall(("gtk_drag_source_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkDragSource GtkGestureSingle libgtk4 gtk_drag_source_get_type begin function GLib.signalnames(::Type{GtkDragSource}) vcat([:drag_begin, :drag_cancel, :drag_end, :prepare], signalnames(supertype(GtkDragSource))) @@ -2821,23 +1357,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkDrawingArea <: GtkWidget end - mutable struct GtkDrawingAreaLeaf <: GtkDrawingArea - handle::Ptr{GObject} - function GtkDrawingAreaLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkDrawingAreaLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkDrawingArea] = GtkDrawingAreaLeaf - (GLib.g_type(::Type{T}) where T <: GtkDrawingArea) = begin - ccall(("gtk_drawing_area_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkDrawingArea GtkWidget libgtk4 gtk_drawing_area_get_type begin function GLib.signalnames(::Type{GtkDrawingArea}) vcat([:resize], signalnames(supertype(GtkDrawingArea))) @@ -2851,23 +1371,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkDropControllerMotion <: GtkEventController end - mutable struct GtkDropControllerMotionLeaf <: GtkDropControllerMotion - handle::Ptr{GObject} - function GtkDropControllerMotionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkDropControllerMotionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkDropControllerMotion] = GtkDropControllerMotionLeaf - (GLib.g_type(::Type{T}) where T <: GtkDropControllerMotion) = begin - ccall(("gtk_drop_controller_motion_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkDropControllerMotion GtkEventController libgtk4 gtk_drop_controller_motion_get_type begin function GLib.signalnames(::Type{GtkDropControllerMotion}) vcat([:enter, :leave, :motion], signalnames(supertype(GtkDropControllerMotion))) @@ -2881,23 +1385,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkDropDown <: GtkWidget end - mutable struct GtkDropDownLeaf <: GtkDropDown - handle::Ptr{GObject} - function GtkDropDownLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkDropDownLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkDropDown] = GtkDropDownLeaf - (GLib.g_type(::Type{T}) where T <: GtkDropDown) = begin - ccall(("gtk_drop_down_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkDropDown GtkWidget libgtk4 gtk_drop_down_get_type begin function GLib.signalnames(::Type{GtkDropDown}) vcat([:activate], signalnames(supertype(GtkDropDown))) @@ -2911,23 +1399,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkDropTarget <: GtkEventController end - mutable struct GtkDropTargetLeaf <: GtkDropTarget - handle::Ptr{GObject} - function GtkDropTargetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkDropTargetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkDropTarget] = GtkDropTargetLeaf - (GLib.g_type(::Type{T}) where T <: GtkDropTarget) = begin - ccall(("gtk_drop_target_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkDropTarget GtkEventController libgtk4 gtk_drop_target_get_type begin function GLib.signalnames(::Type{GtkDropTarget}) vcat([:accept, :drop, :enter, :leave, :motion], signalnames(supertype(GtkDropTarget))) @@ -2941,23 +1413,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkDropTargetAsync <: GtkEventController end - mutable struct GtkDropTargetAsyncLeaf <: GtkDropTargetAsync - handle::Ptr{GObject} - function GtkDropTargetAsyncLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkDropTargetAsyncLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkDropTargetAsync] = GtkDropTargetAsyncLeaf - (GLib.g_type(::Type{T}) where T <: GtkDropTargetAsync) = begin - ccall(("gtk_drop_target_async_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkDropTargetAsync GtkEventController libgtk4 gtk_drop_target_async_get_type begin function GLib.signalnames(::Type{GtkDropTargetAsync}) vcat([:accept, :drag_enter, :drag_leave, :drag_motion, :drop], signalnames(supertype(GtkDropTargetAsync))) @@ -2971,23 +1427,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEditableLabel <: GtkWidget end - mutable struct GtkEditableLabelLeaf <: GtkEditableLabel - handle::Ptr{GObject} - function GtkEditableLabelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEditableLabelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEditableLabel] = GtkEditableLabelLeaf - (GLib.g_type(::Type{T}) where T <: GtkEditableLabel) = begin - ccall(("gtk_editable_label_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEditableLabel GtkWidget libgtk4 gtk_editable_label_get_type begin function GLib.signalnames(::Type{GtkEditableLabel}) vcat([:changed, :delete_text, :insert_text], signalnames(supertype(GtkEditableLabel))) @@ -3001,23 +1441,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkPopover <: GtkWidget end - mutable struct GtkPopoverLeaf <: GtkPopover - handle::Ptr{GObject} - function GtkPopoverLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPopoverLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPopover] = GtkPopoverLeaf - (GLib.g_type(::Type{T}) where T <: GtkPopover) = begin - ccall(("gtk_popover_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPopover GtkWidget libgtk4 gtk_popover_get_type begin function GLib.signalnames(::Type{GtkPopover}) vcat([:activate_default, :closed], signalnames(supertype(GtkPopover))) @@ -3031,23 +1455,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEmojiChooser <: GtkPopover end - mutable struct GtkEmojiChooserLeaf <: GtkEmojiChooser - handle::Ptr{GObject} - function GtkEmojiChooserLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEmojiChooserLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEmojiChooser] = GtkEmojiChooserLeaf - (GLib.g_type(::Type{T}) where T <: GtkEmojiChooser) = begin - ccall(("gtk_emoji_chooser_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEmojiChooser GtkPopover libgtk4 gtk_emoji_chooser_get_type begin function GLib.signalnames(::Type{GtkEmojiChooser}) vcat([:emoji_picked], signalnames(supertype(GtkEmojiChooser))) @@ -3061,23 +1469,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEntry <: GtkWidget end - mutable struct GtkEntryLeaf <: GtkEntry - handle::Ptr{GObject} - function GtkEntryLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEntryLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEntry] = GtkEntryLeaf - (GLib.g_type(::Type{T}) where T <: GtkEntry) = begin - ccall(("gtk_entry_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEntry GtkWidget libgtk4 gtk_entry_get_type begin function GLib.signalnames(::Type{GtkEntry}) vcat([:activate, :icon_press, :icon_release, :editing_done, :remove_widget, :changed, :delete_text, :insert_text], signalnames(supertype(GtkEntry))) @@ -3091,23 +1483,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEntryBuffer <: GObject end - mutable struct GtkEntryBufferLeaf <: GtkEntryBuffer - handle::Ptr{GObject} - function GtkEntryBufferLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEntryBufferLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEntryBuffer] = GtkEntryBufferLeaf - (GLib.g_type(::Type{T}) where T <: GtkEntryBuffer) = begin - ccall(("gtk_entry_buffer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEntryBuffer GObject libgtk4 gtk_entry_buffer_get_type begin function GLib.signalnames(::Type{GtkEntryBuffer}) vcat([:deleted_text, :inserted_text], signalnames(supertype(GtkEntryBuffer))) @@ -3121,23 +1497,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEntryCompletion <: GObject end - mutable struct GtkEntryCompletionLeaf <: GtkEntryCompletion - handle::Ptr{GObject} - function GtkEntryCompletionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEntryCompletionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEntryCompletion] = GtkEntryCompletionLeaf - (GLib.g_type(::Type{T}) where T <: GtkEntryCompletion) = begin - ccall(("gtk_entry_completion_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEntryCompletion GObject libgtk4 gtk_entry_completion_get_type begin function GLib.signalnames(::Type{GtkEntryCompletion}) vcat([:cursor_on_match, :insert_prefix, :match_selected, :no_matches], signalnames(supertype(GtkEntryCompletion))) @@ -3151,23 +1511,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEventControllerFocus <: GtkEventController end - mutable struct GtkEventControllerFocusLeaf <: GtkEventControllerFocus - handle::Ptr{GObject} - function GtkEventControllerFocusLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEventControllerFocusLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEventControllerFocus] = GtkEventControllerFocusLeaf - (GLib.g_type(::Type{T}) where T <: GtkEventControllerFocus) = begin - ccall(("gtk_event_controller_focus_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEventControllerFocus GtkEventController libgtk4 gtk_event_controller_focus_get_type begin function GLib.signalnames(::Type{GtkEventControllerFocus}) vcat([:enter, :leave], signalnames(supertype(GtkEventControllerFocus))) @@ -3181,23 +1525,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEventControllerKey <: GtkEventController end - mutable struct GtkEventControllerKeyLeaf <: GtkEventControllerKey - handle::Ptr{GObject} - function GtkEventControllerKeyLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEventControllerKeyLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEventControllerKey] = GtkEventControllerKeyLeaf - (GLib.g_type(::Type{T}) where T <: GtkEventControllerKey) = begin - ccall(("gtk_event_controller_key_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEventControllerKey GtkEventController libgtk4 gtk_event_controller_key_get_type begin function GLib.signalnames(::Type{GtkEventControllerKey}) vcat([:im_update, :key_pressed, :key_released, :modifiers], signalnames(supertype(GtkEventControllerKey))) @@ -3211,23 +1539,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEventControllerLegacy <: GtkEventController end - mutable struct GtkEventControllerLegacyLeaf <: GtkEventControllerLegacy - handle::Ptr{GObject} - function GtkEventControllerLegacyLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEventControllerLegacyLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEventControllerLegacy] = GtkEventControllerLegacyLeaf - (GLib.g_type(::Type{T}) where T <: GtkEventControllerLegacy) = begin - ccall(("gtk_event_controller_legacy_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEventControllerLegacy GtkEventController libgtk4 gtk_event_controller_legacy_get_type begin function GLib.signalnames(::Type{GtkEventControllerLegacy}) vcat([:event], signalnames(supertype(GtkEventControllerLegacy))) @@ -3241,23 +1553,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEventControllerMotion <: GtkEventController end - mutable struct GtkEventControllerMotionLeaf <: GtkEventControllerMotion - handle::Ptr{GObject} - function GtkEventControllerMotionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEventControllerMotionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEventControllerMotion] = GtkEventControllerMotionLeaf - (GLib.g_type(::Type{T}) where T <: GtkEventControllerMotion) = begin - ccall(("gtk_event_controller_motion_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEventControllerMotion GtkEventController libgtk4 gtk_event_controller_motion_get_type begin function GLib.signalnames(::Type{GtkEventControllerMotion}) vcat([:enter, :leave, :motion], signalnames(supertype(GtkEventControllerMotion))) @@ -3271,23 +1567,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEventControllerScroll <: GtkEventController end - mutable struct GtkEventControllerScrollLeaf <: GtkEventControllerScroll - handle::Ptr{GObject} - function GtkEventControllerScrollLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEventControllerScrollLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEventControllerScroll] = GtkEventControllerScrollLeaf - (GLib.g_type(::Type{T}) where T <: GtkEventControllerScroll) = begin - ccall(("gtk_event_controller_scroll_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEventControllerScroll GtkEventController libgtk4 gtk_event_controller_scroll_get_type begin function GLib.signalnames(::Type{GtkEventControllerScroll}) vcat([:decelerate, :scroll, :scroll_begin, :scroll_end], signalnames(supertype(GtkEventControllerScroll))) @@ -3301,23 +1581,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkEveryFilter <: GtkMultiFilter end - mutable struct GtkEveryFilterLeaf <: GtkEveryFilter - handle::Ptr{GObject} - function GtkEveryFilterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkEveryFilterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkEveryFilter] = GtkEveryFilterLeaf - (GLib.g_type(::Type{T}) where T <: GtkEveryFilter) = begin - ccall(("gtk_every_filter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkEveryFilter GtkMultiFilter libgtk4 gtk_every_filter_get_type begin function GLib.signalnames(::Type{GtkEveryFilter}) vcat([:items_changed], signalnames(supertype(GtkEveryFilter))) @@ -3331,23 +1595,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkExpander <: GtkWidget end - mutable struct GtkExpanderLeaf <: GtkExpander - handle::Ptr{GObject} - function GtkExpanderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkExpanderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkExpander] = GtkExpanderLeaf - (GLib.g_type(::Type{T}) where T <: GtkExpander) = begin - ccall(("gtk_expander_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkExpander GtkWidget libgtk4 gtk_expander_get_type begin function GLib.signalnames(::Type{GtkExpander}) vcat([:activate], signalnames(supertype(GtkExpander))) @@ -3361,45 +1609,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFileChooserDialog <: GtkDialog end - mutable struct GtkFileChooserDialogLeaf <: GtkFileChooserDialog - handle::Ptr{GObject} - function GtkFileChooserDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFileChooserDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFileChooserDialog] = GtkFileChooserDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkFileChooserDialog) = begin - ccall(("gtk_file_chooser_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFileChooserDialog GtkDialog libgtk4 gtk_file_chooser_dialog_get_type begin function GLib.signalnames(::Type{GtkFileChooserDialog}) signalnames(supertype(GtkFileChooserDialog)) end end - begin - abstract type GtkNativeDialog <: GObject end - mutable struct GtkNativeDialogLeaf <: GtkNativeDialog - handle::Ptr{GObject} - function GtkNativeDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkNativeDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkNativeDialog] = GtkNativeDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkNativeDialog) = begin - ccall(("gtk_native_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkNativeDialog GObject libgtk4 gtk_native_dialog_get_type begin function GLib.signalnames(::Type{GtkNativeDialog}) vcat([:response], signalnames(supertype(GtkNativeDialog))) @@ -3413,45 +1629,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFileChooserNative <: GtkNativeDialog end - mutable struct GtkFileChooserNativeLeaf <: GtkFileChooserNative - handle::Ptr{GObject} - function GtkFileChooserNativeLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFileChooserNativeLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFileChooserNative] = GtkFileChooserNativeLeaf - (GLib.g_type(::Type{T}) where T <: GtkFileChooserNative) = begin - ccall(("gtk_file_chooser_native_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFileChooserNative GtkNativeDialog libgtk4 gtk_file_chooser_native_get_type begin function GLib.signalnames(::Type{GtkFileChooserNative}) signalnames(supertype(GtkFileChooserNative)) end end - begin - abstract type GtkFileChooserWidget <: GtkWidget end - mutable struct GtkFileChooserWidgetLeaf <: GtkFileChooserWidget - handle::Ptr{GObject} - function GtkFileChooserWidgetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFileChooserWidgetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFileChooserWidget] = GtkFileChooserWidgetLeaf - (GLib.g_type(::Type{T}) where T <: GtkFileChooserWidget) = begin - ccall(("gtk_file_chooser_widget_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFileChooserWidget GtkWidget libgtk4 gtk_file_chooser_widget_get_type begin function GLib.signalnames(::Type{GtkFileChooserWidget}) vcat([:desktop_folder, :down_folder, :home_folder, :location_popup, :location_popup_on_paste, :location_toggle_popup, :places_shortcut, :quick_bookmark, :recent_shortcut, :search_shortcut, :show_hidden, :up_folder], signalnames(supertype(GtkFileChooserWidget))) @@ -3465,89 +1649,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFileDialog <: GObject end - mutable struct GtkFileDialogLeaf <: GtkFileDialog - handle::Ptr{GObject} - function GtkFileDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFileDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFileDialog] = GtkFileDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkFileDialog) = begin - ccall(("gtk_file_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFileDialog GObject libgtk4 gtk_file_dialog_get_type begin function GLib.signalnames(::Type{GtkFileDialog}) signalnames(supertype(GtkFileDialog)) end end - begin - abstract type GtkFileFilter <: GtkFilter end - mutable struct GtkFileFilterLeaf <: GtkFileFilter - handle::Ptr{GObject} - function GtkFileFilterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFileFilterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFileFilter] = GtkFileFilterLeaf - (GLib.g_type(::Type{T}) where T <: GtkFileFilter) = begin - ccall(("gtk_file_filter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFileFilter GtkFilter libgtk4 gtk_file_filter_get_type begin function GLib.signalnames(::Type{GtkFileFilter}) signalnames(supertype(GtkFileFilter)) end end - begin - abstract type GtkFileLauncher <: GObject end - mutable struct GtkFileLauncherLeaf <: GtkFileLauncher - handle::Ptr{GObject} - function GtkFileLauncherLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFileLauncherLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFileLauncher] = GtkFileLauncherLeaf - (GLib.g_type(::Type{T}) where T <: GtkFileLauncher) = begin - ccall(("gtk_file_launcher_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFileLauncher GObject libgtk4 gtk_file_launcher_get_type begin function GLib.signalnames(::Type{GtkFileLauncher}) signalnames(supertype(GtkFileLauncher)) end end - begin - abstract type GtkFilterListModel <: GObject end - mutable struct GtkFilterListModelLeaf <: GtkFilterListModel - handle::Ptr{GObject} - function GtkFilterListModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFilterListModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFilterListModel] = GtkFilterListModelLeaf - (GLib.g_type(::Type{T}) where T <: GtkFilterListModel) = begin - ccall(("gtk_filter_list_model_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFilterListModel GObject libgtk4 gtk_filter_list_model_get_type begin function GLib.signalnames(::Type{GtkFilterListModel}) vcat([:items_changed, :sections_changed], signalnames(supertype(GtkFilterListModel))) @@ -3561,89 +1681,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFixed <: GtkWidget end - mutable struct GtkFixedLeaf <: GtkFixed - handle::Ptr{GObject} - function GtkFixedLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFixedLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFixed] = GtkFixedLeaf - (GLib.g_type(::Type{T}) where T <: GtkFixed) = begin - ccall(("gtk_fixed_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFixed GtkWidget libgtk4 gtk_fixed_get_type begin function GLib.signalnames(::Type{GtkFixed}) signalnames(supertype(GtkFixed)) end end - begin - abstract type GtkFixedLayout <: GtkLayoutManager end - mutable struct GtkFixedLayoutLeaf <: GtkFixedLayout - handle::Ptr{GObject} - function GtkFixedLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFixedLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFixedLayout] = GtkFixedLayoutLeaf - (GLib.g_type(::Type{T}) where T <: GtkFixedLayout) = begin - ccall(("gtk_fixed_layout_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFixedLayout GtkLayoutManager libgtk4 gtk_fixed_layout_get_type begin function GLib.signalnames(::Type{GtkFixedLayout}) signalnames(supertype(GtkFixedLayout)) end end - begin - abstract type GtkFixedLayoutChild <: GtkLayoutChild end - mutable struct GtkFixedLayoutChildLeaf <: GtkFixedLayoutChild - handle::Ptr{GObject} - function GtkFixedLayoutChildLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFixedLayoutChildLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFixedLayoutChild] = GtkFixedLayoutChildLeaf - (GLib.g_type(::Type{T}) where T <: GtkFixedLayoutChild) = begin - ccall(("gtk_fixed_layout_child_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFixedLayoutChild GtkLayoutChild libgtk4 gtk_fixed_layout_child_get_type begin function GLib.signalnames(::Type{GtkFixedLayoutChild}) signalnames(supertype(GtkFixedLayoutChild)) end end - begin - abstract type GtkFlattenListModel <: GObject end - mutable struct GtkFlattenListModelLeaf <: GtkFlattenListModel - handle::Ptr{GObject} - function GtkFlattenListModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFlattenListModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFlattenListModel] = GtkFlattenListModelLeaf - (GLib.g_type(::Type{T}) where T <: GtkFlattenListModel) = begin - ccall(("gtk_flatten_list_model_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFlattenListModel GObject libgtk4 gtk_flatten_list_model_get_type begin function GLib.signalnames(::Type{GtkFlattenListModel}) vcat([:items_changed, :sections_changed], signalnames(supertype(GtkFlattenListModel))) @@ -3657,23 +1713,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFlowBox <: GtkWidget end - mutable struct GtkFlowBoxLeaf <: GtkFlowBox - handle::Ptr{GObject} - function GtkFlowBoxLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFlowBoxLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFlowBox] = GtkFlowBoxLeaf - (GLib.g_type(::Type{T}) where T <: GtkFlowBox) = begin - ccall(("gtk_flow_box_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFlowBox GtkWidget libgtk4 gtk_flow_box_get_type begin function GLib.signalnames(::Type{GtkFlowBox}) vcat([:activate_cursor_child, :child_activated, :move_cursor, :select_all, :selected_children_changed, :toggle_cursor_child, :unselect_all], signalnames(supertype(GtkFlowBox))) @@ -3687,23 +1727,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFlowBoxChild <: GtkWidget end - mutable struct GtkFlowBoxChildLeaf <: GtkFlowBoxChild - handle::Ptr{GObject} - function GtkFlowBoxChildLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFlowBoxChildLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFlowBoxChild] = GtkFlowBoxChildLeaf - (GLib.g_type(::Type{T}) where T <: GtkFlowBoxChild) = begin - ccall(("gtk_flow_box_child_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFlowBoxChild GtkWidget libgtk4 gtk_flow_box_child_get_type begin function GLib.signalnames(::Type{GtkFlowBoxChild}) vcat([:activate], signalnames(supertype(GtkFlowBoxChild))) @@ -3717,23 +1741,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFontButton <: GtkWidget end - mutable struct GtkFontButtonLeaf <: GtkFontButton - handle::Ptr{GObject} - function GtkFontButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFontButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFontButton] = GtkFontButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkFontButton) = begin - ccall(("gtk_font_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFontButton GtkWidget libgtk4 gtk_font_button_get_type begin function GLib.signalnames(::Type{GtkFontButton}) vcat([:activate, :font_set, :font_activated], signalnames(supertype(GtkFontButton))) @@ -3747,23 +1755,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFontChooserDialog <: GtkDialog end - mutable struct GtkFontChooserDialogLeaf <: GtkFontChooserDialog - handle::Ptr{GObject} - function GtkFontChooserDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFontChooserDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFontChooserDialog] = GtkFontChooserDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkFontChooserDialog) = begin - ccall(("gtk_font_chooser_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFontChooserDialog GtkDialog libgtk4 gtk_font_chooser_dialog_get_type begin function GLib.signalnames(::Type{GtkFontChooserDialog}) vcat([:font_activated], signalnames(supertype(GtkFontChooserDialog))) @@ -3777,23 +1769,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFontChooserWidget <: GtkWidget end - mutable struct GtkFontChooserWidgetLeaf <: GtkFontChooserWidget - handle::Ptr{GObject} - function GtkFontChooserWidgetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFontChooserWidgetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFontChooserWidget] = GtkFontChooserWidgetLeaf - (GLib.g_type(::Type{T}) where T <: GtkFontChooserWidget) = begin - ccall(("gtk_font_chooser_widget_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFontChooserWidget GtkWidget libgtk4 gtk_font_chooser_widget_get_type begin function GLib.signalnames(::Type{GtkFontChooserWidget}) vcat([:font_activated], signalnames(supertype(GtkFontChooserWidget))) @@ -3807,45 +1783,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFontDialog <: GObject end - mutable struct GtkFontDialogLeaf <: GtkFontDialog - handle::Ptr{GObject} - function GtkFontDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFontDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFontDialog] = GtkFontDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkFontDialog) = begin - ccall(("gtk_font_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFontDialog GObject libgtk4 gtk_font_dialog_get_type begin function GLib.signalnames(::Type{GtkFontDialog}) signalnames(supertype(GtkFontDialog)) end end - begin - abstract type GtkFontDialogButton <: GtkWidget end - mutable struct GtkFontDialogButtonLeaf <: GtkFontDialogButton - handle::Ptr{GObject} - function GtkFontDialogButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFontDialogButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFontDialogButton] = GtkFontDialogButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkFontDialogButton) = begin - ccall(("gtk_font_dialog_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFontDialogButton GtkWidget libgtk4 gtk_font_dialog_button_get_type begin function GLib.signalnames(::Type{GtkFontDialogButton}) vcat([:activate], signalnames(supertype(GtkFontDialogButton))) @@ -3859,45 +1803,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkFrame <: GtkWidget end - mutable struct GtkFrameLeaf <: GtkFrame - handle::Ptr{GObject} - function GtkFrameLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkFrameLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkFrame] = GtkFrameLeaf - (GLib.g_type(::Type{T}) where T <: GtkFrame) = begin - ccall(("gtk_frame_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkFrame GtkWidget libgtk4 gtk_frame_get_type begin function GLib.signalnames(::Type{GtkFrame}) signalnames(supertype(GtkFrame)) end end - begin - abstract type GtkGLArea <: GtkWidget end - mutable struct GtkGLAreaLeaf <: GtkGLArea - handle::Ptr{GObject} - function GtkGLAreaLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGLAreaLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGLArea] = GtkGLAreaLeaf - (GLib.g_type(::Type{T}) where T <: GtkGLArea) = begin - ccall(("gtk_gl_area_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGLArea GtkWidget libgtk4 gtk_gl_area_get_type begin function GLib.signalnames(::Type{GtkGLArea}) vcat([:create_context, :render, :resize], signalnames(supertype(GtkGLArea))) @@ -3911,23 +1823,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkGestureClick <: GtkGestureSingle end - mutable struct GtkGestureClickLeaf <: GtkGestureClick - handle::Ptr{GObject} - function GtkGestureClickLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGestureClickLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGestureClick] = GtkGestureClickLeaf - (GLib.g_type(::Type{T}) where T <: GtkGestureClick) = begin - ccall(("gtk_gesture_click_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGestureClick GtkGestureSingle libgtk4 gtk_gesture_click_get_type begin function GLib.signalnames(::Type{GtkGestureClick}) vcat([:pressed, :released, :stopped, :unpaired_release], signalnames(supertype(GtkGestureClick))) @@ -3941,23 +1837,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkGestureDrag <: GtkGestureSingle end - mutable struct GtkGestureDragLeaf <: GtkGestureDrag - handle::Ptr{GObject} - function GtkGestureDragLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGestureDragLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGestureDrag] = GtkGestureDragLeaf - (GLib.g_type(::Type{T}) where T <: GtkGestureDrag) = begin - ccall(("gtk_gesture_drag_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGestureDrag GtkGestureSingle libgtk4 gtk_gesture_drag_get_type begin function GLib.signalnames(::Type{GtkGestureDrag}) vcat([:drag_begin, :drag_end, :drag_update], signalnames(supertype(GtkGestureDrag))) @@ -3971,23 +1851,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkGestureLongPress <: GtkGestureSingle end - mutable struct GtkGestureLongPressLeaf <: GtkGestureLongPress - handle::Ptr{GObject} - function GtkGestureLongPressLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGestureLongPressLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGestureLongPress] = GtkGestureLongPressLeaf - (GLib.g_type(::Type{T}) where T <: GtkGestureLongPress) = begin - ccall(("gtk_gesture_long_press_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGestureLongPress GtkGestureSingle libgtk4 gtk_gesture_long_press_get_type begin function GLib.signalnames(::Type{GtkGestureLongPress}) vcat([:cancelled, :pressed], signalnames(supertype(GtkGestureLongPress))) @@ -4001,23 +1865,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkGesturePan <: GtkGestureDrag end - mutable struct GtkGesturePanLeaf <: GtkGesturePan - handle::Ptr{GObject} - function GtkGesturePanLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGesturePanLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGesturePan] = GtkGesturePanLeaf - (GLib.g_type(::Type{T}) where T <: GtkGesturePan) = begin - ccall(("gtk_gesture_pan_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGesturePan GtkGestureDrag libgtk4 gtk_gesture_pan_get_type begin function GLib.signalnames(::Type{GtkGesturePan}) vcat([:pan], signalnames(supertype(GtkGesturePan))) @@ -4031,23 +1879,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkGestureRotate <: GtkGesture end - mutable struct GtkGestureRotateLeaf <: GtkGestureRotate - handle::Ptr{GObject} - function GtkGestureRotateLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGestureRotateLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGestureRotate] = GtkGestureRotateLeaf - (GLib.g_type(::Type{T}) where T <: GtkGestureRotate) = begin - ccall(("gtk_gesture_rotate_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGestureRotate GtkGesture libgtk4 gtk_gesture_rotate_get_type begin function GLib.signalnames(::Type{GtkGestureRotate}) vcat([:angle_changed], signalnames(supertype(GtkGestureRotate))) @@ -4061,23 +1893,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkGestureStylus <: GtkGestureSingle end - mutable struct GtkGestureStylusLeaf <: GtkGestureStylus - handle::Ptr{GObject} - function GtkGestureStylusLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGestureStylusLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGestureStylus] = GtkGestureStylusLeaf - (GLib.g_type(::Type{T}) where T <: GtkGestureStylus) = begin - ccall(("gtk_gesture_stylus_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGestureStylus GtkGestureSingle libgtk4 gtk_gesture_stylus_get_type begin function GLib.signalnames(::Type{GtkGestureStylus}) vcat([:down, :motion, :proximity, :up], signalnames(supertype(GtkGestureStylus))) @@ -4091,23 +1907,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkGestureSwipe <: GtkGestureSingle end - mutable struct GtkGestureSwipeLeaf <: GtkGestureSwipe - handle::Ptr{GObject} - function GtkGestureSwipeLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGestureSwipeLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGestureSwipe] = GtkGestureSwipeLeaf - (GLib.g_type(::Type{T}) where T <: GtkGestureSwipe) = begin - ccall(("gtk_gesture_swipe_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGestureSwipe GtkGestureSingle libgtk4 gtk_gesture_swipe_get_type begin function GLib.signalnames(::Type{GtkGestureSwipe}) vcat([:swipe], signalnames(supertype(GtkGestureSwipe))) @@ -4121,23 +1921,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkGestureZoom <: GtkGesture end - mutable struct GtkGestureZoomLeaf <: GtkGestureZoom - handle::Ptr{GObject} - function GtkGestureZoomLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGestureZoomLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGestureZoom] = GtkGestureZoomLeaf - (GLib.g_type(::Type{T}) where T <: GtkGestureZoom) = begin - ccall(("gtk_gesture_zoom_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGestureZoom GtkGesture libgtk4 gtk_gesture_zoom_get_type begin function GLib.signalnames(::Type{GtkGestureZoom}) vcat([:scale_changed], signalnames(supertype(GtkGestureZoom))) @@ -4151,133 +1935,37 @@ $(Expr(:toplevel, quote end end end + GLib.@Gobject GtkGraphicsOffload GtkWidget libgtk4 gtk_graphics_offload_get_type begin - abstract type GtkGraphicsOffload <: GtkWidget end - mutable struct GtkGraphicsOffloadLeaf <: GtkGraphicsOffload - handle::Ptr{GObject} - function GtkGraphicsOffloadLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGraphicsOffloadLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGraphicsOffload] = GtkGraphicsOffloadLeaf - (GLib.g_type(::Type{T}) where T <: GtkGraphicsOffload) = begin - ccall(("gtk_graphics_offload_get_type", libgtk4), GType, ()) - end - end - begin - function GLib.signalnames(::Type{GtkGraphicsOffload}) - signalnames(supertype(GtkGraphicsOffload)) - end - end - begin - abstract type GtkGrid <: GtkWidget end - mutable struct GtkGridLeaf <: GtkGrid - handle::Ptr{GObject} - function GtkGridLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGridLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGrid] = GtkGridLeaf - (GLib.g_type(::Type{T}) where T <: GtkGrid) = begin - ccall(("gtk_grid_get_type", libgtk4), GType, ()) - end - end - begin - function GLib.signalnames(::Type{GtkGrid}) - signalnames(supertype(GtkGrid)) + function GLib.signalnames(::Type{GtkGraphicsOffload}) + signalnames(supertype(GtkGraphicsOffload)) end end + GLib.@Gobject GtkGrid GtkWidget libgtk4 gtk_grid_get_type begin - abstract type GtkGridLayout <: GtkLayoutManager end - mutable struct GtkGridLayoutLeaf <: GtkGridLayout - handle::Ptr{GObject} - function GtkGridLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGridLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end + function GLib.signalnames(::Type{GtkGrid}) + signalnames(supertype(GtkGrid)) end - gtype_wrapper_cache[:GtkGridLayout] = GtkGridLayoutLeaf - (GLib.g_type(::Type{T}) where T <: GtkGridLayout) = begin - ccall(("gtk_grid_layout_get_type", libgtk4), GType, ()) - end end + GLib.@Gobject GtkGridLayout GtkLayoutManager libgtk4 gtk_grid_layout_get_type begin function GLib.signalnames(::Type{GtkGridLayout}) signalnames(supertype(GtkGridLayout)) end end - begin - abstract type GtkGridLayoutChild <: GtkLayoutChild end - mutable struct GtkGridLayoutChildLeaf <: GtkGridLayoutChild - handle::Ptr{GObject} - function GtkGridLayoutChildLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGridLayoutChildLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGridLayoutChild] = GtkGridLayoutChildLeaf - (GLib.g_type(::Type{T}) where T <: GtkGridLayoutChild) = begin - ccall(("gtk_grid_layout_child_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGridLayoutChild GtkLayoutChild libgtk4 gtk_grid_layout_child_get_type begin function GLib.signalnames(::Type{GtkGridLayoutChild}) signalnames(supertype(GtkGridLayoutChild)) end end - begin - abstract type GtkListBase <: GtkWidget end - mutable struct GtkListBaseLeaf <: GtkListBase - handle::Ptr{GObject} - function GtkListBaseLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkListBaseLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkListBase] = GtkListBaseLeaf - (GLib.g_type(::Type{T}) where T <: GtkListBase) = begin - ccall(("gtk_list_base_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkListBase GtkWidget libgtk4 gtk_list_base_get_type begin function GLib.signalnames(::Type{GtkListBase}) signalnames(supertype(GtkListBase)) end end - begin - abstract type GtkGridView <: GtkListBase end - mutable struct GtkGridViewLeaf <: GtkGridView - handle::Ptr{GObject} - function GtkGridViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkGridViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkGridView] = GtkGridViewLeaf - (GLib.g_type(::Type{T}) where T <: GtkGridView) = begin - ccall(("gtk_grid_view_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkGridView GtkListBase libgtk4 gtk_grid_view_get_type begin function GLib.signalnames(::Type{GtkGridView}) vcat([:activate], signalnames(supertype(GtkGridView))) @@ -4291,45 +1979,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkHeaderBar <: GtkWidget end - mutable struct GtkHeaderBarLeaf <: GtkHeaderBar - handle::Ptr{GObject} - function GtkHeaderBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkHeaderBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkHeaderBar] = GtkHeaderBarLeaf - (GLib.g_type(::Type{T}) where T <: GtkHeaderBar) = begin - ccall(("gtk_header_bar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkHeaderBar GtkWidget libgtk4 gtk_header_bar_get_type begin function GLib.signalnames(::Type{GtkHeaderBar}) signalnames(supertype(GtkHeaderBar)) end end - begin - abstract type GtkIMContext <: GObject end - mutable struct GtkIMContextLeaf <: GtkIMContext - handle::Ptr{GObject} - function GtkIMContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkIMContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkIMContext] = GtkIMContextLeaf - (GLib.g_type(::Type{T}) where T <: GtkIMContext) = begin - ccall(("gtk_im_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkIMContext GObject libgtk4 gtk_im_context_get_type begin function GLib.signalnames(::Type{GtkIMContext}) vcat([:commit, :delete_surrounding, :preedit_changed, :preedit_end, :preedit_start, :retrieve_surrounding], signalnames(supertype(GtkIMContext))) @@ -4343,67 +1999,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkIMContextSimple <: GtkIMContext end - mutable struct GtkIMContextSimpleLeaf <: GtkIMContextSimple - handle::Ptr{GObject} - function GtkIMContextSimpleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkIMContextSimpleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkIMContextSimple] = GtkIMContextSimpleLeaf - (GLib.g_type(::Type{T}) where T <: GtkIMContextSimple) = begin - ccall(("gtk_im_context_simple_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkIMContextSimple GtkIMContext libgtk4 gtk_im_context_simple_get_type begin function GLib.signalnames(::Type{GtkIMContextSimple}) signalnames(supertype(GtkIMContextSimple)) end end - begin - abstract type GtkIMMulticontext <: GtkIMContext end - mutable struct GtkIMMulticontextLeaf <: GtkIMMulticontext - handle::Ptr{GObject} - function GtkIMMulticontextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkIMMulticontextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkIMMulticontext] = GtkIMMulticontextLeaf - (GLib.g_type(::Type{T}) where T <: GtkIMMulticontext) = begin - ccall(("gtk_im_multicontext_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkIMMulticontext GtkIMContext libgtk4 gtk_im_multicontext_get_type begin function GLib.signalnames(::Type{GtkIMMulticontext}) signalnames(supertype(GtkIMMulticontext)) end end - begin - abstract type GtkIconPaintable <: GObject end - mutable struct GtkIconPaintableLeaf <: GtkIconPaintable - handle::Ptr{GObject} - function GtkIconPaintableLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkIconPaintableLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkIconPaintable] = GtkIconPaintableLeaf - (GLib.g_type(::Type{T}) where T <: GtkIconPaintable) = begin - ccall(("gtk_icon_paintable_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkIconPaintable GObject libgtk4 gtk_icon_paintable_get_type begin function GLib.signalnames(::Type{GtkIconPaintable}) vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GtkIconPaintable))) @@ -4417,23 +2025,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkIconTheme <: GObject end - mutable struct GtkIconThemeLeaf <: GtkIconTheme - handle::Ptr{GObject} - function GtkIconThemeLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkIconThemeLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkIconTheme] = GtkIconThemeLeaf - (GLib.g_type(::Type{T}) where T <: GtkIconTheme) = begin - ccall(("gtk_icon_theme_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkIconTheme GObject libgtk4 gtk_icon_theme_get_type begin function GLib.signalnames(::Type{GtkIconTheme}) vcat([:changed], signalnames(supertype(GtkIconTheme))) @@ -4447,23 +2039,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkIconView <: GtkWidget end - mutable struct GtkIconViewLeaf <: GtkIconView - handle::Ptr{GObject} - function GtkIconViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkIconViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkIconView] = GtkIconViewLeaf - (GLib.g_type(::Type{T}) where T <: GtkIconView) = begin - ccall(("gtk_icon_view_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkIconView GtkWidget libgtk4 gtk_icon_view_get_type begin function GLib.signalnames(::Type{GtkIconView}) vcat([:activate_cursor_item, :item_activated, :move_cursor, :select_all, :select_cursor_item, :selection_changed, :toggle_cursor_item, :unselect_all], signalnames(supertype(GtkIconView))) @@ -4477,45 +2053,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkImage <: GtkWidget end - mutable struct GtkImageLeaf <: GtkImage - handle::Ptr{GObject} - function GtkImageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkImageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkImage] = GtkImageLeaf - (GLib.g_type(::Type{T}) where T <: GtkImage) = begin - ccall(("gtk_image_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkImage GtkWidget libgtk4 gtk_image_get_type begin function GLib.signalnames(::Type{GtkImage}) signalnames(supertype(GtkImage)) end end - begin - abstract type GtkInfoBar <: GtkWidget end - mutable struct GtkInfoBarLeaf <: GtkInfoBar - handle::Ptr{GObject} - function GtkInfoBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkInfoBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkInfoBar] = GtkInfoBarLeaf - (GLib.g_type(::Type{T}) where T <: GtkInfoBar) = begin - ccall(("gtk_info_bar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkInfoBar GtkWidget libgtk4 gtk_info_bar_get_type begin function GLib.signalnames(::Type{GtkInfoBar}) vcat([:close, :response], signalnames(supertype(GtkInfoBar))) @@ -4529,67 +2073,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkInscription <: GtkWidget end - mutable struct GtkInscriptionLeaf <: GtkInscription - handle::Ptr{GObject} - function GtkInscriptionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkInscriptionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkInscription] = GtkInscriptionLeaf - (GLib.g_type(::Type{T}) where T <: GtkInscription) = begin - ccall(("gtk_inscription_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkInscription GtkWidget libgtk4 gtk_inscription_get_type begin function GLib.signalnames(::Type{GtkInscription}) signalnames(supertype(GtkInscription)) end end - begin - abstract type GtkKeyvalTrigger <: GtkShortcutTrigger end - mutable struct GtkKeyvalTriggerLeaf <: GtkKeyvalTrigger - handle::Ptr{GObject} - function GtkKeyvalTriggerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkKeyvalTriggerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkKeyvalTrigger] = GtkKeyvalTriggerLeaf - (GLib.g_type(::Type{T}) where T <: GtkKeyvalTrigger) = begin - ccall(("gtk_keyval_trigger_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkKeyvalTrigger GtkShortcutTrigger libgtk4 gtk_keyval_trigger_get_type begin function GLib.signalnames(::Type{GtkKeyvalTrigger}) signalnames(supertype(GtkKeyvalTrigger)) end end - begin - abstract type GtkLabel <: GtkWidget end - mutable struct GtkLabelLeaf <: GtkLabel - handle::Ptr{GObject} - function GtkLabelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkLabelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkLabel] = GtkLabelLeaf - (GLib.g_type(::Type{T}) where T <: GtkLabel) = begin - ccall(("gtk_label_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkLabel GtkWidget libgtk4 gtk_label_get_type begin function GLib.signalnames(::Type{GtkLabel}) vcat([:activate_current_link, :activate_link, :copy_clipboard, :move_cursor], signalnames(supertype(GtkLabel))) @@ -4603,23 +2099,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkLevelBar <: GtkWidget end - mutable struct GtkLevelBarLeaf <: GtkLevelBar - handle::Ptr{GObject} - function GtkLevelBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkLevelBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkLevelBar] = GtkLevelBarLeaf - (GLib.g_type(::Type{T}) where T <: GtkLevelBar) = begin - ccall(("gtk_level_bar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkLevelBar GtkWidget libgtk4 gtk_level_bar_get_type begin function GLib.signalnames(::Type{GtkLevelBar}) vcat([:offset_changed], signalnames(supertype(GtkLevelBar))) @@ -4633,23 +2113,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkLinkButton <: GtkButton end - mutable struct GtkLinkButtonLeaf <: GtkLinkButton - handle::Ptr{GObject} - function GtkLinkButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkLinkButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkLinkButton] = GtkLinkButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkLinkButton) = begin - ccall(("gtk_link_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkLinkButton GtkButton libgtk4 gtk_link_button_get_type begin function GLib.signalnames(::Type{GtkLinkButton}) vcat([:activate_link], signalnames(supertype(GtkLinkButton))) @@ -4663,23 +2127,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkListBox <: GtkWidget end - mutable struct GtkListBoxLeaf <: GtkListBox - handle::Ptr{GObject} - function GtkListBoxLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkListBoxLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkListBox] = GtkListBoxLeaf - (GLib.g_type(::Type{T}) where T <: GtkListBox) = begin - ccall(("gtk_list_box_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkListBox GtkWidget libgtk4 gtk_list_box_get_type begin function GLib.signalnames(::Type{GtkListBox}) vcat([:activate_cursor_row, :move_cursor, :row_activated, :row_selected, :select_all, :selected_rows_changed, :toggle_cursor_row, :unselect_all], signalnames(supertype(GtkListBox))) @@ -4693,23 +2141,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkListBoxRow <: GtkWidget end - mutable struct GtkListBoxRowLeaf <: GtkListBoxRow - handle::Ptr{GObject} - function GtkListBoxRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkListBoxRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkListBoxRow] = GtkListBoxRowLeaf - (GLib.g_type(::Type{T}) where T <: GtkListBoxRow) = begin - ccall(("gtk_list_box_row_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkListBoxRow GtkWidget libgtk4 gtk_list_box_row_get_type begin function GLib.signalnames(::Type{GtkListBoxRow}) vcat([:activate], signalnames(supertype(GtkListBoxRow))) @@ -4723,45 +2155,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkListHeader <: GObject end - mutable struct GtkListHeaderLeaf <: GtkListHeader - handle::Ptr{GObject} - function GtkListHeaderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkListHeaderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkListHeader] = GtkListHeaderLeaf - (GLib.g_type(::Type{T}) where T <: GtkListHeader) = begin - ccall(("gtk_list_header_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkListHeader GObject libgtk4 gtk_list_header_get_type begin function GLib.signalnames(::Type{GtkListHeader}) signalnames(supertype(GtkListHeader)) end end - begin - abstract type GtkListStore <: GObject end - mutable struct GtkListStoreLeaf <: GtkListStore - handle::Ptr{GObject} - function GtkListStoreLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkListStoreLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkListStore] = GtkListStoreLeaf - (GLib.g_type(::Type{T}) where T <: GtkListStore) = begin - ccall(("gtk_list_store_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkListStore GObject libgtk4 gtk_list_store_get_type begin function GLib.signalnames(::Type{GtkListStore}) vcat([:row_changed, :row_deleted, :row_has_child_toggled, :row_inserted, :sort_column_changed], signalnames(supertype(GtkListStore))) @@ -4775,23 +2175,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkListView <: GtkListBase end - mutable struct GtkListViewLeaf <: GtkListView - handle::Ptr{GObject} - function GtkListViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkListViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkListView] = GtkListViewLeaf - (GLib.g_type(::Type{T}) where T <: GtkListView) = begin - ccall(("gtk_list_view_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkListView GtkListBase libgtk4 gtk_list_view_get_type begin function GLib.signalnames(::Type{GtkListView}) vcat([:activate], signalnames(supertype(GtkListView))) @@ -4805,45 +2189,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkLockButton <: GtkButton end - mutable struct GtkLockButtonLeaf <: GtkLockButton - handle::Ptr{GObject} - function GtkLockButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkLockButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkLockButton] = GtkLockButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkLockButton) = begin - ccall(("gtk_lock_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkLockButton GtkButton libgtk4 gtk_lock_button_get_type begin function GLib.signalnames(::Type{GtkLockButton}) signalnames(supertype(GtkLockButton)) end end - begin - abstract type GtkMapListModel <: GObject end - mutable struct GtkMapListModelLeaf <: GtkMapListModel - handle::Ptr{GObject} - function GtkMapListModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMapListModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMapListModel] = GtkMapListModelLeaf - (GLib.g_type(::Type{T}) where T <: GtkMapListModel) = begin - ccall(("gtk_map_list_model_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMapListModel GObject libgtk4 gtk_map_list_model_get_type begin function GLib.signalnames(::Type{GtkMapListModel}) vcat([:items_changed, :sections_changed], signalnames(supertype(GtkMapListModel))) @@ -4857,45 +2209,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkMediaControls <: GtkWidget end - mutable struct GtkMediaControlsLeaf <: GtkMediaControls - handle::Ptr{GObject} - function GtkMediaControlsLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMediaControlsLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMediaControls] = GtkMediaControlsLeaf - (GLib.g_type(::Type{T}) where T <: GtkMediaControls) = begin - ccall(("gtk_media_controls_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMediaControls GtkWidget libgtk4 gtk_media_controls_get_type begin function GLib.signalnames(::Type{GtkMediaControls}) signalnames(supertype(GtkMediaControls)) end end - begin - abstract type GtkMediaStream <: GObject end - mutable struct GtkMediaStreamLeaf <: GtkMediaStream - handle::Ptr{GObject} - function GtkMediaStreamLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMediaStreamLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMediaStream] = GtkMediaStreamLeaf - (GLib.g_type(::Type{T}) where T <: GtkMediaStream) = begin - ccall(("gtk_media_stream_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMediaStream GObject libgtk4 gtk_media_stream_get_type begin function GLib.signalnames(::Type{GtkMediaStream}) vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GtkMediaStream))) @@ -4909,23 +2229,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkMediaFile <: GtkMediaStream end - mutable struct GtkMediaFileLeaf <: GtkMediaFile - handle::Ptr{GObject} - function GtkMediaFileLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMediaFileLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMediaFile] = GtkMediaFileLeaf - (GLib.g_type(::Type{T}) where T <: GtkMediaFile) = begin - ccall(("gtk_media_file_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMediaFile GtkMediaStream libgtk4 gtk_media_file_get_type begin function GLib.signalnames(::Type{GtkMediaFile}) vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GtkMediaFile))) @@ -4939,23 +2243,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkMenuButton <: GtkWidget end - mutable struct GtkMenuButtonLeaf <: GtkMenuButton - handle::Ptr{GObject} - function GtkMenuButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMenuButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMenuButton] = GtkMenuButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkMenuButton) = begin - ccall(("gtk_menu_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMenuButton GtkWidget libgtk4 gtk_menu_button_get_type begin function GLib.signalnames(::Type{GtkMenuButton}) vcat([:activate], signalnames(supertype(GtkMenuButton))) @@ -4969,111 +2257,31 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkMessageDialog <: GtkDialog end - mutable struct GtkMessageDialogLeaf <: GtkMessageDialog - handle::Ptr{GObject} - function GtkMessageDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMessageDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMessageDialog] = GtkMessageDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkMessageDialog) = begin - ccall(("gtk_message_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMessageDialog GtkDialog libgtk4 gtk_message_dialog_get_type begin function GLib.signalnames(::Type{GtkMessageDialog}) signalnames(supertype(GtkMessageDialog)) end end - begin - abstract type GtkMnemonicAction <: GtkShortcutAction end - mutable struct GtkMnemonicActionLeaf <: GtkMnemonicAction - handle::Ptr{GObject} - function GtkMnemonicActionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMnemonicActionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMnemonicAction] = GtkMnemonicActionLeaf - (GLib.g_type(::Type{T}) where T <: GtkMnemonicAction) = begin - ccall(("gtk_mnemonic_action_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMnemonicAction GtkShortcutAction libgtk4 gtk_mnemonic_action_get_type begin function GLib.signalnames(::Type{GtkMnemonicAction}) signalnames(supertype(GtkMnemonicAction)) end end - begin - abstract type GtkMnemonicTrigger <: GtkShortcutTrigger end - mutable struct GtkMnemonicTriggerLeaf <: GtkMnemonicTrigger - handle::Ptr{GObject} - function GtkMnemonicTriggerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMnemonicTriggerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMnemonicTrigger] = GtkMnemonicTriggerLeaf - (GLib.g_type(::Type{T}) where T <: GtkMnemonicTrigger) = begin - ccall(("gtk_mnemonic_trigger_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMnemonicTrigger GtkShortcutTrigger libgtk4 gtk_mnemonic_trigger_get_type begin function GLib.signalnames(::Type{GtkMnemonicTrigger}) signalnames(supertype(GtkMnemonicTrigger)) end end - begin - abstract type GtkMountOperation <: GMountOperation end - mutable struct GtkMountOperationLeaf <: GtkMountOperation - handle::Ptr{GObject} - function GtkMountOperationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMountOperationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMountOperation] = GtkMountOperationLeaf - (GLib.g_type(::Type{T}) where T <: GtkMountOperation) = begin - ccall(("gtk_mount_operation_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMountOperation GMountOperation libgtk4 gtk_mount_operation_get_type begin function GLib.signalnames(::Type{GtkMountOperation}) signalnames(supertype(GtkMountOperation)) end end - begin - abstract type GtkMultiSelection <: GObject end - mutable struct GtkMultiSelectionLeaf <: GtkMultiSelection - handle::Ptr{GObject} - function GtkMultiSelectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMultiSelectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMultiSelection] = GtkMultiSelectionLeaf - (GLib.g_type(::Type{T}) where T <: GtkMultiSelection) = begin - ccall(("gtk_multi_selection_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMultiSelection GObject libgtk4 gtk_multi_selection_get_type begin function GLib.signalnames(::Type{GtkMultiSelection}) vcat([:items_changed, :sections_changed, :selection_changed], signalnames(supertype(GtkMultiSelection))) @@ -5087,23 +2295,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkMultiSorter <: GtkSorter end - mutable struct GtkMultiSorterLeaf <: GtkMultiSorter - handle::Ptr{GObject} - function GtkMultiSorterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkMultiSorterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkMultiSorter] = GtkMultiSorterLeaf - (GLib.g_type(::Type{T}) where T <: GtkMultiSorter) = begin - ccall(("gtk_multi_sorter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkMultiSorter GtkSorter libgtk4 gtk_multi_sorter_get_type begin function GLib.signalnames(::Type{GtkMultiSorter}) vcat([:items_changed], signalnames(supertype(GtkMultiSorter))) @@ -5117,67 +2309,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkNamedAction <: GtkShortcutAction end - mutable struct GtkNamedActionLeaf <: GtkNamedAction - handle::Ptr{GObject} - function GtkNamedActionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkNamedActionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkNamedAction] = GtkNamedActionLeaf - (GLib.g_type(::Type{T}) where T <: GtkNamedAction) = begin - ccall(("gtk_named_action_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkNamedAction GtkShortcutAction libgtk4 gtk_named_action_get_type begin function GLib.signalnames(::Type{GtkNamedAction}) signalnames(supertype(GtkNamedAction)) end end - begin - abstract type GtkNeverTrigger <: GtkShortcutTrigger end - mutable struct GtkNeverTriggerLeaf <: GtkNeverTrigger - handle::Ptr{GObject} - function GtkNeverTriggerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkNeverTriggerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkNeverTrigger] = GtkNeverTriggerLeaf - (GLib.g_type(::Type{T}) where T <: GtkNeverTrigger) = begin - ccall(("gtk_never_trigger_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkNeverTrigger GtkShortcutTrigger libgtk4 gtk_never_trigger_get_type begin function GLib.signalnames(::Type{GtkNeverTrigger}) signalnames(supertype(GtkNeverTrigger)) end end - begin - abstract type GtkNoSelection <: GObject end - mutable struct GtkNoSelectionLeaf <: GtkNoSelection - handle::Ptr{GObject} - function GtkNoSelectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkNoSelectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkNoSelection] = GtkNoSelectionLeaf - (GLib.g_type(::Type{T}) where T <: GtkNoSelection) = begin - ccall(("gtk_no_selection_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkNoSelection GObject libgtk4 gtk_no_selection_get_type begin function GLib.signalnames(::Type{GtkNoSelection}) vcat([:items_changed, :sections_changed, :selection_changed], signalnames(supertype(GtkNoSelection))) @@ -5191,23 +2335,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkNotebook <: GtkWidget end - mutable struct GtkNotebookLeaf <: GtkNotebook - handle::Ptr{GObject} - function GtkNotebookLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkNotebookLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkNotebook] = GtkNotebookLeaf - (GLib.g_type(::Type{T}) where T <: GtkNotebook) = begin - ccall(("gtk_notebook_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkNotebook GtkWidget libgtk4 gtk_notebook_get_type begin function GLib.signalnames(::Type{GtkNotebook}) vcat([:change_current_page, :create_window, :focus_tab, :move_focus_out, :page_added, :page_removed, :page_reordered, :reorder_tab, :select_page, :switch_page], signalnames(supertype(GtkNotebook))) @@ -5221,67 +2349,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkNotebookPage <: GObject end - mutable struct GtkNotebookPageLeaf <: GtkNotebookPage - handle::Ptr{GObject} - function GtkNotebookPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkNotebookPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkNotebookPage] = GtkNotebookPageLeaf - (GLib.g_type(::Type{T}) where T <: GtkNotebookPage) = begin - ccall(("gtk_notebook_page_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkNotebookPage GObject libgtk4 gtk_notebook_page_get_type begin function GLib.signalnames(::Type{GtkNotebookPage}) signalnames(supertype(GtkNotebookPage)) end end - begin - abstract type GtkNothingAction <: GtkShortcutAction end - mutable struct GtkNothingActionLeaf <: GtkNothingAction - handle::Ptr{GObject} - function GtkNothingActionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkNothingActionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkNothingAction] = GtkNothingActionLeaf - (GLib.g_type(::Type{T}) where T <: GtkNothingAction) = begin - ccall(("gtk_nothing_action_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkNothingAction GtkShortcutAction libgtk4 gtk_nothing_action_get_type begin function GLib.signalnames(::Type{GtkNothingAction}) - signalnames(supertype(GtkNothingAction)) - end - end - begin - abstract type GtkNumericSorter <: GtkSorter end - mutable struct GtkNumericSorterLeaf <: GtkNumericSorter - handle::Ptr{GObject} - function GtkNumericSorterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkNumericSorterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end + signalnames(supertype(GtkNothingAction)) end - gtype_wrapper_cache[:GtkNumericSorter] = GtkNumericSorterLeaf - (GLib.g_type(::Type{T}) where T <: GtkNumericSorter) = begin - ccall(("gtk_numeric_sorter_get_type", libgtk4), GType, ()) - end end + GLib.@Gobject GtkNumericSorter GtkSorter libgtk4 gtk_numeric_sorter_get_type begin function GLib.signalnames(::Type{GtkNumericSorter}) signalnames(supertype(GtkNumericSorter)) @@ -5295,23 +2375,7 @@ $(Expr(:toplevel, quote handle::Ptr{GtkExpression} end end - begin - abstract type GtkOverlay <: GtkWidget end - mutable struct GtkOverlayLeaf <: GtkOverlay - handle::Ptr{GObject} - function GtkOverlayLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkOverlayLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkOverlay] = GtkOverlayLeaf - (GLib.g_type(::Type{T}) where T <: GtkOverlay) = begin - ccall(("gtk_overlay_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkOverlay GtkWidget libgtk4 gtk_overlay_get_type begin function GLib.signalnames(::Type{GtkOverlay}) vcat([:get_child_position], signalnames(supertype(GtkOverlay))) @@ -5325,111 +2389,31 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkOverlayLayout <: GtkLayoutManager end - mutable struct GtkOverlayLayoutLeaf <: GtkOverlayLayout - handle::Ptr{GObject} - function GtkOverlayLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkOverlayLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkOverlayLayout] = GtkOverlayLayoutLeaf - (GLib.g_type(::Type{T}) where T <: GtkOverlayLayout) = begin - ccall(("gtk_overlay_layout_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkOverlayLayout GtkLayoutManager libgtk4 gtk_overlay_layout_get_type begin function GLib.signalnames(::Type{GtkOverlayLayout}) signalnames(supertype(GtkOverlayLayout)) end end - begin - abstract type GtkOverlayLayoutChild <: GtkLayoutChild end - mutable struct GtkOverlayLayoutChildLeaf <: GtkOverlayLayoutChild - handle::Ptr{GObject} - function GtkOverlayLayoutChildLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkOverlayLayoutChildLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkOverlayLayoutChild] = GtkOverlayLayoutChildLeaf - (GLib.g_type(::Type{T}) where T <: GtkOverlayLayoutChild) = begin - ccall(("gtk_overlay_layout_child_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkOverlayLayoutChild GtkLayoutChild libgtk4 gtk_overlay_layout_child_get_type begin function GLib.signalnames(::Type{GtkOverlayLayoutChild}) signalnames(supertype(GtkOverlayLayoutChild)) end end - begin - abstract type GtkPadController <: GtkEventController end - mutable struct GtkPadControllerLeaf <: GtkPadController - handle::Ptr{GObject} - function GtkPadControllerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPadControllerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPadController] = GtkPadControllerLeaf - (GLib.g_type(::Type{T}) where T <: GtkPadController) = begin - ccall(("gtk_pad_controller_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPadController GtkEventController libgtk4 gtk_pad_controller_get_type begin function GLib.signalnames(::Type{GtkPadController}) signalnames(supertype(GtkPadController)) end end - begin - abstract type GtkPageSetup <: GObject end - mutable struct GtkPageSetupLeaf <: GtkPageSetup - handle::Ptr{GObject} - function GtkPageSetupLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPageSetupLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPageSetup] = GtkPageSetupLeaf - (GLib.g_type(::Type{T}) where T <: GtkPageSetup) = begin - ccall(("gtk_page_setup_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPageSetup GObject libgtk4 gtk_page_setup_get_type begin function GLib.signalnames(::Type{GtkPageSetup}) signalnames(supertype(GtkPageSetup)) end end - begin - abstract type GtkPaned <: GtkWidget end - mutable struct GtkPanedLeaf <: GtkPaned - handle::Ptr{GObject} - function GtkPanedLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPanedLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPaned] = GtkPanedLeaf - (GLib.g_type(::Type{T}) where T <: GtkPaned) = begin - ccall(("gtk_paned_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPaned GtkWidget libgtk4 gtk_paned_get_type begin function GLib.signalnames(::Type{GtkPaned}) vcat([:accept_position, :cancel_position, :cycle_child_focus, :cycle_handle_focus, :move_handle, :toggle_handle_focus], signalnames(supertype(GtkPaned))) @@ -5443,23 +2427,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkPasswordEntry <: GtkWidget end - mutable struct GtkPasswordEntryLeaf <: GtkPasswordEntry - handle::Ptr{GObject} - function GtkPasswordEntryLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPasswordEntryLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPasswordEntry] = GtkPasswordEntryLeaf - (GLib.g_type(::Type{T}) where T <: GtkPasswordEntry) = begin - ccall(("gtk_password_entry_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPasswordEntry GtkWidget libgtk4 gtk_password_entry_get_type begin function GLib.signalnames(::Type{GtkPasswordEntry}) vcat([:activate, :changed, :delete_text, :insert_text], signalnames(supertype(GtkPasswordEntry))) @@ -5473,155 +2441,43 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkPasswordEntryBuffer <: GtkEntryBuffer end - mutable struct GtkPasswordEntryBufferLeaf <: GtkPasswordEntryBuffer - handle::Ptr{GObject} - function GtkPasswordEntryBufferLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPasswordEntryBufferLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPasswordEntryBuffer] = GtkPasswordEntryBufferLeaf - (GLib.g_type(::Type{T}) where T <: GtkPasswordEntryBuffer) = begin - ccall(("gtk_password_entry_buffer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPasswordEntryBuffer GtkEntryBuffer libgtk4 gtk_password_entry_buffer_get_type begin function GLib.signalnames(::Type{GtkPasswordEntryBuffer}) signalnames(supertype(GtkPasswordEntryBuffer)) end end - begin - abstract type GtkPicture <: GtkWidget end - mutable struct GtkPictureLeaf <: GtkPicture - handle::Ptr{GObject} - function GtkPictureLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPictureLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPicture] = GtkPictureLeaf - (GLib.g_type(::Type{T}) where T <: GtkPicture) = begin - ccall(("gtk_picture_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPicture GtkWidget libgtk4 gtk_picture_get_type begin function GLib.signalnames(::Type{GtkPicture}) signalnames(supertype(GtkPicture)) end end - begin - abstract type GtkPopoverMenu <: GtkPopover end - mutable struct GtkPopoverMenuLeaf <: GtkPopoverMenu - handle::Ptr{GObject} - function GtkPopoverMenuLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPopoverMenuLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPopoverMenu] = GtkPopoverMenuLeaf - (GLib.g_type(::Type{T}) where T <: GtkPopoverMenu) = begin - ccall(("gtk_popover_menu_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPopoverMenu GtkPopover libgtk4 gtk_popover_menu_get_type begin function GLib.signalnames(::Type{GtkPopoverMenu}) signalnames(supertype(GtkPopoverMenu)) end end - begin - abstract type GtkPopoverMenuBar <: GtkWidget end - mutable struct GtkPopoverMenuBarLeaf <: GtkPopoverMenuBar - handle::Ptr{GObject} - function GtkPopoverMenuBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPopoverMenuBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPopoverMenuBar] = GtkPopoverMenuBarLeaf - (GLib.g_type(::Type{T}) where T <: GtkPopoverMenuBar) = begin - ccall(("gtk_popover_menu_bar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPopoverMenuBar GtkWidget libgtk4 gtk_popover_menu_bar_get_type begin function GLib.signalnames(::Type{GtkPopoverMenuBar}) signalnames(supertype(GtkPopoverMenuBar)) end end - begin - abstract type GtkPrintContext <: GObject end - mutable struct GtkPrintContextLeaf <: GtkPrintContext - handle::Ptr{GObject} - function GtkPrintContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPrintContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPrintContext] = GtkPrintContextLeaf - (GLib.g_type(::Type{T}) where T <: GtkPrintContext) = begin - ccall(("gtk_print_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPrintContext GObject libgtk4 gtk_print_context_get_type begin function GLib.signalnames(::Type{GtkPrintContext}) signalnames(supertype(GtkPrintContext)) end end - begin - abstract type GtkPrintDialog <: GObject end - mutable struct GtkPrintDialogLeaf <: GtkPrintDialog - handle::Ptr{GObject} - function GtkPrintDialogLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPrintDialogLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPrintDialog] = GtkPrintDialogLeaf - (GLib.g_type(::Type{T}) where T <: GtkPrintDialog) = begin - ccall(("gtk_print_dialog_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPrintDialog GObject libgtk4 gtk_print_dialog_get_type begin function GLib.signalnames(::Type{GtkPrintDialog}) signalnames(supertype(GtkPrintDialog)) end end - begin - abstract type GtkPrintJob <: GObject end - mutable struct GtkPrintJobLeaf <: GtkPrintJob - handle::Ptr{GObject} - function GtkPrintJobLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPrintJobLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPrintJob] = GtkPrintJobLeaf - (GLib.g_type(::Type{T}) where T <: GtkPrintJob) = begin - ccall(("gtk_print_job_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPrintJob GObject libgtk4 gtk_print_job_get_type begin function GLib.signalnames(::Type{GtkPrintJob}) vcat([:status_changed], signalnames(supertype(GtkPrintJob))) @@ -5635,23 +2491,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkPrintOperation <: GObject end - mutable struct GtkPrintOperationLeaf <: GtkPrintOperation - handle::Ptr{GObject} - function GtkPrintOperationLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPrintOperationLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPrintOperation] = GtkPrintOperationLeaf - (GLib.g_type(::Type{T}) where T <: GtkPrintOperation) = begin - ccall(("gtk_print_operation_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPrintOperation GObject libgtk4 gtk_print_operation_get_type begin function GLib.signalnames(::Type{GtkPrintOperation}) vcat([:begin_print, :create_custom_widget, :custom_widget_apply, :done, :draw_page, :end_print, :paginate, :preview, :request_page_setup, :status_changed, :update_custom_widget, :got_page_size, :ready], signalnames(supertype(GtkPrintOperation))) @@ -5665,45 +2505,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkPrintSettings <: GObject end - mutable struct GtkPrintSettingsLeaf <: GtkPrintSettings - handle::Ptr{GObject} - function GtkPrintSettingsLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPrintSettingsLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPrintSettings] = GtkPrintSettingsLeaf - (GLib.g_type(::Type{T}) where T <: GtkPrintSettings) = begin - ccall(("gtk_print_settings_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPrintSettings GObject libgtk4 gtk_print_settings_get_type begin function GLib.signalnames(::Type{GtkPrintSettings}) signalnames(supertype(GtkPrintSettings)) end end - begin - abstract type GtkPrinter <: GObject end - mutable struct GtkPrinterLeaf <: GtkPrinter - handle::Ptr{GObject} - function GtkPrinterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkPrinterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkPrinter] = GtkPrinterLeaf - (GLib.g_type(::Type{T}) where T <: GtkPrinter) = begin - ccall(("gtk_printer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkPrinter GObject libgtk4 gtk_printer_get_type begin function GLib.signalnames(::Type{GtkPrinter}) vcat([:details_acquired], signalnames(supertype(GtkPrinter))) @@ -5717,23 +2525,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkProgressBar <: GtkWidget end - mutable struct GtkProgressBarLeaf <: GtkProgressBar - handle::Ptr{GObject} - function GtkProgressBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkProgressBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkProgressBar] = GtkProgressBarLeaf - (GLib.g_type(::Type{T}) where T <: GtkProgressBar) = begin - ccall(("gtk_progress_bar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkProgressBar GtkWidget libgtk4 gtk_progress_bar_get_type begin function GLib.signalnames(::Type{GtkProgressBar}) signalnames(supertype(GtkProgressBar)) @@ -5747,23 +2539,7 @@ $(Expr(:toplevel, quote handle::Ptr{GtkExpression} end end - begin - abstract type GtkRange <: GtkWidget end - mutable struct GtkRangeLeaf <: GtkRange - handle::Ptr{GObject} - function GtkRangeLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkRangeLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkRange] = GtkRangeLeaf - (GLib.g_type(::Type{T}) where T <: GtkRange) = begin - ccall(("gtk_range_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkRange GtkWidget libgtk4 gtk_range_get_type begin function GLib.signalnames(::Type{GtkRange}) vcat([:adjust_bounds, :change_value, :move_slider, :value_changed], signalnames(supertype(GtkRange))) @@ -5777,23 +2553,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkRecentManager <: GObject end - mutable struct GtkRecentManagerLeaf <: GtkRecentManager - handle::Ptr{GObject} - function GtkRecentManagerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkRecentManagerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkRecentManager] = GtkRecentManagerLeaf - (GLib.g_type(::Type{T}) where T <: GtkRecentManager) = begin - ccall(("gtk_recent_manager_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkRecentManager GObject libgtk4 gtk_recent_manager_get_type begin function GLib.signalnames(::Type{GtkRecentManager}) vcat([:changed], signalnames(supertype(GtkRecentManager))) @@ -5807,67 +2567,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkRevealer <: GtkWidget end - mutable struct GtkRevealerLeaf <: GtkRevealer - handle::Ptr{GObject} - function GtkRevealerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkRevealerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkRevealer] = GtkRevealerLeaf - (GLib.g_type(::Type{T}) where T <: GtkRevealer) = begin - ccall(("gtk_revealer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkRevealer GtkWidget libgtk4 gtk_revealer_get_type begin function GLib.signalnames(::Type{GtkRevealer}) signalnames(supertype(GtkRevealer)) end end - begin - abstract type GtkScale <: GtkRange end - mutable struct GtkScaleLeaf <: GtkScale - handle::Ptr{GObject} - function GtkScaleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkScaleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkScale] = GtkScaleLeaf - (GLib.g_type(::Type{T}) where T <: GtkScale) = begin - ccall(("gtk_scale_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkScale GtkRange libgtk4 gtk_scale_get_type begin function GLib.signalnames(::Type{GtkScale}) signalnames(supertype(GtkScale)) end end - begin - abstract type GtkScaleButton <: GtkWidget end - mutable struct GtkScaleButtonLeaf <: GtkScaleButton - handle::Ptr{GObject} - function GtkScaleButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkScaleButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkScaleButton] = GtkScaleButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkScaleButton) = begin - ccall(("gtk_scale_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkScaleButton GtkWidget libgtk4 gtk_scale_button_get_type begin function GLib.signalnames(::Type{GtkScaleButton}) vcat([:popdown, :popup, :value_changed], signalnames(supertype(GtkScaleButton))) @@ -5881,45 +2593,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkScrollbar <: GtkWidget end - mutable struct GtkScrollbarLeaf <: GtkScrollbar - handle::Ptr{GObject} - function GtkScrollbarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkScrollbarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkScrollbar] = GtkScrollbarLeaf - (GLib.g_type(::Type{T}) where T <: GtkScrollbar) = begin - ccall(("gtk_scrollbar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkScrollbar GtkWidget libgtk4 gtk_scrollbar_get_type begin function GLib.signalnames(::Type{GtkScrollbar}) signalnames(supertype(GtkScrollbar)) end end - begin - abstract type GtkScrolledWindow <: GtkWidget end - mutable struct GtkScrolledWindowLeaf <: GtkScrolledWindow - handle::Ptr{GObject} - function GtkScrolledWindowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkScrolledWindowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkScrolledWindow] = GtkScrolledWindowLeaf - (GLib.g_type(::Type{T}) where T <: GtkScrolledWindow) = begin - ccall(("gtk_scrolled_window_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkScrolledWindow GtkWidget libgtk4 gtk_scrolled_window_get_type begin function GLib.signalnames(::Type{GtkScrolledWindow}) vcat([:edge_overshot, :edge_reached, :move_focus_out, :scroll_child], signalnames(supertype(GtkScrolledWindow))) @@ -5933,45 +2613,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkSearchBar <: GtkWidget end - mutable struct GtkSearchBarLeaf <: GtkSearchBar - handle::Ptr{GObject} - function GtkSearchBarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSearchBarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSearchBar] = GtkSearchBarLeaf - (GLib.g_type(::Type{T}) where T <: GtkSearchBar) = begin - ccall(("gtk_search_bar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSearchBar GtkWidget libgtk4 gtk_search_bar_get_type begin function GLib.signalnames(::Type{GtkSearchBar}) signalnames(supertype(GtkSearchBar)) end end - begin - abstract type GtkSearchEntry <: GtkWidget end - mutable struct GtkSearchEntryLeaf <: GtkSearchEntry - handle::Ptr{GObject} - function GtkSearchEntryLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSearchEntryLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSearchEntry] = GtkSearchEntryLeaf - (GLib.g_type(::Type{T}) where T <: GtkSearchEntry) = begin - ccall(("gtk_search_entry_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSearchEntry GtkWidget libgtk4 gtk_search_entry_get_type begin function GLib.signalnames(::Type{GtkSearchEntry}) vcat([:activate, :next_match, :previous_match, :search_changed, :search_started, :stop_search, :changed, :delete_text, :insert_text], signalnames(supertype(GtkSearchEntry))) @@ -5985,23 +2633,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkSelectionFilterModel <: GObject end - mutable struct GtkSelectionFilterModelLeaf <: GtkSelectionFilterModel - handle::Ptr{GObject} - function GtkSelectionFilterModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSelectionFilterModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSelectionFilterModel] = GtkSelectionFilterModelLeaf - (GLib.g_type(::Type{T}) where T <: GtkSelectionFilterModel) = begin - ccall(("gtk_selection_filter_model_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSelectionFilterModel GObject libgtk4 gtk_selection_filter_model_get_type begin function GLib.signalnames(::Type{GtkSelectionFilterModel}) vcat([:items_changed], signalnames(supertype(GtkSelectionFilterModel))) @@ -6015,45 +2647,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkSeparator <: GtkWidget end - mutable struct GtkSeparatorLeaf <: GtkSeparator - handle::Ptr{GObject} - function GtkSeparatorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSeparatorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSeparator] = GtkSeparatorLeaf - (GLib.g_type(::Type{T}) where T <: GtkSeparator) = begin - ccall(("gtk_separator_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSeparator GtkWidget libgtk4 gtk_separator_get_type begin function GLib.signalnames(::Type{GtkSeparator}) signalnames(supertype(GtkSeparator)) end end - begin - abstract type GtkSettings <: GObject end - mutable struct GtkSettingsLeaf <: GtkSettings - handle::Ptr{GObject} - function GtkSettingsLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSettingsLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSettings] = GtkSettingsLeaf - (GLib.g_type(::Type{T}) where T <: GtkSettings) = begin - ccall(("gtk_settings_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSettings GObject libgtk4 gtk_settings_get_type begin function GLib.signalnames(::Type{GtkSettings}) vcat([:gtk_private_changed], signalnames(supertype(GtkSettings))) @@ -6067,45 +2667,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkShortcut <: GObject end - mutable struct GtkShortcutLeaf <: GtkShortcut - handle::Ptr{GObject} - function GtkShortcutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkShortcutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkShortcut] = GtkShortcutLeaf - (GLib.g_type(::Type{T}) where T <: GtkShortcut) = begin - ccall(("gtk_shortcut_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkShortcut GObject libgtk4 gtk_shortcut_get_type begin function GLib.signalnames(::Type{GtkShortcut}) signalnames(supertype(GtkShortcut)) end end - begin - abstract type GtkShortcutController <: GtkEventController end - mutable struct GtkShortcutControllerLeaf <: GtkShortcutController - handle::Ptr{GObject} - function GtkShortcutControllerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkShortcutControllerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkShortcutController] = GtkShortcutControllerLeaf - (GLib.g_type(::Type{T}) where T <: GtkShortcutController) = begin - ccall(("gtk_shortcut_controller_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkShortcutController GtkEventController libgtk4 gtk_shortcut_controller_get_type begin function GLib.signalnames(::Type{GtkShortcutController}) vcat([:items_changed], signalnames(supertype(GtkShortcutController))) @@ -6119,67 +2687,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkShortcutLabel <: GtkWidget end - mutable struct GtkShortcutLabelLeaf <: GtkShortcutLabel - handle::Ptr{GObject} - function GtkShortcutLabelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkShortcutLabelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkShortcutLabel] = GtkShortcutLabelLeaf - (GLib.g_type(::Type{T}) where T <: GtkShortcutLabel) = begin - ccall(("gtk_shortcut_label_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkShortcutLabel GtkWidget libgtk4 gtk_shortcut_label_get_type begin function GLib.signalnames(::Type{GtkShortcutLabel}) signalnames(supertype(GtkShortcutLabel)) end end - begin - abstract type GtkShortcutsGroup <: GtkBox end - mutable struct GtkShortcutsGroupLeaf <: GtkShortcutsGroup - handle::Ptr{GObject} - function GtkShortcutsGroupLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkShortcutsGroupLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkShortcutsGroup] = GtkShortcutsGroupLeaf - (GLib.g_type(::Type{T}) where T <: GtkShortcutsGroup) = begin - ccall(("gtk_shortcuts_group_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkShortcutsGroup GtkBox libgtk4 gtk_shortcuts_group_get_type begin function GLib.signalnames(::Type{GtkShortcutsGroup}) signalnames(supertype(GtkShortcutsGroup)) end end - begin - abstract type GtkShortcutsSection <: GtkBox end - mutable struct GtkShortcutsSectionLeaf <: GtkShortcutsSection - handle::Ptr{GObject} - function GtkShortcutsSectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkShortcutsSectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkShortcutsSection] = GtkShortcutsSectionLeaf - (GLib.g_type(::Type{T}) where T <: GtkShortcutsSection) = begin - ccall(("gtk_shortcuts_section_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkShortcutsSection GtkBox libgtk4 gtk_shortcuts_section_get_type begin function GLib.signalnames(::Type{GtkShortcutsSection}) vcat([:change_current_page], signalnames(supertype(GtkShortcutsSection))) @@ -6193,45 +2713,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkShortcutsShortcut <: GtkWidget end - mutable struct GtkShortcutsShortcutLeaf <: GtkShortcutsShortcut - handle::Ptr{GObject} - function GtkShortcutsShortcutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkShortcutsShortcutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkShortcutsShortcut] = GtkShortcutsShortcutLeaf - (GLib.g_type(::Type{T}) where T <: GtkShortcutsShortcut) = begin - ccall(("gtk_shortcuts_shortcut_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkShortcutsShortcut GtkWidget libgtk4 gtk_shortcuts_shortcut_get_type begin function GLib.signalnames(::Type{GtkShortcutsShortcut}) signalnames(supertype(GtkShortcutsShortcut)) end end - begin - abstract type GtkShortcutsWindow <: GtkWindow end - mutable struct GtkShortcutsWindowLeaf <: GtkShortcutsWindow - handle::Ptr{GObject} - function GtkShortcutsWindowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkShortcutsWindowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkShortcutsWindow] = GtkShortcutsWindowLeaf - (GLib.g_type(::Type{T}) where T <: GtkShortcutsWindow) = begin - ccall(("gtk_shortcuts_window_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkShortcutsWindow GtkWindow libgtk4 gtk_shortcuts_window_get_type begin function GLib.signalnames(::Type{GtkShortcutsWindow}) vcat([:close, :search], signalnames(supertype(GtkShortcutsWindow))) @@ -6245,45 +2733,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkSignalAction <: GtkShortcutAction end - mutable struct GtkSignalActionLeaf <: GtkSignalAction - handle::Ptr{GObject} - function GtkSignalActionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSignalActionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSignalAction] = GtkSignalActionLeaf - (GLib.g_type(::Type{T}) where T <: GtkSignalAction) = begin - ccall(("gtk_signal_action_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSignalAction GtkShortcutAction libgtk4 gtk_signal_action_get_type begin function GLib.signalnames(::Type{GtkSignalAction}) signalnames(supertype(GtkSignalAction)) end end - begin - abstract type GtkSignalListItemFactory <: GtkListItemFactory end - mutable struct GtkSignalListItemFactoryLeaf <: GtkSignalListItemFactory - handle::Ptr{GObject} - function GtkSignalListItemFactoryLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSignalListItemFactoryLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSignalListItemFactory] = GtkSignalListItemFactoryLeaf - (GLib.g_type(::Type{T}) where T <: GtkSignalListItemFactory) = begin - ccall(("gtk_signal_list_item_factory_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSignalListItemFactory GtkListItemFactory libgtk4 gtk_signal_list_item_factory_get_type begin function GLib.signalnames(::Type{GtkSignalListItemFactory}) vcat([:bind, :setup, :teardown, :unbind], signalnames(supertype(GtkSignalListItemFactory))) @@ -6297,23 +2753,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkSingleSelection <: GObject end - mutable struct GtkSingleSelectionLeaf <: GtkSingleSelection - handle::Ptr{GObject} - function GtkSingleSelectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSingleSelectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSingleSelection] = GtkSingleSelectionLeaf - (GLib.g_type(::Type{T}) where T <: GtkSingleSelection) = begin - ccall(("gtk_single_selection_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSingleSelection GObject libgtk4 gtk_single_selection_get_type begin function GLib.signalnames(::Type{GtkSingleSelection}) vcat([:items_changed, :sections_changed, :selection_changed], signalnames(supertype(GtkSingleSelection))) @@ -6327,45 +2767,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkSizeGroup <: GObject end - mutable struct GtkSizeGroupLeaf <: GtkSizeGroup - handle::Ptr{GObject} - function GtkSizeGroupLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSizeGroupLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSizeGroup] = GtkSizeGroupLeaf - (GLib.g_type(::Type{T}) where T <: GtkSizeGroup) = begin - ccall(("gtk_size_group_get_type", libgtk4), GType, ()) - end - end - begin - function GLib.signalnames(::Type{GtkSizeGroup}) - signalnames(supertype(GtkSizeGroup)) - end - end - begin - abstract type GtkSliceListModel <: GObject end - mutable struct GtkSliceListModelLeaf <: GtkSliceListModel - handle::Ptr{GObject} - function GtkSliceListModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSliceListModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end + GLib.@Gobject GtkSizeGroup GObject libgtk4 gtk_size_group_get_type + begin + function GLib.signalnames(::Type{GtkSizeGroup}) + signalnames(supertype(GtkSizeGroup)) end - gtype_wrapper_cache[:GtkSliceListModel] = GtkSliceListModelLeaf - (GLib.g_type(::Type{T}) where T <: GtkSliceListModel) = begin - ccall(("gtk_slice_list_model_get_type", libgtk4), GType, ()) - end end + GLib.@Gobject GtkSliceListModel GObject libgtk4 gtk_slice_list_model_get_type begin function GLib.signalnames(::Type{GtkSliceListModel}) vcat([:items_changed, :sections_changed], signalnames(supertype(GtkSliceListModel))) @@ -6379,45 +2787,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkSnapshot <: GdkSnapshot end - mutable struct GtkSnapshotLeaf <: GtkSnapshot - handle::Ptr{GObject} - function GtkSnapshotLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSnapshotLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSnapshot] = GtkSnapshotLeaf - (GLib.g_type(::Type{T}) where T <: GtkSnapshot) = begin - ccall(("gtk_snapshot_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSnapshot GdkSnapshot libgtk4 gtk_snapshot_get_type begin function GLib.signalnames(::Type{GtkSnapshot}) signalnames(supertype(GtkSnapshot)) end end - begin - abstract type GtkSortListModel <: GObject end - mutable struct GtkSortListModelLeaf <: GtkSortListModel - handle::Ptr{GObject} - function GtkSortListModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSortListModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSortListModel] = GtkSortListModelLeaf - (GLib.g_type(::Type{T}) where T <: GtkSortListModel) = begin - ccall(("gtk_sort_list_model_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSortListModel GObject libgtk4 gtk_sort_list_model_get_type begin function GLib.signalnames(::Type{GtkSortListModel}) vcat([:items_changed, :sections_changed], signalnames(supertype(GtkSortListModel))) @@ -6431,23 +2807,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkSpinButton <: GtkWidget end - mutable struct GtkSpinButtonLeaf <: GtkSpinButton - handle::Ptr{GObject} - function GtkSpinButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSpinButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSpinButton] = GtkSpinButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkSpinButton) = begin - ccall(("gtk_spin_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSpinButton GtkWidget libgtk4 gtk_spin_button_get_type begin function GLib.signalnames(::Type{GtkSpinButton}) vcat([:activate, :change_value, :input, :output, :value_changed, :wrapped, :editing_done, :remove_widget, :changed, :delete_text, :insert_text], signalnames(supertype(GtkSpinButton))) @@ -6461,133 +2821,37 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkSpinner <: GtkWidget end - mutable struct GtkSpinnerLeaf <: GtkSpinner - handle::Ptr{GObject} - function GtkSpinnerLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSpinnerLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSpinner] = GtkSpinnerLeaf - (GLib.g_type(::Type{T}) where T <: GtkSpinner) = begin - ccall(("gtk_spinner_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSpinner GtkWidget libgtk4 gtk_spinner_get_type begin function GLib.signalnames(::Type{GtkSpinner}) signalnames(supertype(GtkSpinner)) end end - begin - abstract type GtkStack <: GtkWidget end - mutable struct GtkStackLeaf <: GtkStack - handle::Ptr{GObject} - function GtkStackLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStackLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStack] = GtkStackLeaf - (GLib.g_type(::Type{T}) where T <: GtkStack) = begin - ccall(("gtk_stack_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStack GtkWidget libgtk4 gtk_stack_get_type begin function GLib.signalnames(::Type{GtkStack}) signalnames(supertype(GtkStack)) end end - begin - abstract type GtkStackPage <: GObject end - mutable struct GtkStackPageLeaf <: GtkStackPage - handle::Ptr{GObject} - function GtkStackPageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStackPageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStackPage] = GtkStackPageLeaf - (GLib.g_type(::Type{T}) where T <: GtkStackPage) = begin - ccall(("gtk_stack_page_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStackPage GObject libgtk4 gtk_stack_page_get_type begin function GLib.signalnames(::Type{GtkStackPage}) signalnames(supertype(GtkStackPage)) end end - begin - abstract type GtkStackSidebar <: GtkWidget end - mutable struct GtkStackSidebarLeaf <: GtkStackSidebar - handle::Ptr{GObject} - function GtkStackSidebarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStackSidebarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStackSidebar] = GtkStackSidebarLeaf - (GLib.g_type(::Type{T}) where T <: GtkStackSidebar) = begin - ccall(("gtk_stack_sidebar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStackSidebar GtkWidget libgtk4 gtk_stack_sidebar_get_type begin function GLib.signalnames(::Type{GtkStackSidebar}) signalnames(supertype(GtkStackSidebar)) end end - begin - abstract type GtkStackSwitcher <: GtkWidget end - mutable struct GtkStackSwitcherLeaf <: GtkStackSwitcher - handle::Ptr{GObject} - function GtkStackSwitcherLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStackSwitcherLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStackSwitcher] = GtkStackSwitcherLeaf - (GLib.g_type(::Type{T}) where T <: GtkStackSwitcher) = begin - ccall(("gtk_stack_switcher_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStackSwitcher GtkWidget libgtk4 gtk_stack_switcher_get_type begin function GLib.signalnames(::Type{GtkStackSwitcher}) signalnames(supertype(GtkStackSwitcher)) end end - begin - abstract type GtkStatusbar <: GtkWidget end - mutable struct GtkStatusbarLeaf <: GtkStatusbar - handle::Ptr{GObject} - function GtkStatusbarLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStatusbarLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStatusbar] = GtkStatusbarLeaf - (GLib.g_type(::Type{T}) where T <: GtkStatusbar) = begin - ccall(("gtk_statusbar_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStatusbar GtkWidget libgtk4 gtk_statusbar_get_type begin function GLib.signalnames(::Type{GtkStatusbar}) vcat([:text_popped, :text_pushed], signalnames(supertype(GtkStatusbar))) @@ -6601,45 +2865,13 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkStringFilter <: GtkFilter end - mutable struct GtkStringFilterLeaf <: GtkStringFilter - handle::Ptr{GObject} - function GtkStringFilterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStringFilterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStringFilter] = GtkStringFilterLeaf - (GLib.g_type(::Type{T}) where T <: GtkStringFilter) = begin - ccall(("gtk_string_filter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStringFilter GtkFilter libgtk4 gtk_string_filter_get_type begin function GLib.signalnames(::Type{GtkStringFilter}) signalnames(supertype(GtkStringFilter)) end end - begin - abstract type GtkStringList <: GObject end - mutable struct GtkStringListLeaf <: GtkStringList - handle::Ptr{GObject} - function GtkStringListLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStringListLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStringList] = GtkStringListLeaf - (GLib.g_type(::Type{T}) where T <: GtkStringList) = begin - ccall(("gtk_string_list_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStringList GObject libgtk4 gtk_string_list_get_type begin function GLib.signalnames(::Type{GtkStringList}) vcat([:items_changed], signalnames(supertype(GtkStringList))) @@ -6653,89 +2885,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkStringObject <: GObject end - mutable struct GtkStringObjectLeaf <: GtkStringObject - handle::Ptr{GObject} - function GtkStringObjectLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStringObjectLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStringObject] = GtkStringObjectLeaf - (GLib.g_type(::Type{T}) where T <: GtkStringObject) = begin - ccall(("gtk_string_object_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStringObject GObject libgtk4 gtk_string_object_get_type begin function GLib.signalnames(::Type{GtkStringObject}) signalnames(supertype(GtkStringObject)) end end - begin - abstract type GtkStringSorter <: GtkSorter end - mutable struct GtkStringSorterLeaf <: GtkStringSorter - handle::Ptr{GObject} - function GtkStringSorterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStringSorterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStringSorter] = GtkStringSorterLeaf - (GLib.g_type(::Type{T}) where T <: GtkStringSorter) = begin - ccall(("gtk_string_sorter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStringSorter GtkSorter libgtk4 gtk_string_sorter_get_type begin function GLib.signalnames(::Type{GtkStringSorter}) signalnames(supertype(GtkStringSorter)) end end - begin - abstract type GtkStyleContext <: GObject end - mutable struct GtkStyleContextLeaf <: GtkStyleContext - handle::Ptr{GObject} - function GtkStyleContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkStyleContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkStyleContext] = GtkStyleContextLeaf - (GLib.g_type(::Type{T}) where T <: GtkStyleContext) = begin - ccall(("gtk_style_context_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkStyleContext GObject libgtk4 gtk_style_context_get_type begin function GLib.signalnames(::Type{GtkStyleContext}) signalnames(supertype(GtkStyleContext)) end end - begin - abstract type GtkSwitch <: GtkWidget end - mutable struct GtkSwitchLeaf <: GtkSwitch - handle::Ptr{GObject} - function GtkSwitchLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkSwitchLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkSwitch] = GtkSwitchLeaf - (GLib.g_type(::Type{T}) where T <: GtkSwitch) = begin - ccall(("gtk_switch_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkSwitch GtkWidget libgtk4 gtk_switch_get_type begin function GLib.signalnames(::Type{GtkSwitch}) vcat([:activate, :state_set], signalnames(supertype(GtkSwitch))) @@ -6749,23 +2917,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkText <: GtkWidget end - mutable struct GtkTextLeaf <: GtkText - handle::Ptr{GObject} - function GtkTextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkText] = GtkTextLeaf - (GLib.g_type(::Type{T}) where T <: GtkText) = begin - ccall(("gtk_text_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkText GtkWidget libgtk4 gtk_text_get_type begin function GLib.signalnames(::Type{GtkText}) vcat([:activate, :backspace, :copy_clipboard, :cut_clipboard, :delete_from_cursor, :insert_at_cursor, :insert_emoji, :move_cursor, :paste_clipboard, :preedit_changed, :toggle_overwrite, :changed, :delete_text, :insert_text], signalnames(supertype(GtkText))) @@ -6779,23 +2931,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTextBuffer <: GObject end - mutable struct GtkTextBufferLeaf <: GtkTextBuffer - handle::Ptr{GObject} - function GtkTextBufferLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTextBufferLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTextBuffer] = GtkTextBufferLeaf - (GLib.g_type(::Type{T}) where T <: GtkTextBuffer) = begin - ccall(("gtk_text_buffer_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTextBuffer GObject libgtk4 gtk_text_buffer_get_type begin function GLib.signalnames(::Type{GtkTextBuffer}) vcat([:apply_tag, :begin_user_action, :changed, :delete_range, :end_user_action, :insert_child_anchor, :insert_paintable, :insert_text, :mark_deleted, :mark_set, :modified_changed, :paste_done, :redo, :remove_tag, :undo], signalnames(supertype(GtkTextBuffer))) @@ -6809,89 +2945,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTextChildAnchor <: GObject end - mutable struct GtkTextChildAnchorLeaf <: GtkTextChildAnchor - handle::Ptr{GObject} - function GtkTextChildAnchorLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTextChildAnchorLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTextChildAnchor] = GtkTextChildAnchorLeaf - (GLib.g_type(::Type{T}) where T <: GtkTextChildAnchor) = begin - ccall(("gtk_text_child_anchor_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTextChildAnchor GObject libgtk4 gtk_text_child_anchor_get_type begin function GLib.signalnames(::Type{GtkTextChildAnchor}) signalnames(supertype(GtkTextChildAnchor)) end end - begin - abstract type GtkTextMark <: GObject end - mutable struct GtkTextMarkLeaf <: GtkTextMark - handle::Ptr{GObject} - function GtkTextMarkLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTextMarkLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTextMark] = GtkTextMarkLeaf - (GLib.g_type(::Type{T}) where T <: GtkTextMark) = begin - ccall(("gtk_text_mark_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTextMark GObject libgtk4 gtk_text_mark_get_type begin function GLib.signalnames(::Type{GtkTextMark}) signalnames(supertype(GtkTextMark)) end end - begin - abstract type GtkTextTag <: GObject end - mutable struct GtkTextTagLeaf <: GtkTextTag - handle::Ptr{GObject} - function GtkTextTagLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTextTagLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTextTag] = GtkTextTagLeaf - (GLib.g_type(::Type{T}) where T <: GtkTextTag) = begin - ccall(("gtk_text_tag_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTextTag GObject libgtk4 gtk_text_tag_get_type begin function GLib.signalnames(::Type{GtkTextTag}) signalnames(supertype(GtkTextTag)) end end - begin - abstract type GtkTextTagTable <: GObject end - mutable struct GtkTextTagTableLeaf <: GtkTextTagTable - handle::Ptr{GObject} - function GtkTextTagTableLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTextTagTableLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTextTagTable] = GtkTextTagTableLeaf - (GLib.g_type(::Type{T}) where T <: GtkTextTagTable) = begin - ccall(("gtk_text_tag_table_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTextTagTable GObject libgtk4 gtk_text_tag_table_get_type begin function GLib.signalnames(::Type{GtkTextTagTable}) vcat([:tag_added, :tag_changed, :tag_removed], signalnames(supertype(GtkTextTagTable))) @@ -6905,23 +2977,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTextView <: GtkWidget end - mutable struct GtkTextViewLeaf <: GtkTextView - handle::Ptr{GObject} - function GtkTextViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTextViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTextView] = GtkTextViewLeaf - (GLib.g_type(::Type{T}) where T <: GtkTextView) = begin - ccall(("gtk_text_view_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTextView GtkWidget libgtk4 gtk_text_view_get_type begin function GLib.signalnames(::Type{GtkTextView}) vcat([:backspace, :copy_clipboard, :cut_clipboard, :delete_from_cursor, :extend_selection, :insert_at_cursor, :insert_emoji, :move_cursor, :move_viewport, :paste_clipboard, :preedit_changed, :select_all, :set_anchor, :toggle_cursor_visible, :toggle_overwrite], signalnames(supertype(GtkTextView))) @@ -6935,23 +2991,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkToggleButton <: GtkButton end - mutable struct GtkToggleButtonLeaf <: GtkToggleButton - handle::Ptr{GObject} - function GtkToggleButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkToggleButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkToggleButton] = GtkToggleButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkToggleButton) = begin - ccall(("gtk_toggle_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkToggleButton GtkButton libgtk4 gtk_toggle_button_get_type begin function GLib.signalnames(::Type{GtkToggleButton}) vcat([:toggled], signalnames(supertype(GtkToggleButton))) @@ -6965,67 +3005,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTooltip <: GObject end - mutable struct GtkTooltipLeaf <: GtkTooltip - handle::Ptr{GObject} - function GtkTooltipLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTooltipLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTooltip] = GtkTooltipLeaf - (GLib.g_type(::Type{T}) where T <: GtkTooltip) = begin - ccall(("gtk_tooltip_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTooltip GObject libgtk4 gtk_tooltip_get_type begin function GLib.signalnames(::Type{GtkTooltip}) signalnames(supertype(GtkTooltip)) end end - begin - abstract type GtkTreeExpander <: GtkWidget end - mutable struct GtkTreeExpanderLeaf <: GtkTreeExpander - handle::Ptr{GObject} - function GtkTreeExpanderLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeExpanderLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeExpander] = GtkTreeExpanderLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeExpander) = begin - ccall(("gtk_tree_expander_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeExpander GtkWidget libgtk4 gtk_tree_expander_get_type begin function GLib.signalnames(::Type{GtkTreeExpander}) signalnames(supertype(GtkTreeExpander)) end end - begin - abstract type GtkTreeListModel <: GObject end - mutable struct GtkTreeListModelLeaf <: GtkTreeListModel - handle::Ptr{GObject} - function GtkTreeListModelLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeListModelLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeListModel] = GtkTreeListModelLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeListModel) = begin - ccall(("gtk_tree_list_model_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeListModel GObject libgtk4 gtk_tree_list_model_get_type begin function GLib.signalnames(::Type{GtkTreeListModel}) vcat([:items_changed], signalnames(supertype(GtkTreeListModel))) @@ -7039,67 +3031,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTreeListRow <: GObject end - mutable struct GtkTreeListRowLeaf <: GtkTreeListRow - handle::Ptr{GObject} - function GtkTreeListRowLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeListRowLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeListRow] = GtkTreeListRowLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeListRow) = begin - ccall(("gtk_tree_list_row_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeListRow GObject libgtk4 gtk_tree_list_row_get_type begin function GLib.signalnames(::Type{GtkTreeListRow}) signalnames(supertype(GtkTreeListRow)) end end - begin - abstract type GtkTreeListRowSorter <: GtkSorter end - mutable struct GtkTreeListRowSorterLeaf <: GtkTreeListRowSorter - handle::Ptr{GObject} - function GtkTreeListRowSorterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeListRowSorterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeListRowSorter] = GtkTreeListRowSorterLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeListRowSorter) = begin - ccall(("gtk_tree_list_row_sorter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeListRowSorter GtkSorter libgtk4 gtk_tree_list_row_sorter_get_type begin function GLib.signalnames(::Type{GtkTreeListRowSorter}) signalnames(supertype(GtkTreeListRowSorter)) end end - begin - abstract type GtkTreeModelFilter <: GObject end - mutable struct GtkTreeModelFilterLeaf <: GtkTreeModelFilter - handle::Ptr{GObject} - function GtkTreeModelFilterLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeModelFilterLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeModelFilter] = GtkTreeModelFilterLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeModelFilter) = begin - ccall(("gtk_tree_model_filter_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeModelFilter GObject libgtk4 gtk_tree_model_filter_get_type begin function GLib.signalnames(::Type{GtkTreeModelFilter}) vcat([:row_changed, :row_deleted, :row_has_child_toggled, :row_inserted], signalnames(supertype(GtkTreeModelFilter))) @@ -7113,23 +3057,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTreeModelSort <: GObject end - mutable struct GtkTreeModelSortLeaf <: GtkTreeModelSort - handle::Ptr{GObject} - function GtkTreeModelSortLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeModelSortLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeModelSort] = GtkTreeModelSortLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeModelSort) = begin - ccall(("gtk_tree_model_sort_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeModelSort GObject libgtk4 gtk_tree_model_sort_get_type begin function GLib.signalnames(::Type{GtkTreeModelSort}) vcat([:row_changed, :row_deleted, :row_has_child_toggled, :row_inserted, :sort_column_changed], signalnames(supertype(GtkTreeModelSort))) @@ -7143,23 +3071,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTreeSelection <: GObject end - mutable struct GtkTreeSelectionLeaf <: GtkTreeSelection - handle::Ptr{GObject} - function GtkTreeSelectionLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeSelectionLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeSelection] = GtkTreeSelectionLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeSelection) = begin - ccall(("gtk_tree_selection_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeSelection GObject libgtk4 gtk_tree_selection_get_type begin function GLib.signalnames(::Type{GtkTreeSelection}) vcat([:changed], signalnames(supertype(GtkTreeSelection))) @@ -7173,23 +3085,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTreeStore <: GObject end - mutable struct GtkTreeStoreLeaf <: GtkTreeStore - handle::Ptr{GObject} - function GtkTreeStoreLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeStoreLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeStore] = GtkTreeStoreLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeStore) = begin - ccall(("gtk_tree_store_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeStore GObject libgtk4 gtk_tree_store_get_type begin function GLib.signalnames(::Type{GtkTreeStore}) vcat([:row_changed, :row_deleted, :row_has_child_toggled, :row_inserted, :sort_column_changed], signalnames(supertype(GtkTreeStore))) @@ -7203,23 +3099,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTreeView <: GtkWidget end - mutable struct GtkTreeViewLeaf <: GtkTreeView - handle::Ptr{GObject} - function GtkTreeViewLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeViewLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeView] = GtkTreeViewLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeView) = begin - ccall(("gtk_tree_view_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeView GtkWidget libgtk4 gtk_tree_view_get_type begin function GLib.signalnames(::Type{GtkTreeView}) vcat([:columns_changed, :cursor_changed, :expand_collapse_cursor_row, :move_cursor, :row_activated, :row_collapsed, :row_expanded, :select_all, :select_cursor_parent, :select_cursor_row, :start_interactive_search, :test_collapse_row, :test_expand_row, :toggle_cursor_row, :unselect_all], signalnames(supertype(GtkTreeView))) @@ -7233,23 +3113,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkTreeViewColumn <: GInitiallyUnowned end - mutable struct GtkTreeViewColumnLeaf <: GtkTreeViewColumn - handle::Ptr{GObject} - function GtkTreeViewColumnLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkTreeViewColumnLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkTreeViewColumn] = GtkTreeViewColumnLeaf - (GLib.g_type(::Type{T}) where T <: GtkTreeViewColumn) = begin - ccall(("gtk_tree_view_column_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkTreeViewColumn GInitiallyUnowned libgtk4 gtk_tree_view_column_get_type begin function GLib.signalnames(::Type{GtkTreeViewColumn}) vcat([:clicked], signalnames(supertype(GtkTreeViewColumn))) @@ -7263,111 +3127,31 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkUriLauncher <: GObject end - mutable struct GtkUriLauncherLeaf <: GtkUriLauncher - handle::Ptr{GObject} - function GtkUriLauncherLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkUriLauncherLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkUriLauncher] = GtkUriLauncherLeaf - (GLib.g_type(::Type{T}) where T <: GtkUriLauncher) = begin - ccall(("gtk_uri_launcher_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkUriLauncher GObject libgtk4 gtk_uri_launcher_get_type begin function GLib.signalnames(::Type{GtkUriLauncher}) signalnames(supertype(GtkUriLauncher)) end end - begin - abstract type GtkVideo <: GtkWidget end - mutable struct GtkVideoLeaf <: GtkVideo - handle::Ptr{GObject} - function GtkVideoLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkVideoLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkVideo] = GtkVideoLeaf - (GLib.g_type(::Type{T}) where T <: GtkVideo) = begin - ccall(("gtk_video_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkVideo GtkWidget libgtk4 gtk_video_get_type begin function GLib.signalnames(::Type{GtkVideo}) signalnames(supertype(GtkVideo)) end end - begin - abstract type GtkViewport <: GtkWidget end - mutable struct GtkViewportLeaf <: GtkViewport - handle::Ptr{GObject} - function GtkViewportLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkViewportLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkViewport] = GtkViewportLeaf - (GLib.g_type(::Type{T}) where T <: GtkViewport) = begin - ccall(("gtk_viewport_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkViewport GtkWidget libgtk4 gtk_viewport_get_type begin function GLib.signalnames(::Type{GtkViewport}) signalnames(supertype(GtkViewport)) end end - begin - abstract type GtkVolumeButton <: GtkScaleButton end - mutable struct GtkVolumeButtonLeaf <: GtkVolumeButton - handle::Ptr{GObject} - function GtkVolumeButtonLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkVolumeButtonLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkVolumeButton] = GtkVolumeButtonLeaf - (GLib.g_type(::Type{T}) where T <: GtkVolumeButton) = begin - ccall(("gtk_volume_button_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkVolumeButton GtkScaleButton libgtk4 gtk_volume_button_get_type begin function GLib.signalnames(::Type{GtkVolumeButton}) signalnames(supertype(GtkVolumeButton)) end end - begin - abstract type GtkWidgetPaintable <: GObject end - mutable struct GtkWidgetPaintableLeaf <: GtkWidgetPaintable - handle::Ptr{GObject} - function GtkWidgetPaintableLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkWidgetPaintableLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkWidgetPaintable] = GtkWidgetPaintableLeaf - (GLib.g_type(::Type{T}) where T <: GtkWidgetPaintable) = begin - ccall(("gtk_widget_paintable_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkWidgetPaintable GObject libgtk4 gtk_widget_paintable_get_type begin function GLib.signalnames(::Type{GtkWidgetPaintable}) vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GtkWidgetPaintable))) @@ -7381,67 +3165,19 @@ $(Expr(:toplevel, quote end end end - begin - abstract type GtkWindowControls <: GtkWidget end - mutable struct GtkWindowControlsLeaf <: GtkWindowControls - handle::Ptr{GObject} - function GtkWindowControlsLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkWindowControlsLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkWindowControls] = GtkWindowControlsLeaf - (GLib.g_type(::Type{T}) where T <: GtkWindowControls) = begin - ccall(("gtk_window_controls_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkWindowControls GtkWidget libgtk4 gtk_window_controls_get_type begin function GLib.signalnames(::Type{GtkWindowControls}) signalnames(supertype(GtkWindowControls)) end end - begin - abstract type GtkWindowGroup <: GObject end - mutable struct GtkWindowGroupLeaf <: GtkWindowGroup - handle::Ptr{GObject} - function GtkWindowGroupLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkWindowGroupLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkWindowGroup] = GtkWindowGroupLeaf - (GLib.g_type(::Type{T}) where T <: GtkWindowGroup) = begin - ccall(("gtk_window_group_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkWindowGroup GObject libgtk4 gtk_window_group_get_type begin function GLib.signalnames(::Type{GtkWindowGroup}) signalnames(supertype(GtkWindowGroup)) end end - begin - abstract type GtkWindowHandle <: GtkWidget end - mutable struct GtkWindowHandleLeaf <: GtkWindowHandle - handle::Ptr{GObject} - function GtkWindowHandleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct GtkWindowHandleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:GtkWindowHandle] = GtkWindowHandleLeaf - (GLib.g_type(::Type{T}) where T <: GtkWindowHandle) = begin - ccall(("gtk_window_handle_get_type", libgtk4), GType, ()) - end - end + GLib.@Gobject GtkWindowHandle GtkWidget libgtk4 gtk_window_handle_get_type begin function GLib.signalnames(::Type{GtkWindowHandle}) signalnames(supertype(GtkWindowHandle)) diff --git a/src/gen/pango_structs b/src/gen/pango_structs index b492ad8a..8595e279 100644 --- a/src/gen/pango_structs +++ b/src/gen/pango_structs @@ -875,111 +875,31 @@ $(Expr(:toplevel, quote append!(GLib.gboxed_types, gboxed_types) end const gtype_wrapper_cache = Dict{Symbol, Type}() - begin - abstract type PangoContext <: GObject end - mutable struct PangoContextLeaf <: PangoContext - handle::Ptr{GObject} - function PangoContextLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoContextLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoContext] = PangoContextLeaf - (GLib.g_type(::Type{T}) where T <: PangoContext) = begin - ccall(("pango_context_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoContext GObject libpango pango_context_get_type begin function GLib.signalnames(::Type{PangoContext}) signalnames(supertype(PangoContext)) end end - begin - abstract type PangoCoverage <: GObject end - mutable struct PangoCoverageLeaf <: PangoCoverage - handle::Ptr{GObject} - function PangoCoverageLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoCoverageLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoCoverage] = PangoCoverageLeaf - (GLib.g_type(::Type{T}) where T <: PangoCoverage) = begin - ccall(("pango_coverage_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoCoverage GObject libpango pango_coverage_get_type begin function GLib.signalnames(::Type{PangoCoverage}) signalnames(supertype(PangoCoverage)) end end - begin - abstract type PangoFont <: GObject end - mutable struct PangoFontLeaf <: PangoFont - handle::Ptr{GObject} - function PangoFontLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoFontLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoFont] = PangoFontLeaf - (GLib.g_type(::Type{T}) where T <: PangoFont) = begin - ccall(("pango_font_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoFont GObject libpango pango_font_get_type begin function GLib.signalnames(::Type{PangoFont}) signalnames(supertype(PangoFont)) end end - begin - abstract type PangoFontFace <: GObject end - mutable struct PangoFontFaceLeaf <: PangoFontFace - handle::Ptr{GObject} - function PangoFontFaceLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoFontFaceLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoFontFace] = PangoFontFaceLeaf - (GLib.g_type(::Type{T}) where T <: PangoFontFace) = begin - ccall(("pango_font_face_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoFontFace GObject libpango pango_font_face_get_type begin function GLib.signalnames(::Type{PangoFontFace}) signalnames(supertype(PangoFontFace)) end end - begin - abstract type PangoFontFamily <: GObject end - mutable struct PangoFontFamilyLeaf <: PangoFontFamily - handle::Ptr{GObject} - function PangoFontFamilyLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoFontFamilyLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoFontFamily] = PangoFontFamilyLeaf - (GLib.g_type(::Type{T}) where T <: PangoFontFamily) = begin - ccall(("pango_font_family_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoFontFamily GObject libpango pango_font_family_get_type begin function GLib.signalnames(::Type{PangoFontFamily}) vcat([:items_changed], signalnames(supertype(PangoFontFamily))) @@ -993,23 +913,7 @@ $(Expr(:toplevel, quote end end end - begin - abstract type PangoFontMap <: GObject end - mutable struct PangoFontMapLeaf <: PangoFontMap - handle::Ptr{GObject} - function PangoFontMapLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoFontMapLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoFontMap] = PangoFontMapLeaf - (GLib.g_type(::Type{T}) where T <: PangoFontMap) = begin - ccall(("pango_font_map_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoFontMap GObject libpango pango_font_map_get_type begin function GLib.signalnames(::Type{PangoFontMap}) vcat([:items_changed], signalnames(supertype(PangoFontMap))) @@ -1023,89 +927,25 @@ $(Expr(:toplevel, quote end end end - begin - abstract type PangoFontset <: GObject end - mutable struct PangoFontsetLeaf <: PangoFontset - handle::Ptr{GObject} - function PangoFontsetLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoFontsetLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoFontset] = PangoFontsetLeaf - (GLib.g_type(::Type{T}) where T <: PangoFontset) = begin - ccall(("pango_fontset_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoFontset GObject libpango pango_fontset_get_type begin function GLib.signalnames(::Type{PangoFontset}) signalnames(supertype(PangoFontset)) end end - begin - abstract type PangoFontsetSimple <: PangoFontset end - mutable struct PangoFontsetSimpleLeaf <: PangoFontsetSimple - handle::Ptr{GObject} - function PangoFontsetSimpleLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoFontsetSimpleLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoFontsetSimple] = PangoFontsetSimpleLeaf - (GLib.g_type(::Type{T}) where T <: PangoFontsetSimple) = begin - ccall(("pango_fontset_simple_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoFontsetSimple PangoFontset libpango pango_fontset_simple_get_type begin function GLib.signalnames(::Type{PangoFontsetSimple}) signalnames(supertype(PangoFontsetSimple)) end end - begin - abstract type PangoLayout <: GObject end - mutable struct PangoLayoutLeaf <: PangoLayout - handle::Ptr{GObject} - function PangoLayoutLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoLayoutLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoLayout] = PangoLayoutLeaf - (GLib.g_type(::Type{T}) where T <: PangoLayout) = begin - ccall(("pango_layout_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoLayout GObject libpango pango_layout_get_type begin function GLib.signalnames(::Type{PangoLayout}) signalnames(supertype(PangoLayout)) end end - begin - abstract type PangoRenderer <: GObject end - mutable struct PangoRendererLeaf <: PangoRenderer - handle::Ptr{GObject} - function PangoRendererLeaf(handle::Ptr{GObject}, owns = false) - if handle == C_NULL - error("Cannot construct PangoRendererLeaf with a NULL pointer") - end - GLib.gobject_maybe_sink(handle, owns) - return gobject_ref(new(handle)) - end - end - gtype_wrapper_cache[:PangoRenderer] = PangoRendererLeaf - (GLib.g_type(::Type{T}) where T <: PangoRenderer) = begin - ccall(("pango_renderer_get_type", libpango), GType, ()) - end - end + GLib.@Gobject PangoRenderer GObject libpango pango_renderer_get_type begin function GLib.signalnames(::Type{PangoRenderer}) signalnames(supertype(PangoRenderer)) diff --git a/src/gen/pangocairo_structs b/src/gen/pangocairo_structs index e5af5c5e..f1ca5cd1 100644 --- a/src/gen/pangocairo_structs +++ b/src/gen/pangocairo_structs @@ -1,19 +1,7 @@ quote $(Expr(:toplevel, quote - struct PangoCairoFont <: GInterface - handle::Ptr{GObject} - gc::Any - PangoCairoFont(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end - struct PangoCairoFontMap <: GInterface - handle::Ptr{GObject} - gc::Any - PangoCairoFontMap(x::GObject) = begin - new(unsafe_convert(Ptr{GObject}, x), x) - end - end + GLib.@Giface PangoCairoFont libpangocairo pango_cairo_font_get_type + GLib.@Giface PangoCairoFontMap libpangocairo pango_cairo_font_map_get_type function PangoCairoShapeRendererFunc(cr, attr, do_path, data) cr = convert(cairoContext, cr, false) attr = convert(PangoAttrShapeLike, attr)