feat: complete libadwaita - bind all remaining 36 Adw classes

Bind the last unbound GNOME (libadwaita) classes, so every Adw* class in
the GIR (81/81) is now available, bringing the Adw coverage to 84
modules (81 classes + AdwEnums + the BreakpointCondition/SpringParams
boxed helpers).

New classes:
- dialogs: AdwDialog, AdwAlertDialog, AdwAboutDialog,
    AdwPreferencesDialog, AdwPreferencesWindow
- responsive: AdwFlap, AdwLeaflet, AdwLeafletPage, AdwOverlaySplitView,
    AdwNavigationSplitView, AdwBottomSheet
- tabs: AdwTabView, AdwTabPage, AdwTabBar, AdwTabButton, AdwTabOverview
- carousel: AdwCarousel, AdwCarouselIndicatorDots/Lines
- toggles: AdwToggle, AdwToggleGroup
- adaptive: AdwBreakpoint, AdwBreakpointBin, AdwBreakpointCondition,
    AdwMultiLayoutView, AdwLayout, AdwLayoutSlot
- misc: AdwStyleManager, AdwSwipeTracker, AdwEnumListModel,
    AdwEnumListItem
- animation: AdwAnimation, AdwAnimationTarget, AdwTimedAnimation,
    AdwSpringAnimation, AdwSpringParams, AdwCallbackAnimationTarget,
    AdwPropertyAnimationTarget

AdwEnums gains the animation/easing, flap/leaflet transition,
dialog presentation, navigation direction, response appearance, accent
colour, colour scheme and tab-view-shortcut enumerations.  Variadic
functions (format_*, add_responses, add_setters, setup_extra_drop_target)
and va_list variants are intentionally omitted; async callbacks are
passed as ADDRESS, following the GtkFileDialog convention.

Also:
- tests/test_adw_widgets2.mod: builds and checks the new widgets
- examples/adw_views.mod: a tabbed window with AdwTabView/TabBar/
    TabButton/TabOverview
- Makefile/README updated

Test suite: 43 passed. gir-verify: 0 unexpected.

Makefile

@@ -26,7 +26,7 @@ EXAMPLES := hello counter inputs containers actions headerbar editor layouts fil
 # Include the libadwaita test/example only when libadwaita is installed.
 ifneq ($(ADWLIBS),)
 TESTS    += test_adw
-EXAMPLES += adw adw_widgets
+EXAMPLES += adw adw_widgets adw_views
 endif
 
 .PHONY: all tests examples demos check clean gir gir-check gir-verify

README.md

@@ -14,16 +14,18 @@ Verified with `gm2` 16.0.1 (experimental), GTK 4.18.6 and libadwaita 1.7.6.
 
 ## Features
 
-- **186 hand-written binding modules** across GLib, GObject, Gio, GTK4
+- **224 hand-written binding modules** across GLib, GObject, Gio, GTK4
   and libadwaita — windows, widgets, inputs, containers, model-backed
   views, actions/menus/accelerators, dialogs, CSS, drawing (Cairo/Pango),
   rich text, gestures, drag-and-drop, media, OpenGL, printing,
-  expressions/constraints/shortcuts, settings, and the GNOME (libadwaita)
-  widgets (view stacks, switchers, navigation, adaptive containers), and more.
+  expressions/constraints/shortcuts, settings, and the **complete GNOME
+  (libadwaita) widget set** — every `Adw*` class, including view stacks,
+  switchers, navigation, tabs, carousels, breakpoints, adaptive
+  containers, dialogs and animations.
 - **Pure-Modula-2 helpers**: `GtkUtils` (string/number conversion,
   `Connect`, `SetAccel`, ownership and `GError` helpers) and
   `GtkClosures` (per-connection signal contexts with cleanup).
-- **42 tests**, **26 runnable examples**, and an **m2 gtk-demo**
+- **43 tests**, **28 runnable examples**, and an **m2 gtk-demo**
   browser (`demos/`) modelled on GTK's own `gtk4-demo`.
 - **Generator + verifier**: `tools/gir2def.py` turns a `.gir` file into
   `.def` files; `tools/gir_verify.py` checks every generated identifier
@@ -132,6 +134,8 @@ gm2 -fiso -Isrc -Ilib myprog.mod \
 | `media` | `GdkTexture` in a `GtkPicture`, plus `GtkVideo` |
 | `clipboard` | copy/paste text through `GdkClipboard` |
 | `adw` | libadwaita preferences app (toolbar view, rows, toast, about) |
+| `adw_widgets` | view-switcher title, view stack, banner, squeezer, wrap box, avatar, spinner |
+| `adw_views` | tabbed window: `AdwTabView`/`AdwTabBar`/`AdwTabButton`/`AdwTabOverview` |
 
 ## m2 gtk-demo (`demos/`)
 
@@ -230,18 +234,31 @@ make demos
 | `AdwViewStack`, `AdwViewStackPage`, `AdwViewStackPages` | animated page stack |
 | `AdwViewSwitcher`, `AdwViewSwitcherBar`, `AdwViewSwitcherTitle`, `AdwInlineViewSwitcher` | view switchers |
 | `AdwNavigationView`, `AdwNavigationPage` | push/pop navigation |
+| `AdwNavigationSplitView`, `AdwOverlaySplitView` | adaptive split views |
+| `AdwFlap`, `AdwLeaflet`, `AdwLeafletPage` | fold/overlay sidebars (deprecated) |
+| `AdwBottomSheet` | bottom sheet with a bottom bar |
+| `AdwTabView`, `AdwTabPage`, `AdwTabBar`, `AdwTabButton`, `AdwTabOverview` | tabs |
+| `AdwCarousel`, `AdwCarouselIndicatorDots`, `AdwCarouselIndicatorLines` | carousel pagers |
+| `AdwToggle`, `AdwToggleGroup` | segmented toggles |
+| `AdwDialog`, `AdwAlertDialog`, `AdwAboutDialog` | dialogs |
+| `AdwPreferencesDialog`, `AdwPreferencesWindow` | preferences dialogs/windows |
 | `AdwPreferencesPage`, `AdwPreferencesGroup`, `AdwPreferencesRow` | preferences layout |
 | `AdwActionRow`, `AdwSwitchRow`, `AdwEntryRow`, `AdwComboRow`, `AdwExpanderRow` | settings rows |
 | `AdwButtonRow`, `AdwSpinRow`, `AdwPasswordEntryRow` | button, spin and password rows |
 | `AdwClamp`, `AdwClampScrollable`, `AdwClampLayout` | clamping containers/layouts |
 | `AdwSqueezer`, `AdwSqueezerPage` | show-the-largest-that-fits |
 | `AdwWrapBox`, `AdwWrapLayout` | wrapping lines |
+| `AdwBreakpoint`, `AdwBreakpointCondition`, `AdwBreakpointBin` | adaptive breakpoints |
+| `AdwMultiLayoutView`, `AdwLayout`, `AdwLayoutSlot` | multi-layout containers |
+| `AdwAnimation`, `AdwAnimationTarget`, `AdwTimedAnimation`, `AdwSpringAnimation`, `AdwSpringParams`, `AdwCallbackAnimationTarget`, `AdwPropertyAnimationTarget` | animations |
+| `AdwSwipeTracker`, `AdwStyleManager` | swipe tracking and Adwaita styling |
+| `AdwEnumListModel`, `AdwEnumListItem` | enum-backed list models |
 | `AdwBin`, `AdwSpinner`, `AdwSpinnerPaintable`, `AdwAvatar` | misc widgets |
 | `AdwButtonContent`, `AdwSplitButton` | rich button content |
 | `AdwStatusPage`, `AdwBanner` | status/banner |
 | `AdwToast`, `AdwToastOverlay` | transient notifications |
 | `AdwAboutWindow`, `AdwMessageDialog` | about and message dialogs |
-| `AdwEnums` | shared Adw enums (view switcher, justify, wrap, length units) |
+| `AdwEnums` | shared Adw enums (view switcher, animation/easing, flap/leaflet, dialog, tab shortcuts, …) |
 
 ### Helpers and the C shim (`lib/`)
 

examples/adw_views.mod

@@ -0,0 +1,114 @@
+MODULE adw_views ;
+
+(*
+   m2-GTK4 example - a tabbed window built from the GNOME (libadwaita)
+   widgets:
+
+     AdwApplicationWindow > AdwToolbarView
+       top bar - AdwHeaderBar
+                   title widget: AdwTabBar
+                   packed start: AdwTabButton (opens AdwTabOverview)
+                   packed end:   "+" button (adds a tab)
+       content - AdwTabView
+
+   Build:  make examples
+   Run:    ./build/examples/adw_views
+*)
+
+FROM Gio IMPORT g_application_run;
+FROM AdwApplication IMPORT adw_application_new;
+FROM AdwApplicationWindow IMPORT adw_application_window_new,
+   adw_application_window_set_content;
+FROM AdwHeaderBar IMPORT adw_header_bar_new, adw_header_bar_set_title_widget,
+   adw_header_bar_pack_start, adw_header_bar_pack_end;
+FROM AdwToolbarView IMPORT adw_toolbar_view_new, adw_toolbar_view_add_top_bar,
+   adw_toolbar_view_set_content;
+FROM AdwTabView IMPORT adw_tab_view_new, adw_tab_view_append;
+FROM AdwTabBar IMPORT adw_tab_bar_new, adw_tab_bar_set_view;
+FROM AdwTabButton IMPORT adw_tab_button_new, adw_tab_button_set_view;
+FROM AdwTabOverview IMPORT adw_tab_overview_new, adw_tab_overview_set_view;
+FROM AdwTabPage IMPORT adw_tab_page_set_title;
+FROM GtkWindow IMPORT gtk_window_present, gtk_window_set_default_size;
+FROM GtkButton IMPORT gtk_button_new_with_label;
+FROM GtkLabel IMPORT gtk_label_new;
+FROM GtkClosures IMPORT Connect2;
+FROM GtkUtils IMPORT IntToStr, StrAppend;
+FROM SYSTEM IMPORT ADDRESS;
+FROM libc IMPORT printf;
+
+CONST
+   AppId = "org.example.m2gtk4.AdwViews";
+
+VAR
+   counter: INTEGER;
+
+PROCEDURE AddTab (view: ADDRESS; title: ARRAY OF CHAR);
+VAR
+   page: ADDRESS;
+BEGIN
+   page := adw_tab_view_append (view, gtk_label_new(title));
+   adw_tab_page_set_title (page, title)
+END AddTab;
+
+PROCEDURE OnNewTab (button: ADDRESS; data: ADDRESS);
+VAR
+   view: ADDRESS;
+   num: ARRAY [0..15] OF CHAR;
+   text: ARRAY [0..31] OF CHAR;
+BEGIN
+   view := data;
+   INC(counter);
+   IntToStr(counter, num);
+   text := "Tab ";
+   StrAppend(text, num);
+   AddTab(view, text)
+END OnNewTab;
+
+PROCEDURE OnActivate (application: ADDRESS; data: ADDRESS);
+VAR
+   window, toolbar, header, tabview, tabbar, tabbutton, overview,
+   newbutton: ADDRESS;
+BEGIN
+   tabview := adw_tab_view_new();
+   AddTab(tabview, "Home");
+   AddTab(tabview, "About");
+
+   tabbar := adw_tab_bar_new();
+   adw_tab_bar_set_view(tabbar, tabview);
+
+   tabbutton := adw_tab_button_new();
+   adw_tab_button_set_view(tabbutton, tabview);
+
+   overview := adw_tab_overview_new();
+   adw_tab_overview_set_view(overview, tabview);
+
+   newbutton := gtk_button_new_with_label("+");
+   Connect2(newbutton, "clicked", OnNewTab, tabview);
+
+   header := adw_header_bar_new();
+   adw_header_bar_set_title_widget(header, tabbar);
+   adw_header_bar_pack_start(header, tabbutton);
+   adw_header_bar_pack_end(header, newbutton);
+
+   toolbar := adw_toolbar_view_new();
+   adw_toolbar_view_add_top_bar(toolbar, header);
+   adw_toolbar_view_set_content(toolbar, tabview);
+
+   window := adw_application_window_new(application);
+   gtk_window_set_default_size(window, 560, 400);
+   adw_application_window_set_content(window, toolbar);
+   gtk_window_present(window)
+END OnActivate;
+
+VAR
+   app: ADDRESS;
+BEGIN
+   counter := 2;
+   app := adw_application_new(AppId, 0);
+   IF app = NIL THEN
+      printf("adw_application_new failed\n");
+      HALT(1)
+   END;
+   Connect2(app, "activate", OnActivate, NIL);
+   g_application_run(app, 0, NIL)
+END adw_views.

src/AdwAboutDialog.def

@@ -0,0 +1,257 @@
+DEFINITION MODULE FOR "C" AdwAboutDialog ;
+
+(*
+   m2-GTK4 - AdwAboutDialog: the dialog form of the GNOME about window.
+   Mapped onto <libadwaita-1/adw-about-dialog.h>.
+
+   The artist/designer/developer/documenter lists are NULL-terminated
+   string arrays (`const char * const *`), passed here as ADDRESS.
+   The appdata constructor reads a GResource path.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwAboutDialog,
+   adw_about_dialog_new, adw_about_dialog_new_from_appdata,
+   adw_about_dialog_set_application_icon,
+   adw_about_dialog_get_application_icon,
+   adw_about_dialog_set_application_name,
+   adw_about_dialog_get_application_name,
+   adw_about_dialog_set_version, adw_about_dialog_get_version,
+   adw_about_dialog_set_release_notes, adw_about_dialog_get_release_notes,
+   adw_about_dialog_set_release_notes_version,
+   adw_about_dialog_get_release_notes_version,
+   adw_about_dialog_set_comments, adw_about_dialog_get_comments,
+   adw_about_dialog_set_website, adw_about_dialog_get_website,
+   adw_about_dialog_set_support_url, adw_about_dialog_get_support_url,
+   adw_about_dialog_set_issue_url, adw_about_dialog_get_issue_url,
+   adw_about_dialog_set_developer_name, adw_about_dialog_get_developer_name,
+   adw_about_dialog_set_copyright, adw_about_dialog_get_copyright,
+   adw_about_dialog_set_license, adw_about_dialog_get_license,
+   adw_about_dialog_set_license_type, adw_about_dialog_get_license_type,
+   adw_about_dialog_set_debug_info, adw_about_dialog_get_debug_info,
+   adw_about_dialog_set_debug_info_filename,
+   adw_about_dialog_get_debug_info_filename,
+   adw_about_dialog_set_translator_credits,
+   adw_about_dialog_get_translator_credits,
+   adw_about_dialog_set_artists, adw_about_dialog_get_artists,
+   adw_about_dialog_set_designers, adw_about_dialog_get_designers,
+   adw_about_dialog_set_developers, adw_about_dialog_get_developers,
+   adw_about_dialog_set_documenters, adw_about_dialog_get_documenters,
+   adw_about_dialog_add_credit_section,
+   adw_about_dialog_add_acknowledgement_section,
+   adw_about_dialog_add_link, adw_about_dialog_add_legal_section,
+   adw_about_dialog_add_other_app;
+
+TYPE
+   AdwAboutDialog = ADDRESS;
+
+(* GtkWidget *adw_about_dialog_new(void) *)
+PROCEDURE adw_about_dialog_new () : AdwAboutDialog;
+
+(* GtkWidget *adw_about_dialog_new_from_appdata(const char *resource_path,
+                                                const char *release_notes_version) *)
+PROCEDURE adw_about_dialog_new_from_appdata (resource_path: ARRAY OF CHAR;
+                                             release_notes_version: ARRAY OF CHAR)
+                                            : AdwAboutDialog;
+
+(* void adw_about_dialog_set_application_icon(AdwAboutDialog *self,
+                                               const char *icon_name) *)
+PROCEDURE adw_about_dialog_set_application_icon (self: AdwAboutDialog;
+                                                 icon_name: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_application_icon(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_application_icon (self: AdwAboutDialog)
+                                                 : ADDRESS;
+
+(* void adw_about_dialog_set_application_name(AdwAboutDialog *self,
+                                               const char *name) *)
+PROCEDURE adw_about_dialog_set_application_name (self: AdwAboutDialog;
+                                                 name: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_application_name(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_application_name (self: AdwAboutDialog)
+                                                 : ADDRESS;
+
+(* void adw_about_dialog_set_version(AdwAboutDialog *self, const char *version) *)
+PROCEDURE adw_about_dialog_set_version (self: AdwAboutDialog;
+                                        version: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_version(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_version (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_release_notes(AdwAboutDialog *self,
+                                           const char *release_notes) *)
+PROCEDURE adw_about_dialog_set_release_notes (self: AdwAboutDialog;
+                                              release_notes: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_release_notes(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_release_notes (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_release_notes_version(AdwAboutDialog *self,
+                                                   const char *version) *)
+PROCEDURE adw_about_dialog_set_release_notes_version (self: AdwAboutDialog;
+                                                      version: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_release_notes_version(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_release_notes_version (self: AdwAboutDialog)
+                                                      : ADDRESS;
+
+(* void adw_about_dialog_set_comments(AdwAboutDialog *self,
+                                      const char *comments) *)
+PROCEDURE adw_about_dialog_set_comments (self: AdwAboutDialog;
+                                         comments: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_comments(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_comments (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_website(AdwAboutDialog *self,
+                                     const char *website) *)
+PROCEDURE adw_about_dialog_set_website (self: AdwAboutDialog;
+                                        website: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_website(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_website (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_support_url(AdwAboutDialog *self,
+                                         const char *support_url) *)
+PROCEDURE adw_about_dialog_set_support_url (self: AdwAboutDialog;
+                                            support_url: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_support_url(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_support_url (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_issue_url(AdwAboutDialog *self,
+                                       const char *issue_url) *)
+PROCEDURE adw_about_dialog_set_issue_url (self: AdwAboutDialog;
+                                          issue_url: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_issue_url(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_issue_url (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_developer_name(AdwAboutDialog *self,
+                                             const char *developer_name) *)
+PROCEDURE adw_about_dialog_set_developer_name (self: AdwAboutDialog;
+                                               developer_name: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_developer_name(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_developer_name (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_copyright(AdwAboutDialog *self,
+                                       const char *copyright) *)
+PROCEDURE adw_about_dialog_set_copyright (self: AdwAboutDialog;
+                                          copyright: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_copyright(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_copyright (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_license(AdwAboutDialog *self,
+                                     const char *license) *)
+PROCEDURE adw_about_dialog_set_license (self: AdwAboutDialog;
+                                        license: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_license(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_license (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_license_type(AdwAboutDialog *self,
+                                          GtkLicense license_type) *)
+PROCEDURE adw_about_dialog_set_license_type (self: AdwAboutDialog;
+                                             license_type: CARDINAL);
+
+(* GtkLicense adw_about_dialog_get_license_type(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_license_type (self: AdwAboutDialog) : CARDINAL;
+
+(* void adw_about_dialog_set_debug_info(AdwAboutDialog *self,
+                                        const char *debug_info) *)
+PROCEDURE adw_about_dialog_set_debug_info (self: AdwAboutDialog;
+                                           debug_info: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_debug_info(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_debug_info (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_debug_info_filename(AdwAboutDialog *self,
+                                                 const char *filename) *)
+PROCEDURE adw_about_dialog_set_debug_info_filename (self: AdwAboutDialog;
+                                                    filename: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_debug_info_filename(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_debug_info_filename (self: AdwAboutDialog)
+                                                    : ADDRESS;
+
+(* void adw_about_dialog_set_translator_credits(AdwAboutDialog *self,
+                                                const char *credits) *)
+PROCEDURE adw_about_dialog_set_translator_credits (self: AdwAboutDialog;
+                                                   credits: ARRAY OF CHAR);
+
+(* const char *adw_about_dialog_get_translator_credits(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_translator_credits (self: AdwAboutDialog)
+                                                   : ADDRESS;
+
+(* void adw_about_dialog_set_artists(AdwAboutDialog *self,
+                                      const char * const *artists) *)
+PROCEDURE adw_about_dialog_set_artists (self: AdwAboutDialog;
+                                        artists: ADDRESS);
+
+(* const char * const *adw_about_dialog_get_artists(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_artists (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_designers(AdwAboutDialog *self,
+                                        const char * const *designers) *)
+PROCEDURE adw_about_dialog_set_designers (self: AdwAboutDialog;
+                                          designers: ADDRESS);
+
+(* const char * const *adw_about_dialog_get_designers(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_designers (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_developers(AdwAboutDialog *self,
+                                         const char * const *developers) *)
+PROCEDURE adw_about_dialog_set_developers (self: AdwAboutDialog;
+                                           developers: ADDRESS);
+
+(* const char * const *adw_about_dialog_get_developers(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_developers (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_set_documenters(AdwAboutDialog *self,
+                                          const char * const *documenters) *)
+PROCEDURE adw_about_dialog_set_documenters (self: AdwAboutDialog;
+                                            documenters: ADDRESS);
+
+(* const char * const *adw_about_dialog_get_documenters(AdwAboutDialog *self) *)
+PROCEDURE adw_about_dialog_get_documenters (self: AdwAboutDialog) : ADDRESS;
+
+(* void adw_about_dialog_add_credit_section(AdwAboutDialog *self,
+                                             const char *name,
+                                             const char * const *people) *)
+PROCEDURE adw_about_dialog_add_credit_section (self: AdwAboutDialog;
+                                               name: ARRAY OF CHAR;
+                                               people: ADDRESS);
+
+(* void adw_about_dialog_add_acknowledgement_section(
+          AdwAboutDialog *self, const char *name,
+          const char * const *people) *)
+PROCEDURE adw_about_dialog_add_acknowledgement_section
+              (self: AdwAboutDialog; name: ARRAY OF CHAR; people: ADDRESS);
+
+(* void adw_about_dialog_add_link(AdwAboutDialog *self, const char *title,
+                                   const char *url) *)
+PROCEDURE adw_about_dialog_add_link (self: AdwAboutDialog;
+                                     title, url: ARRAY OF CHAR);
+
+(* void adw_about_dialog_add_legal_section(AdwAboutDialog *self,
+                                            const char *title,
+                                            const char *copyright,
+                                            GtkLicense license_type,
+                                            const char *license) *)
+PROCEDURE adw_about_dialog_add_legal_section (self: AdwAboutDialog;
+                                              title, copyright: ARRAY OF CHAR;
+                                              license_type: CARDINAL;
+                                              license: ARRAY OF CHAR);
+
+(* void adw_about_dialog_add_other_app(AdwAboutDialog *self,
+                                        const char *appid, const char *name,
+                                        const char *summary) *)
+PROCEDURE adw_about_dialog_add_other_app (self: AdwAboutDialog;
+                                          appid, name, summary: ARRAY OF CHAR);
+
+END AdwAboutDialog.

src/AdwAlertDialog.def

@@ -0,0 +1,186 @@
+DEFINITION MODULE FOR "C" AdwAlertDialog ;
+
+(*
+   m2-GTK4 - AdwAlertDialog: a simple alert dialog with responses.
+   Mapped onto <libadwaita-1/adw-alert-dialog.h>.
+
+   Choose a response asynchronously with choose(); the callback has the
+   GAsyncReadyCallback shape
+
+      void callback(AdwAlertDialog *source, GAsyncResult *result,
+                    gpointer user_data)
+
+   and obtains the chosen response id with choose_finish().
+
+   Note: the variadic format_*() and add_responses() helpers are left out.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+FROM AdwEnums IMPORT AdwResponseAppearance;
+
+EXPORT UNQUALIFIED
+   AdwAlertDialog,
+   adw_alert_dialog_new,
+   adw_alert_dialog_add_response, adw_alert_dialog_remove_response,
+   adw_alert_dialog_has_response,
+   adw_alert_dialog_get_heading, adw_alert_dialog_set_heading,
+   adw_alert_dialog_get_body, adw_alert_dialog_set_body,
+   adw_alert_dialog_get_heading_use_markup,
+   adw_alert_dialog_set_heading_use_markup,
+   adw_alert_dialog_get_body_use_markup,
+   adw_alert_dialog_set_body_use_markup,
+   adw_alert_dialog_get_close_response, adw_alert_dialog_set_close_response,
+   adw_alert_dialog_get_default_response,
+   adw_alert_dialog_set_default_response,
+   adw_alert_dialog_get_extra_child, adw_alert_dialog_set_extra_child,
+   adw_alert_dialog_get_prefer_wide_layout,
+   adw_alert_dialog_set_prefer_wide_layout,
+   adw_alert_dialog_get_response_appearance,
+   adw_alert_dialog_set_response_appearance,
+   adw_alert_dialog_get_response_enabled,
+   adw_alert_dialog_set_response_enabled,
+   adw_alert_dialog_get_response_label,
+   adw_alert_dialog_set_response_label,
+   adw_alert_dialog_choose, adw_alert_dialog_choose_finish;
+
+TYPE
+   AdwAlertDialog = ADDRESS;
+
+(* AdwDialog *adw_alert_dialog_new(const char *heading, const char *body) *)
+PROCEDURE adw_alert_dialog_new (heading, body: ARRAY OF CHAR) : AdwAlertDialog;
+
+(* void adw_alert_dialog_add_response(AdwAlertDialog *self,
+                                      const char *id, const char *label) *)
+PROCEDURE adw_alert_dialog_add_response (self: AdwAlertDialog;
+                                         id, label: ARRAY OF CHAR);
+
+(* void adw_alert_dialog_remove_response(AdwAlertDialog *self,
+                                         const char *id) *)
+PROCEDURE adw_alert_dialog_remove_response (self: AdwAlertDialog;
+                                            id: ARRAY OF CHAR);
+
+(* gboolean adw_alert_dialog_has_response(AdwAlertDialog *self,
+                                          const char *response) *)
+PROCEDURE adw_alert_dialog_has_response (self: AdwAlertDialog;
+                                         response: ARRAY OF CHAR) : INTEGER;
+
+(* const char *adw_alert_dialog_get_heading(AdwAlertDialog *self) *)
+PROCEDURE adw_alert_dialog_get_heading (self: AdwAlertDialog) : ADDRESS;
+
+(* void adw_alert_dialog_set_heading(AdwAlertDialog *self,
+                                     const char *heading) *)
+PROCEDURE adw_alert_dialog_set_heading (self: AdwAlertDialog;
+                                        heading: ARRAY OF CHAR);
+
+(* const char *adw_alert_dialog_get_body(AdwAlertDialog *self) *)
+PROCEDURE adw_alert_dialog_get_body (self: AdwAlertDialog) : ADDRESS;
+
+(* void adw_alert_dialog_set_body(AdwAlertDialog *self, const char *body) *)
+PROCEDURE adw_alert_dialog_set_body (self: AdwAlertDialog;
+                                     body: ARRAY OF CHAR);
+
+(* gboolean adw_alert_dialog_get_heading_use_markup(AdwAlertDialog *self) *)
+PROCEDURE adw_alert_dialog_get_heading_use_markup (self: AdwAlertDialog)
+                                                   : INTEGER;
+
+(* void adw_alert_dialog_set_heading_use_markup(AdwAlertDialog *self,
+                                                gboolean use_markup) *)
+PROCEDURE adw_alert_dialog_set_heading_use_markup (self: AdwAlertDialog;
+                                                   use_markup: INTEGER);
+
+(* gboolean adw_alert_dialog_get_body_use_markup(AdwAlertDialog *self) *)
+PROCEDURE adw_alert_dialog_get_body_use_markup (self: AdwAlertDialog)
+                                                : INTEGER;
+
+(* void adw_alert_dialog_set_body_use_markup(AdwAlertDialog *self,
+                                             gboolean use_markup) *)
+PROCEDURE adw_alert_dialog_set_body_use_markup (self: AdwAlertDialog;
+                                                use_markup: INTEGER);
+
+(* const char *adw_alert_dialog_get_close_response(AdwAlertDialog *self) *)
+PROCEDURE adw_alert_dialog_get_close_response (self: AdwAlertDialog) : ADDRESS;
+
+(* void adw_alert_dialog_set_close_response(AdwAlertDialog *self,
+                                            const char *response) *)
+PROCEDURE adw_alert_dialog_set_close_response (self: AdwAlertDialog;
+                                               response: ARRAY OF CHAR);
+
+(* const char *adw_alert_dialog_get_default_response(AdwAlertDialog *self) *)
+PROCEDURE adw_alert_dialog_get_default_response (self: AdwAlertDialog)
+                                                 : ADDRESS;
+
+(* void adw_alert_dialog_set_default_response(AdwAlertDialog *self,
+                                              const char *response) *)
+PROCEDURE adw_alert_dialog_set_default_response (self: AdwAlertDialog;
+                                                 response: ARRAY OF CHAR);
+
+(* GtkWidget *adw_alert_dialog_get_extra_child(AdwAlertDialog *self) *)
+PROCEDURE adw_alert_dialog_get_extra_child (self: AdwAlertDialog) : ADDRESS;
+
+(* void adw_alert_dialog_set_extra_child(AdwAlertDialog *self,
+                                         GtkWidget *child) *)
+PROCEDURE adw_alert_dialog_set_extra_child (self: AdwAlertDialog;
+                                            child: ADDRESS);
+
+(* gboolean adw_alert_dialog_get_prefer_wide_layout(AdwAlertDialog *self) *)
+PROCEDURE adw_alert_dialog_get_prefer_wide_layout (self: AdwAlertDialog)
+                                                   : INTEGER;
+
+(* void adw_alert_dialog_set_prefer_wide_layout(AdwAlertDialog *self,
+                                                gboolean prefer_wide_layout) *)
+PROCEDURE adw_alert_dialog_set_prefer_wide_layout (self: AdwAlertDialog;
+                                                   prefer_wide_layout: INTEGER);
+
+(* AdwResponseAppearance adw_alert_dialog_get_response_appearance(
+        AdwAlertDialog *self, const char *response) *)
+PROCEDURE adw_alert_dialog_get_response_appearance (self: AdwAlertDialog;
+                                                    response: ARRAY OF CHAR)
+                                                   : AdwResponseAppearance;
+
+(* void adw_alert_dialog_set_response_appearance(
+          AdwAlertDialog *self, const char *response,
+          AdwResponseAppearance appearance) *)
+PROCEDURE adw_alert_dialog_set_response_appearance
+              (self: AdwAlertDialog; response: ARRAY OF CHAR;
+               appearance: AdwResponseAppearance);
+
+(* gboolean adw_alert_dialog_get_response_enabled(AdwAlertDialog *self,
+                                                  const char *response) *)
+PROCEDURE adw_alert_dialog_get_response_enabled (self: AdwAlertDialog;
+                                                 response: ARRAY OF CHAR)
+                                                 : INTEGER;
+
+(* void adw_alert_dialog_set_response_enabled(AdwAlertDialog *self,
+                                              const char *response,
+                                              gboolean enabled) *)
+PROCEDURE adw_alert_dialog_set_response_enabled (self: AdwAlertDialog;
+                                                 response: ARRAY OF CHAR;
+                                                 enabled: INTEGER);
+
+(* const char *adw_alert_dialog_get_response_label(AdwAlertDialog *self,
+                                                    const char *response) *)
+PROCEDURE adw_alert_dialog_get_response_label (self: AdwAlertDialog;
+                                               response: ARRAY OF CHAR)
+                                               : ADDRESS;
+
+(* void adw_alert_dialog_set_response_label(AdwAlertDialog *self,
+                                            const char *response,
+                                            const char *label) *)
+PROCEDURE adw_alert_dialog_set_response_label (self: AdwAlertDialog;
+                                               response: ARRAY OF CHAR;
+                                               label: ARRAY OF CHAR);
+
+(* void adw_alert_dialog_choose(AdwAlertDialog *self, GtkWidget *parent,
+                                GCancellable *cancellable,
+                                GAsyncReadyCallback callback,
+                                gpointer user_data) *)
+PROCEDURE adw_alert_dialog_choose (self: AdwAlertDialog; parent: ADDRESS;
+                                   cancellable: ADDRESS; callback: ADDRESS;
+                                   user_data: ADDRESS);
+
+(* const char *adw_alert_dialog_choose_finish(AdwAlertDialog *self,
+                                               GAsyncResult *result) *)
+PROCEDURE adw_alert_dialog_choose_finish (self: AdwAlertDialog;
+                                          result: ADDRESS) : ADDRESS;
+
+END AdwAlertDialog.

src/AdwAnimation.def

@@ -0,0 +1,68 @@
+DEFINITION MODULE FOR "C" AdwAnimation ;
+
+(*
+   m2-GTK4 - AdwAnimation: the abstract base class for animations.
+   Mapped onto <libadwaita-1/adw-animation.h>.
+
+   AdwAnimation is abstract: create an AdwTimedAnimation or an
+   AdwSpringAnimation instead.  The state uses the AdwAnimationState
+   values from AdwEnums.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+FROM AdwEnums IMPORT AdwAnimationState;
+
+EXPORT UNQUALIFIED
+   AdwAnimation,
+   adw_animation_play, adw_animation_pause, adw_animation_resume,
+   adw_animation_reset, adw_animation_skip,
+   adw_animation_get_state, adw_animation_get_value,
+   adw_animation_get_widget, adw_animation_get_target,
+   adw_animation_set_target,
+   adw_animation_get_follow_enable_animations_setting,
+   adw_animation_set_follow_enable_animations_setting;
+
+TYPE
+   AdwAnimation = ADDRESS;
+
+(* void adw_animation_play(AdwAnimation *self) *)
+PROCEDURE adw_animation_play (self: AdwAnimation);
+
+(* void adw_animation_pause(AdwAnimation *self) *)
+PROCEDURE adw_animation_pause (self: AdwAnimation);
+
+(* void adw_animation_resume(AdwAnimation *self) *)
+PROCEDURE adw_animation_resume (self: AdwAnimation);
+
+(* void adw_animation_reset(AdwAnimation *self) *)
+PROCEDURE adw_animation_reset (self: AdwAnimation);
+
+(* void adw_animation_skip(AdwAnimation *self) *)
+PROCEDURE adw_animation_skip (self: AdwAnimation);
+
+(* AdwAnimationState adw_animation_get_state(AdwAnimation *self) *)
+PROCEDURE adw_animation_get_state (self: AdwAnimation) : AdwAnimationState;
+
+(* double adw_animation_get_value(AdwAnimation *self) *)
+PROCEDURE adw_animation_get_value (self: AdwAnimation) : REAL;
+
+(* GtkWidget *adw_animation_get_widget(AdwAnimation *self) *)
+PROCEDURE adw_animation_get_widget (self: AdwAnimation) : ADDRESS;
+
+(* AdwAnimationTarget *adw_animation_get_target(AdwAnimation *self) *)
+PROCEDURE adw_animation_get_target (self: AdwAnimation) : ADDRESS;
+
+(* void adw_animation_set_target(AdwAnimation *self, AdwAnimationTarget *target) *)
+PROCEDURE adw_animation_set_target (self: AdwAnimation; target: ADDRESS);
+
+(* gboolean adw_animation_get_follow_enable_animations_setting(
+              AdwAnimation *self) *)
+PROCEDURE adw_animation_get_follow_enable_animations_setting
+              (self: AdwAnimation) : INTEGER;
+
+(* void adw_animation_set_follow_enable_animations_setting(
+          AdwAnimation *self, gboolean setting) *)
+PROCEDURE adw_animation_set_follow_enable_animations_setting
+              (self: AdwAnimation; setting: INTEGER);
+
+END AdwAnimation.

src/AdwAnimationTarget.def

@@ -0,0 +1,19 @@
+DEFINITION MODULE FOR "C" AdwAnimationTarget ;
+
+(*
+   m2-GTK4 - AdwAnimationTarget: the interface implemented by objects
+   that an AdwAnimation drives.  Mapped onto
+   <libadwaita-1/adw-animation-target.h>.
+
+   It is an interface with no public functions; concrete targets are
+   AdwCallbackAnimationTarget and AdwPropertyAnimationTarget.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED AdwAnimationTarget;
+
+TYPE
+   AdwAnimationTarget = ADDRESS;
+
+END AdwAnimationTarget.

src/AdwBottomSheet.def

@@ -0,0 +1,122 @@
+DEFINITION MODULE FOR "C" AdwBottomSheet ;
+
+(*
+   m2-GTK4 - AdwBottomSheet: a bottom sheet with an optional bottom bar.
+   Mapped onto <libadwaita-1/adw-bottom-sheet.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwBottomSheet,
+   adw_bottom_sheet_new,
+   adw_bottom_sheet_get_content, adw_bottom_sheet_set_content,
+   adw_bottom_sheet_get_sheet, adw_bottom_sheet_set_sheet,
+   adw_bottom_sheet_get_bottom_bar, adw_bottom_sheet_set_bottom_bar,
+   adw_bottom_sheet_get_open, adw_bottom_sheet_set_open,
+   adw_bottom_sheet_get_modal, adw_bottom_sheet_set_modal,
+   adw_bottom_sheet_get_can_open, adw_bottom_sheet_set_can_open,
+   adw_bottom_sheet_get_can_close, adw_bottom_sheet_set_can_close,
+   adw_bottom_sheet_get_full_width, adw_bottom_sheet_set_full_width,
+   adw_bottom_sheet_get_show_drag_handle,
+   adw_bottom_sheet_set_show_drag_handle,
+   adw_bottom_sheet_get_reveal_bottom_bar,
+   adw_bottom_sheet_set_reveal_bottom_bar,
+   adw_bottom_sheet_get_align, adw_bottom_sheet_set_align,
+   adw_bottom_sheet_get_bottom_bar_height,
+   adw_bottom_sheet_get_sheet_height;
+
+TYPE
+   AdwBottomSheet = ADDRESS;
+
+(* GtkWidget *adw_bottom_sheet_new(void) *)
+PROCEDURE adw_bottom_sheet_new () : AdwBottomSheet;
+
+(* GtkWidget *adw_bottom_sheet_get_content(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_content (self: AdwBottomSheet) : ADDRESS;
+
+(* void adw_bottom_sheet_set_content(AdwBottomSheet *self, GtkWidget *content) *)
+PROCEDURE adw_bottom_sheet_set_content (self: AdwBottomSheet;
+                                        content: ADDRESS);
+
+(* GtkWidget *adw_bottom_sheet_get_sheet(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_sheet (self: AdwBottomSheet) : ADDRESS;
+
+(* void adw_bottom_sheet_set_sheet(AdwBottomSheet *self, GtkWidget *sheet) *)
+PROCEDURE adw_bottom_sheet_set_sheet (self: AdwBottomSheet; sheet: ADDRESS);
+
+(* GtkWidget *adw_bottom_sheet_get_bottom_bar(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_bottom_bar (self: AdwBottomSheet) : ADDRESS;
+
+(* void adw_bottom_sheet_set_bottom_bar(AdwBottomSheet *self,
+                                        GtkWidget *bottom_bar) *)
+PROCEDURE adw_bottom_sheet_set_bottom_bar (self: AdwBottomSheet;
+                                           bottom_bar: ADDRESS);
+
+(* gboolean adw_bottom_sheet_get_open(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_open (self: AdwBottomSheet) : INTEGER;
+
+(* void adw_bottom_sheet_set_open(AdwBottomSheet *self, gboolean open) *)
+PROCEDURE adw_bottom_sheet_set_open (self: AdwBottomSheet; open: INTEGER);
+
+(* gboolean adw_bottom_sheet_get_modal(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_modal (self: AdwBottomSheet) : INTEGER;
+
+(* void adw_bottom_sheet_set_modal(AdwBottomSheet *self, gboolean modal) *)
+PROCEDURE adw_bottom_sheet_set_modal (self: AdwBottomSheet; modal: INTEGER);
+
+(* gboolean adw_bottom_sheet_get_can_open(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_can_open (self: AdwBottomSheet) : INTEGER;
+
+(* void adw_bottom_sheet_set_can_open(AdwBottomSheet *self, gboolean can_open) *)
+PROCEDURE adw_bottom_sheet_set_can_open (self: AdwBottomSheet;
+                                         can_open: INTEGER);
+
+(* gboolean adw_bottom_sheet_get_can_close(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_can_close (self: AdwBottomSheet) : INTEGER;
+
+(* void adw_bottom_sheet_set_can_close(AdwBottomSheet *self,
+                                       gboolean can_close) *)
+PROCEDURE adw_bottom_sheet_set_can_close (self: AdwBottomSheet;
+                                          can_close: INTEGER);
+
+(* gboolean adw_bottom_sheet_get_full_width(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_full_width (self: AdwBottomSheet) : INTEGER;
+
+(* void adw_bottom_sheet_set_full_width(AdwBottomSheet *self,
+                                        gboolean full_width) *)
+PROCEDURE adw_bottom_sheet_set_full_width (self: AdwBottomSheet;
+                                           full_width: INTEGER);
+
+(* gboolean adw_bottom_sheet_get_show_drag_handle(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_show_drag_handle (self: AdwBottomSheet)
+                                                 : INTEGER;
+
+(* void adw_bottom_sheet_set_show_drag_handle(AdwBottomSheet *self,
+                                              gboolean show_drag_handle) *)
+PROCEDURE adw_bottom_sheet_set_show_drag_handle (self: AdwBottomSheet;
+                                                 show_drag_handle: INTEGER);
+
+(* gboolean adw_bottom_sheet_get_reveal_bottom_bar(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_reveal_bottom_bar (self: AdwBottomSheet)
+                                                  : INTEGER;
+
+(* void adw_bottom_sheet_set_reveal_bottom_bar(AdwBottomSheet *self,
+                                               gboolean reveal) *)
+PROCEDURE adw_bottom_sheet_set_reveal_bottom_bar (self: AdwBottomSheet;
+                                                  reveal: INTEGER);
+
+(* float adw_bottom_sheet_get_align(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_align (self: AdwBottomSheet) : SHORTREAL;
+
+(* void adw_bottom_sheet_set_align(AdwBottomSheet *self, float align) *)
+PROCEDURE adw_bottom_sheet_set_align (self: AdwBottomSheet; align: SHORTREAL);
+
+(* int adw_bottom_sheet_get_bottom_bar_height(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_bottom_bar_height (self: AdwBottomSheet)
+                                                  : INTEGER;
+
+(* int adw_bottom_sheet_get_sheet_height(AdwBottomSheet *self) *)
+PROCEDURE adw_bottom_sheet_get_sheet_height (self: AdwBottomSheet) : INTEGER;
+
+END AdwBottomSheet.

src/AdwBreakpoint.def

@@ -0,0 +1,46 @@
+DEFINITION MODULE FOR "C" AdwBreakpoint ;
+
+(*
+   m2-GTK4 - AdwBreakpoint: an adaptive breakpoint.  It pairs an
+   AdwBreakpointCondition with setters that are applied when the
+   condition becomes true.  Mapped onto
+   <libadwaita-1/adw-breakpoint.h>.
+
+   Note: add_setters() (variadic) and add_setters_valist() are left out;
+   use add_setter() or add_settersv().
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwBreakpoint,
+   adw_breakpoint_new,
+   adw_breakpoint_get_condition, adw_breakpoint_set_condition,
+   adw_breakpoint_add_setter, adw_breakpoint_add_settersv;
+
+TYPE
+   AdwBreakpoint = ADDRESS;
+
+(* AdwBreakpoint *adw_breakpoint_new(AdwBreakpointCondition *condition) *)
+PROCEDURE adw_breakpoint_new (condition: ADDRESS) : AdwBreakpoint;
+
+(* AdwBreakpointCondition *adw_breakpoint_get_condition(AdwBreakpoint *self) *)
+PROCEDURE adw_breakpoint_get_condition (self: AdwBreakpoint) : ADDRESS;
+
+(* void adw_breakpoint_set_condition(AdwBreakpoint *self,
+                                     AdwBreakpointCondition *condition) *)
+PROCEDURE adw_breakpoint_set_condition (self: AdwBreakpoint;
+                                        condition: ADDRESS);
+
+(* void adw_breakpoint_add_setter(AdwBreakpoint *self, GObject *object,
+                                  const char *property, ...) *)
+PROCEDURE adw_breakpoint_add_setter (self: AdwBreakpoint; object: ADDRESS;
+                                     property: ARRAY OF CHAR;
+                                     value: ADDRESS);
+
+(* void adw_breakpoint_add_settersv(int n_setters, GObject **objects,
+                                    const char **names, GValue *values) *)
+PROCEDURE adw_breakpoint_add_settersv (n_setters: INTEGER; objects: ADDRESS;
+                                       names: ADDRESS; values: ADDRESS);
+
+END AdwBreakpoint.

src/AdwBreakpointBin.def

@@ -0,0 +1,47 @@
+DEFINITION MODULE FOR "C" AdwBreakpointBin ;
+
+(*
+   m2-GTK4 - AdwBreakpointBin: a container whose child can be adapted
+   with AdwBreakpoint objects.  Mapped onto
+   <libadwaita-1/adw-breakpoint-bin.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwBreakpointBin,
+   adw_breakpoint_bin_new,
+   adw_breakpoint_bin_get_child, adw_breakpoint_bin_set_child,
+   adw_breakpoint_bin_add_breakpoint, adw_breakpoint_bin_remove_breakpoint,
+   adw_breakpoint_bin_get_current_breakpoint;
+
+TYPE
+   AdwBreakpointBin = ADDRESS;
+
+(* GtkWidget *adw_breakpoint_bin_new(void) *)
+PROCEDURE adw_breakpoint_bin_new () : AdwBreakpointBin;
+
+(* GtkWidget *adw_breakpoint_bin_get_child(AdwBreakpointBin *self) *)
+PROCEDURE adw_breakpoint_bin_get_child (self: AdwBreakpointBin) : ADDRESS;
+
+(* void adw_breakpoint_bin_set_child(AdwBreakpointBin *self,
+                                     GtkWidget *child) *)
+PROCEDURE adw_breakpoint_bin_set_child (self: AdwBreakpointBin;
+                                        child: ADDRESS);
+
+(* void adw_breakpoint_bin_add_breakpoint(AdwBreakpointBin *self,
+                                           AdwBreakpoint *breakpoint) *)
+PROCEDURE adw_breakpoint_bin_add_breakpoint (self: AdwBreakpointBin;
+                                             breakpoint: ADDRESS);
+
+(* void adw_breakpoint_bin_remove_breakpoint(AdwBreakpointBin *self,
+                                              AdwBreakpoint *breakpoint) *)
+PROCEDURE adw_breakpoint_bin_remove_breakpoint (self: AdwBreakpointBin;
+                                                breakpoint: ADDRESS);
+
+(* AdwBreakpoint *adw_breakpoint_bin_get_current_breakpoint(
+                   AdwBreakpointBin *self) *)
+PROCEDURE adw_breakpoint_bin_get_current_breakpoint
+              (self: AdwBreakpointBin) : ADDRESS;
+
+END AdwBreakpointBin.

src/AdwBreakpointCondition.def

@@ -0,0 +1,63 @@
+DEFINITION MODULE FOR "C" AdwBreakpointCondition ;
+
+(*
+   m2-GTK4 - AdwBreakpointCondition: the condition used by AdwBreakpoint.
+   Mapped onto <libadwaita-1/adw-breakpoint.h>.
+
+   Conditions are reference-counted; free() releases them.  parse()
+   accepts the AdwBreakpointCondition string syntax (e.g. "max-width: 600px").
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwBreakpointCondition,
+   adw_breakpoint_condition_parse,
+   adw_breakpoint_condition_new_and, adw_breakpoint_condition_new_or,
+   adw_breakpoint_condition_new_length, adw_breakpoint_condition_new_ratio,
+   adw_breakpoint_condition_copy, adw_breakpoint_condition_free,
+   adw_breakpoint_condition_to_string;
+
+TYPE
+   AdwBreakpointCondition = ADDRESS;
+
+(* AdwBreakpointCondition *adw_breakpoint_condition_parse(const char *str) *)
+PROCEDURE adw_breakpoint_condition_parse (str: ARRAY OF CHAR)
+                                          : AdwBreakpointCondition;
+
+(* AdwBreakpointCondition *adw_breakpoint_condition_new_and(
+        AdwBreakpointCondition *condition_1,
+        AdwBreakpointCondition *condition_2) *)
+PROCEDURE adw_breakpoint_condition_new_and (condition_1,
+                                            condition_2: ADDRESS) : ADDRESS;
+
+(* AdwBreakpointCondition *adw_breakpoint_condition_new_or(
+        AdwBreakpointCondition *condition_1,
+        AdwBreakpointCondition *condition_2) *)
+PROCEDURE adw_breakpoint_condition_new_or (condition_1,
+                                           condition_2: ADDRESS) : ADDRESS;
+
+(* AdwBreakpointCondition *adw_breakpoint_condition_new_length(
+        AdwBreakpointConditionLengthType type, double value,
+        AdwLengthUnit unit) *)
+PROCEDURE adw_breakpoint_condition_new_length (type: CARDINAL; value: REAL;
+                                               unit: CARDINAL) : ADDRESS;
+
+(* AdwBreakpointCondition *adw_breakpoint_condition_new_ratio(
+        AdwBreakpointConditionRatioType type, int width, int height) *)
+PROCEDURE adw_breakpoint_condition_new_ratio (type: CARDINAL; width,
+                                              height: INTEGER) : ADDRESS;
+
+(* AdwBreakpointCondition *adw_breakpoint_condition_copy(
+        AdwBreakpointCondition *self) *)
+PROCEDURE adw_breakpoint_condition_copy (self: AdwBreakpointCondition)
+                                         : ADDRESS;
+
+(* void adw_breakpoint_condition_free(AdwBreakpointCondition *self) *)
+PROCEDURE adw_breakpoint_condition_free (self: AdwBreakpointCondition);
+
+(* char *adw_breakpoint_condition_to_string(AdwBreakpointCondition *self) *)
+PROCEDURE adw_breakpoint_condition_to_string (self: AdwBreakpointCondition)
+                                              : ADDRESS;
+
+END AdwBreakpointCondition.

src/AdwCallbackAnimationTarget.def

@@ -0,0 +1,31 @@
+DEFINITION MODULE FOR "C" AdwCallbackAnimationTarget ;
+
+(*
+   m2-GTK4 - AdwCallbackAnimationTarget: an AdwAnimationTarget that calls
+   a function with the current animation value.  Mapped onto
+   <libadwaita-1/adw-animation-target.h>.
+
+   The callback has the shape
+
+      void callback(double value, gpointer user_data)
+
+   and is passed here as ADDRESS; destroy (a GDestroyNotify) may be NIL.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwCallbackAnimationTarget,
+   adw_callback_animation_target_new;
+
+TYPE
+   AdwCallbackAnimationTarget = ADDRESS;
+
+(* AdwAnimationTarget *adw_callback_animation_target_new(
+        AdwAnimationTargetFunc callback, gpointer user_data,
+        GDestroyNotify destroy) *)
+PROCEDURE adw_callback_animation_target_new (callback: ADDRESS;
+                                             user_data: ADDRESS;
+                                             destroy: ADDRESS) : ADDRESS;
+
+END AdwCallbackAnimationTarget.

src/AdwCarousel.def

@@ -0,0 +1,118 @@
+DEFINITION MODULE FOR "C" AdwCarousel ;
+
+(*
+   m2-GTK4 - AdwCarousel: a swipeable carousel of pages.  Mapped onto
+   <libadwaita-1/adw-carousel.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwCarousel,
+   adw_carousel_new,
+   adw_carousel_append, adw_carousel_prepend, adw_carousel_insert,
+   adw_carousel_reorder, adw_carousel_remove,
+   adw_carousel_get_n_pages, adw_carousel_get_nth_page,
+   adw_carousel_scroll_to,
+   adw_carousel_get_position,
+   adw_carousel_get_interactive, adw_carousel_set_interactive,
+   adw_carousel_get_spacing, adw_carousel_set_spacing,
+   adw_carousel_get_reveal_duration, adw_carousel_set_reveal_duration,
+   adw_carousel_get_allow_long_swipes, adw_carousel_set_allow_long_swipes,
+   adw_carousel_get_allow_mouse_drag, adw_carousel_set_allow_mouse_drag,
+   adw_carousel_get_allow_scroll_wheel,
+   adw_carousel_set_allow_scroll_wheel,
+   adw_carousel_get_scroll_params, adw_carousel_set_scroll_params;
+
+TYPE
+   AdwCarousel = ADDRESS;
+
+(* GtkWidget *adw_carousel_new(void) *)
+PROCEDURE adw_carousel_new () : AdwCarousel;
+
+(* void adw_carousel_append(AdwCarousel *self, GtkWidget *child) *)
+PROCEDURE adw_carousel_append (self: AdwCarousel; child: ADDRESS);
+
+(* void adw_carousel_prepend(AdwCarousel *self, GtkWidget *child) *)
+PROCEDURE adw_carousel_prepend (self: AdwCarousel; child: ADDRESS);
+
+(* void adw_carousel_insert(AdwCarousel *self, GtkWidget *child,
+                            int position) *)
+PROCEDURE adw_carousel_insert (self: AdwCarousel; child: ADDRESS;
+                               position: INTEGER);
+
+(* void adw_carousel_reorder(AdwCarousel *self, GtkWidget *child,
+                             int position) *)
+PROCEDURE adw_carousel_reorder (self: AdwCarousel; child: ADDRESS;
+                                position: INTEGER);
+
+(* void adw_carousel_remove(AdwCarousel *self, GtkWidget *child) *)
+PROCEDURE adw_carousel_remove (self: AdwCarousel; child: ADDRESS);
+
+(* guint adw_carousel_get_n_pages(AdwCarousel *self) *)
+PROCEDURE adw_carousel_get_n_pages (self: AdwCarousel) : CARDINAL;
+
+(* GtkWidget *adw_carousel_get_nth_page(AdwCarousel *self, guint n) *)
+PROCEDURE adw_carousel_get_nth_page (self: AdwCarousel; n: CARDINAL) : ADDRESS;
+
+(* void adw_carousel_scroll_to(AdwCarousel *self, GtkWidget *widget,
+                               gboolean animate) *)
+PROCEDURE adw_carousel_scroll_to (self: AdwCarousel; widget: ADDRESS;
+                                  animate: INTEGER);
+
+(* double adw_carousel_get_position(AdwCarousel *self) *)
+PROCEDURE adw_carousel_get_position (self: AdwCarousel) : REAL;
+
+(* gboolean adw_carousel_get_interactive(AdwCarousel *self) *)
+PROCEDURE adw_carousel_get_interactive (self: AdwCarousel) : INTEGER;
+
+(* void adw_carousel_set_interactive(AdwCarousel *self, gboolean interactive) *)
+PROCEDURE adw_carousel_set_interactive (self: AdwCarousel;
+                                        interactive: INTEGER);
+
+(* guint adw_carousel_get_spacing(AdwCarousel *self) *)
+PROCEDURE adw_carousel_get_spacing (self: AdwCarousel) : CARDINAL;
+
+(* void adw_carousel_set_spacing(AdwCarousel *self, guint spacing) *)
+PROCEDURE adw_carousel_set_spacing (self: AdwCarousel; spacing: CARDINAL);
+
+(* guint adw_carousel_get_reveal_duration(AdwCarousel *self) *)
+PROCEDURE adw_carousel_get_reveal_duration (self: AdwCarousel) : CARDINAL;
+
+(* void adw_carousel_set_reveal_duration(AdwCarousel *self, guint duration) *)
+PROCEDURE adw_carousel_set_reveal_duration (self: AdwCarousel;
+                                            reveal_duration: CARDINAL);
+
+(* gboolean adw_carousel_get_allow_long_swipes(AdwCarousel *self) *)
+PROCEDURE adw_carousel_get_allow_long_swipes (self: AdwCarousel) : INTEGER;
+
+(* void adw_carousel_set_allow_long_swipes(AdwCarousel *self,
+                                           gboolean allow_long_swipes) *)
+PROCEDURE adw_carousel_set_allow_long_swipes (self: AdwCarousel;
+                                              allow_long_swipes: INTEGER);
+
+(* gboolean adw_carousel_get_allow_mouse_drag(AdwCarousel *self) *)
+PROCEDURE adw_carousel_get_allow_mouse_drag (self: AdwCarousel) : INTEGER;
+
+(* void adw_carousel_set_allow_mouse_drag(AdwCarousel *self,
+                                          gboolean allow_mouse_drag) *)
+PROCEDURE adw_carousel_set_allow_mouse_drag (self: AdwCarousel;
+                                             allow_mouse_drag: INTEGER);
+
+(* gboolean adw_carousel_get_allow_scroll_wheel(AdwCarousel *self) *)
+PROCEDURE adw_carousel_get_allow_scroll_wheel (self: AdwCarousel) : INTEGER;
+
+(* void adw_carousel_set_allow_scroll_wheel(AdwCarousel *self,
+                                            gboolean allow_scroll_wheel) *)
+PROCEDURE adw_carousel_set_allow_scroll_wheel (self: AdwCarousel;
+                                               allow_scroll_wheel: INTEGER);
+
+(* AdwSpringParams *adw_carousel_get_scroll_params(AdwCarousel *self) *)
+PROCEDURE adw_carousel_get_scroll_params (self: AdwCarousel) : ADDRESS;
+
+(* void adw_carousel_set_scroll_params(AdwCarousel *self,
+                                       AdwSpringParams *params) *)
+PROCEDURE adw_carousel_set_scroll_params (self: AdwCarousel;
+                                          params: ADDRESS);
+
+END AdwCarousel.

src/AdwCarouselIndicatorDots.def

@@ -0,0 +1,32 @@
+DEFINITION MODULE FOR "C" AdwCarouselIndicatorDots ;
+
+(*
+   m2-GTK4 - AdwCarouselIndicatorDots: dot indicators for an AdwCarousel.
+   Mapped onto <libadwaita-1/adw-carousel-indicator-dots.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwCarouselIndicatorDots,
+   adw_carousel_indicator_dots_new,
+   adw_carousel_indicator_dots_get_carousel,
+   adw_carousel_indicator_dots_set_carousel;
+
+TYPE
+   AdwCarouselIndicatorDots = ADDRESS;
+
+(* GtkWidget *adw_carousel_indicator_dots_new(void) *)
+PROCEDURE adw_carousel_indicator_dots_new () : AdwCarouselIndicatorDots;
+
+(* AdwCarousel *adw_carousel_indicator_dots_get_carousel(
+                 AdwCarouselIndicatorDots *self) *)
+PROCEDURE adw_carousel_indicator_dots_get_carousel
+              (self: AdwCarouselIndicatorDots) : ADDRESS;
+
+(* void adw_carousel_indicator_dots_set_carousel(
+          AdwCarouselIndicatorDots *self, AdwCarousel *carousel) *)
+PROCEDURE adw_carousel_indicator_dots_set_carousel
+              (self: AdwCarouselIndicatorDots; carousel: ADDRESS);
+
+END AdwCarouselIndicatorDots.

src/AdwCarouselIndicatorLines.def

@@ -0,0 +1,33 @@
+DEFINITION MODULE FOR "C" AdwCarouselIndicatorLines ;
+
+(*
+   m2-GTK4 - AdwCarouselIndicatorLines: line indicators for an
+   AdwCarousel.  Mapped onto
+   <libadwaita-1/adw-carousel-indicator-lines.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwCarouselIndicatorLines,
+   adw_carousel_indicator_lines_new,
+   adw_carousel_indicator_lines_get_carousel,
+   adw_carousel_indicator_lines_set_carousel;
+
+TYPE
+   AdwCarouselIndicatorLines = ADDRESS;
+
+(* GtkWidget *adw_carousel_indicator_lines_new(void) *)
+PROCEDURE adw_carousel_indicator_lines_new () : AdwCarouselIndicatorLines;
+
+(* AdwCarousel *adw_carousel_indicator_lines_get_carousel(
+                 AdwCarouselIndicatorLines *self) *)
+PROCEDURE adw_carousel_indicator_lines_get_carousel
+              (self: AdwCarouselIndicatorLines) : ADDRESS;
+
+(* void adw_carousel_indicator_lines_set_carousel(
+          AdwCarouselIndicatorLines *self, AdwCarousel *carousel) *)
+PROCEDURE adw_carousel_indicator_lines_set_carousel
+              (self: AdwCarouselIndicatorLines; carousel: ADDRESS);
+
+END AdwCarouselIndicatorLines.

src/AdwDialog.def

@@ -0,0 +1,113 @@
+DEFINITION MODULE FOR "C" AdwDialog ;
+
+(*
+   m2-GTK4 - AdwDialog: an adaptive dialog that can appear floating or as
+   a bottom sheet.  Mapped onto <libadwaita-1/adw-dialog.h>.
+
+   Present a dialog with present(); close() returns FALSE if closing was
+   prevented (see the "close-attempt" signal).
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+FROM AdwEnums IMPORT AdwDialogPresentationMode;
+
+EXPORT UNQUALIFIED
+   AdwDialog,
+   adw_dialog_new,
+   adw_dialog_present, adw_dialog_close, adw_dialog_force_close,
+   adw_dialog_get_child, adw_dialog_set_child,
+   adw_dialog_get_title, adw_dialog_set_title,
+   adw_dialog_get_can_close, adw_dialog_set_can_close,
+   adw_dialog_get_content_width, adw_dialog_set_content_width,
+   adw_dialog_get_content_height, adw_dialog_set_content_height,
+   adw_dialog_get_follows_content_size,
+   adw_dialog_set_follows_content_size,
+   adw_dialog_get_focus, adw_dialog_set_focus,
+   adw_dialog_get_default_widget, adw_dialog_set_default_widget,
+   adw_dialog_get_presentation_mode, adw_dialog_set_presentation_mode,
+   adw_dialog_add_breakpoint, adw_dialog_get_current_breakpoint;
+
+TYPE
+   AdwDialog = ADDRESS;
+
+(* GtkWidget *adw_dialog_new(void) *)
+PROCEDURE adw_dialog_new () : AdwDialog;
+
+(* void adw_dialog_present(AdwDialog *self, GtkWidget *parent) *)
+PROCEDURE adw_dialog_present (self: AdwDialog; parent: ADDRESS);
+
+(* gboolean adw_dialog_close(AdwDialog *self) *)
+PROCEDURE adw_dialog_close (self: AdwDialog) : INTEGER;
+
+(* void adw_dialog_force_close(AdwDialog *self) *)
+PROCEDURE adw_dialog_force_close (self: AdwDialog);
+
+(* GtkWidget *adw_dialog_get_child(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_child (self: AdwDialog) : ADDRESS;
+
+(* void adw_dialog_set_child(AdwDialog *self, GtkWidget *child) *)
+PROCEDURE adw_dialog_set_child (self: AdwDialog; child: ADDRESS);
+
+(* const char *adw_dialog_get_title(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_title (self: AdwDialog) : ADDRESS;
+
+(* void adw_dialog_set_title(AdwDialog *self, const char *title) *)
+PROCEDURE adw_dialog_set_title (self: AdwDialog; title: ARRAY OF CHAR);
+
+(* gboolean adw_dialog_get_can_close(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_can_close (self: AdwDialog) : INTEGER;
+
+(* void adw_dialog_set_can_close(AdwDialog *self, gboolean can_close) *)
+PROCEDURE adw_dialog_set_can_close (self: AdwDialog; can_close: INTEGER);
+
+(* int adw_dialog_get_content_width(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_content_width (self: AdwDialog) : INTEGER;
+
+(* void adw_dialog_set_content_width(AdwDialog *self, int content_width) *)
+PROCEDURE adw_dialog_set_content_width (self: AdwDialog;
+                                        content_width: INTEGER);
+
+(* int adw_dialog_get_content_height(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_content_height (self: AdwDialog) : INTEGER;
+
+(* void adw_dialog_set_content_height(AdwDialog *self, int content_height) *)
+PROCEDURE adw_dialog_set_content_height (self: AdwDialog;
+                                         content_height: INTEGER);
+
+(* gboolean adw_dialog_get_follows_content_size(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_follows_content_size (self: AdwDialog) : INTEGER;
+
+(* void adw_dialog_set_follows_content_size(AdwDialog *self,
+                                            gboolean follows_content_size) *)
+PROCEDURE adw_dialog_set_follows_content_size (self: AdwDialog;
+                                               follows_content_size: INTEGER);
+
+(* GtkWidget *adw_dialog_get_focus(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_focus (self: AdwDialog) : ADDRESS;
+
+(* void adw_dialog_set_focus(AdwDialog *self, GtkWidget *focus) *)
+PROCEDURE adw_dialog_set_focus (self: AdwDialog; focus: ADDRESS);
+
+(* GtkWidget *adw_dialog_get_default_widget(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_default_widget (self: AdwDialog) : ADDRESS;
+
+(* void adw_dialog_set_default_widget(AdwDialog *self, GtkWidget *default_widget) *)
+PROCEDURE adw_dialog_set_default_widget (self: AdwDialog;
+                                         default_widget: ADDRESS);
+
+(* AdwDialogPresentationMode adw_dialog_get_presentation_mode(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_presentation_mode (self: AdwDialog)
+                                            : AdwDialogPresentationMode;
+
+(* void adw_dialog_set_presentation_mode(AdwDialog *self,
+                                         AdwDialogPresentationMode mode) *)
+PROCEDURE adw_dialog_set_presentation_mode (self: AdwDialog;
+                                            mode: AdwDialogPresentationMode);
+
+(* void adw_dialog_add_breakpoint(AdwDialog *self, AdwBreakpoint *breakpoint) *)
+PROCEDURE adw_dialog_add_breakpoint (self: AdwDialog; breakpoint: ADDRESS);
+
+(* AdwBreakpoint *adw_dialog_get_current_breakpoint(AdwDialog *self) *)
+PROCEDURE adw_dialog_get_current_breakpoint (self: AdwDialog) : ADDRESS;
+
+END AdwDialog.

src/AdwEnumListItem.def

@@ -0,0 +1,28 @@
+DEFINITION MODULE FOR "C" AdwEnumListItem ;
+
+(*
+   m2-GTK4 - AdwEnumListItem: the item type yielded by an
+   AdwEnumListModel.  Mapped onto <libadwaita-1/adw-enum-list-model.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwEnumListItem,
+   adw_enum_list_item_get_name,
+   adw_enum_list_item_get_nick,
+   adw_enum_list_item_get_value;
+
+TYPE
+   AdwEnumListItem = ADDRESS;
+
+(* const char *adw_enum_list_item_get_name(AdwEnumListItem *self) *)
+PROCEDURE adw_enum_list_item_get_name (self: AdwEnumListItem) : ADDRESS;
+
+(* const char *adw_enum_list_item_get_nick(AdwEnumListItem *self) *)
+PROCEDURE adw_enum_list_item_get_nick (self: AdwEnumListItem) : ADDRESS;
+
+(* int adw_enum_list_item_get_value(AdwEnumListItem *self) *)
+PROCEDURE adw_enum_list_item_get_value (self: AdwEnumListItem) : INTEGER;
+
+END AdwEnumListItem.

src/AdwEnumListModel.def

@@ -0,0 +1,34 @@
+DEFINITION MODULE FOR "C" AdwEnumListModel ;
+
+(*
+   m2-GTK4 - AdwEnumListModel: a GListModel over the values of a GObject
+   enum type, useful for populating dropdowns from an enum.  Mapped onto
+   <libadwaita-1/adw-enum-list-model.h>.
+
+   The enum type is a GType (a gsize, here LONGCARD).
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwEnumListModel,
+   adw_enum_list_model_new,
+   adw_enum_list_model_get_enum_type,
+   adw_enum_list_model_find_position;
+
+TYPE
+   AdwEnumListModel = ADDRESS;
+
+(* AdwEnumListModel *adw_enum_list_model_new(GType enum_type) *)
+PROCEDURE adw_enum_list_model_new (enum_type: LONGCARD) : AdwEnumListModel;
+
+(* GType adw_enum_list_model_get_enum_type(AdwEnumListModel *self) *)
+PROCEDURE adw_enum_list_model_get_enum_type (self: AdwEnumListModel)
+                                             : LONGCARD;
+
+(* guint adw_enum_list_model_find_position(AdwEnumListModel *self,
+                                            int value) *)
+PROCEDURE adw_enum_list_model_find_position (self: AdwEnumListModel;
+                                             value: INTEGER) : CARDINAL;
+
+END AdwEnumListModel.

src/AdwEnums.def

@@ -1,10 +1,13 @@
 DEFINITION MODULE FOR "C" AdwEnums ;
 
 (*
-   m2-GTK4 - enumerations shared by the libadwaita (Adw) widgets: view
-   switcher policy, inline switcher display mode, squeezer transitions,
-   length units, and the justification / wrap / pack direction used by
-   the adaptive containers.  Mapped onto <libadwaita-1/adw-enums.h>.
+   m2-GTK4 - enumerations shared by the libadwaita (Adw) widgets:
+   view-switcher policy, inline switcher display mode, animation state
+   and easing, flap/leaflet transitions, fold threshold, dialog
+   presentation, navigation direction, response appearance, accent
+   colour, colour scheme, tab-view shortcuts, breakpoint conditions,
+   and the justify / wrap / pack / length units used by the adaptive
+   containers.  Mapped onto <libadwaita-1/adw-enums.h>.
 *)
 
 EXPORT UNQUALIFIED
@@ -18,7 +21,49 @@ EXPORT UNQUALIFIED
    AdwLengthUnit, AdwLengthPx, AdwLengthPt, AdwLengthSp,
    AdwJustifyMode, AdwJustifyNone, AdwJustifyFill, AdwJustifySpread,
    AdwWrapPolicy, AdwWrapMinimum, AdwWrapNatural,
-   AdwPackDirection, AdwPackStartToEnd, AdwPackEndToStart;
+   AdwPackDirection, AdwPackStartToEnd, AdwPackEndToStart,
+   AdwAnimationState,
+   AdwAnimationIdle, AdwAnimationPaused, AdwAnimationPlaying,
+   AdwAnimationFinished,
+   AdwEasing, AdwEasingLinear,
+   AdwEasingInQuad, AdwEasingOutQuad, AdwEasingInOutQuad,
+   AdwEasingInCubic, AdwEasingOutCubic, AdwEasingInOutCubic,
+   AdwEasingInQuart, AdwEasingOutQuart, AdwEasingInOutQuart,
+   AdwEasingInQuint, AdwEasingOutQuint, AdwEasingInOutQuint,
+   AdwEasingInSine, AdwEasingOutSine, AdwEasingInOutSine,
+   AdwEasingInExpo, AdwEasingOutExpo, AdwEasingInOutExpo,
+   AdwEasingInCirc, AdwEasingOutCirc, AdwEasingInOutCirc,
+   AdwEasingInElastic, AdwEasingOutElastic, AdwEasingInOutElastic,
+   AdwEasingInBack, AdwEasingOutBack, AdwEasingInOutBack,
+   AdwEasingInBounce, AdwEasingOutBounce, AdwEasingInOutBounce,
+   AdwEasingEase, AdwEasingEaseIn, AdwEasingEaseOut, AdwEasingEaseInOut,
+   AdwFlapFoldPolicy, AdwFlapFoldNever, AdwFlapFoldAlways, AdwFlapFoldAuto,
+   AdwFlapTransitionType,
+   AdwFlapTransitionOver, AdwFlapTransitionUnder, AdwFlapTransitionSlide,
+   AdwLeafletTransitionType,
+   AdwLeafletTransitionOver, AdwLeafletTransitionUnder,
+   AdwLeafletTransitionSlide,
+   AdwNavigationDirection, AdwNavigationBack, AdwNavigationForward,
+   AdwDialogPresentationMode,
+   AdwDialogAuto, AdwDialogFloating, AdwDialogBottomSheet,
+   AdwResponseAppearance,
+   AdwResponseDefault, AdwResponseSuggested, AdwResponseDestructive,
+   AdwAccentColor,
+   AdwAccentBlue, AdwAccentTeal, AdwAccentGreen, AdwAccentYellow,
+   AdwAccentOrange, AdwAccentRed, AdwAccentPink, AdwAccentPurple,
+   AdwAccentSlate,
+   AdwColorScheme,
+   AdwColorSchemeDefault, AdwColorSchemeForceLight,
+   AdwColorSchemePreferLight, AdwColorSchemePreferDark,
+   AdwColorSchemeForceDark,
+   AdwTabViewShortcuts,
+   AdwTabViewShortcutNone, AdwTabViewShortcutControlTab,
+   AdwTabViewShortcutControlShiftTab, AdwTabViewShortcutControlPageUp,
+   AdwTabViewShortcutControlPageDown, AdwTabViewShortcutControlHome,
+   AdwTabViewShortcutControlEnd, AdwTabViewShortcutControlShiftPageUp,
+   AdwTabViewShortcutControlShiftPageDown, AdwTabViewShortcutControlShiftHome,
+   AdwTabViewShortcutControlShiftEnd, AdwTabViewShortcutAltDigits,
+   AdwTabViewShortcutAltZero, AdwTabViewShortcutAll;
 
 TYPE
    AdwViewSwitcherPolicy = CARDINAL;
@@ -29,6 +74,17 @@ TYPE
    AdwJustifyMode = CARDINAL;
    AdwWrapPolicy = CARDINAL;
    AdwPackDirection = CARDINAL;
+   AdwAnimationState = CARDINAL;
+   AdwEasing = CARDINAL;
+   AdwFlapFoldPolicy = CARDINAL;
+   AdwFlapTransitionType = CARDINAL;
+   AdwLeafletTransitionType = CARDINAL;
+   AdwNavigationDirection = CARDINAL;
+   AdwDialogPresentationMode = CARDINAL;
+   AdwResponseAppearance = CARDINAL;
+   AdwAccentColor = CARDINAL;
+   AdwColorScheme = CARDINAL;
+   AdwTabViewShortcuts = CARDINAL;
 
 CONST
    AdwViewSwitcherNarrow = 0;   (* ADW_VIEW_SWITCHER_POLICY_NARROW *)
@@ -58,4 +114,99 @@ CONST
    AdwPackStartToEnd = 0;  (* ADW_PACK_START_TO_END *)
    AdwPackEndToStart = 1;  (* ADW_PACK_END_TO_START *)
 
+   AdwAnimationIdle     = 0;  (* ADW_ANIMATION_IDLE *)
+   AdwAnimationPaused   = 1;  (* ADW_ANIMATION_PAUSED *)
+   AdwAnimationPlaying  = 2;  (* ADW_ANIMATION_PLAYING *)
+   AdwAnimationFinished = 3;  (* ADW_ANIMATION_FINISHED *)
+
+   AdwEasingLinear      = 0;   (* ADW_LINEAR *)
+   AdwEasingInQuad      = 1;
+   AdwEasingOutQuad     = 2;
+   AdwEasingInOutQuad   = 3;
+   AdwEasingInCubic     = 4;
+   AdwEasingOutCubic    = 5;
+   AdwEasingInOutCubic  = 6;
+   AdwEasingInQuart     = 7;
+   AdwEasingOutQuart    = 8;
+   AdwEasingInOutQuart  = 9;
+   AdwEasingInQuint     = 10;
+   AdwEasingOutQuint    = 11;
+   AdwEasingInOutQuint  = 12;
+   AdwEasingInSine      = 13;
+   AdwEasingOutSine     = 14;
+   AdwEasingInOutSine   = 15;
+   AdwEasingInExpo      = 16;
+   AdwEasingOutExpo     = 17;
+   AdwEasingInOutExpo   = 18;
+   AdwEasingInCirc      = 19;
+   AdwEasingOutCirc     = 20;
+   AdwEasingInOutCirc   = 21;
+   AdwEasingInElastic   = 22;
+   AdwEasingOutElastic  = 23;
+   AdwEasingInOutElastic = 24;
+   AdwEasingInBack      = 25;
+   AdwEasingOutBack     = 26;
+   AdwEasingInOutBack   = 27;
+   AdwEasingInBounce    = 28;
+   AdwEasingOutBounce   = 29;
+   AdwEasingInOutBounce = 30;
+   AdwEasingEase        = 31;
+   AdwEasingEaseIn      = 32;
+   AdwEasingEaseOut     = 33;
+   AdwEasingEaseInOut   = 34;
+
+   AdwFlapFoldNever  = 0;  (* ADW_FLAP_FOLD_POLICY_NEVER *)
+   AdwFlapFoldAlways = 1;  (* ADW_FLAP_FOLD_POLICY_ALWAYS *)
+   AdwFlapFoldAuto   = 2;  (* ADW_FLAP_FOLD_POLICY_AUTO *)
+
+   AdwFlapTransitionOver  = 0;  (* ADW_FLAP_TRANSITION_TYPE_OVER *)
+   AdwFlapTransitionUnder = 1;  (* ADW_FLAP_TRANSITION_TYPE_UNDER *)
+   AdwFlapTransitionSlide = 2;  (* ADW_FLAP_TRANSITION_TYPE_SLIDE *)
+
+   AdwLeafletTransitionOver  = 0;  (* ADW_LEAFLET_TRANSITION_TYPE_OVER *)
+   AdwLeafletTransitionUnder = 1;  (* ADW_LEAFLET_TRANSITION_TYPE_UNDER *)
+   AdwLeafletTransitionSlide = 2;  (* ADW_LEAFLET_TRANSITION_TYPE_SLIDE *)
+
+   AdwNavigationBack    = 0;  (* ADW_NAVIGATION_DIRECTION_BACK *)
+   AdwNavigationForward = 1;  (* ADW_NAVIGATION_DIRECTION_FORWARD *)
+
+   AdwDialogAuto        = 0;  (* ADW_DIALOG_AUTO *)
+   AdwDialogFloating    = 1;  (* ADW_DIALOG_FLOATING *)
+   AdwDialogBottomSheet = 2;  (* ADW_DIALOG_BOTTOM_SHEET *)
+
+   AdwResponseDefault     = 0;  (* ADW_RESPONSE_DEFAULT *)
+   AdwResponseSuggested   = 1;  (* ADW_RESPONSE_SUGGESTED *)
+   AdwResponseDestructive = 2;  (* ADW_RESPONSE_DESTRUCTIVE *)
+
+   AdwAccentBlue   = 0;
+   AdwAccentTeal   = 1;
+   AdwAccentGreen  = 2;
+   AdwAccentYellow = 3;
+   AdwAccentOrange = 4;
+   AdwAccentRed    = 5;
+   AdwAccentPink   = 6;
+   AdwAccentPurple = 7;
+   AdwAccentSlate  = 8;
+
+   AdwColorSchemeDefault     = 0;  (* ADW_COLOR_SCHEME_DEFAULT *)
+   AdwColorSchemeForceLight  = 1;  (* ADW_COLOR_SCHEME_FORCE_LIGHT *)
+   AdwColorSchemePreferLight = 2;  (* ADW_COLOR_SCHEME_PREFER_LIGHT *)
+   AdwColorSchemePreferDark  = 3;  (* ADW_COLOR_SCHEME_PREFER_DARK *)
+   AdwColorSchemeForceDark   = 4;  (* ADW_COLOR_SCHEME_FORCE_DARK *)
+
+   AdwTabViewShortcutNone            = 0;     (* ADW_TAB_VIEW_SHORTCUT_NONE *)
+   AdwTabViewShortcutControlTab      = 1;
+   AdwTabViewShortcutControlShiftTab = 2;
+   AdwTabViewShortcutControlPageUp   = 4;
+   AdwTabViewShortcutControlPageDown = 8;
+   AdwTabViewShortcutControlHome     = 16;
+   AdwTabViewShortcutControlEnd      = 32;
+   AdwTabViewShortcutControlShiftPageUp   = 64;
+   AdwTabViewShortcutControlShiftPageDown = 128;
+   AdwTabViewShortcutControlShiftHome     = 256;
+   AdwTabViewShortcutControlShiftEnd      = 512;
+   AdwTabViewShortcutAltDigits       = 1024;
+   AdwTabViewShortcutAltZero         = 2048;
+   AdwTabViewShortcutAll             = 4095;  (* ADW_TAB_VIEW_SHORTCUT_ALL_SHORTCUTS *)
+
 END AdwEnums.

src/AdwFlap.def

@@ -0,0 +1,137 @@
+DEFINITION MODULE FOR "C" AdwFlap ;
+
+(*
+   m2-GTK4 - AdwFlap: a flap (a sidebar that can fold/overlay over the
+   content).  Mapped onto <libadwaita-1/adw-flap.h>.
+
+   The flap position uses the GtkPackType values (start = 0, end = 1).
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+FROM AdwEnums IMPORT AdwFlapFoldPolicy, AdwFoldThresholdPolicy,
+   AdwFlapTransitionType;
+
+EXPORT UNQUALIFIED
+   AdwFlap,
+   adw_flap_new,
+   adw_flap_get_content, adw_flap_set_content,
+   adw_flap_get_flap, adw_flap_set_flap,
+   adw_flap_get_separator, adw_flap_set_separator,
+   adw_flap_get_flap_position, adw_flap_set_flap_position,
+   adw_flap_get_reveal_flap, adw_flap_set_reveal_flap,
+   adw_flap_get_reveal_progress,
+   adw_flap_get_folded, adw_flap_get_locked, adw_flap_set_locked,
+   adw_flap_get_modal, adw_flap_set_modal,
+   adw_flap_get_swipe_to_open, adw_flap_set_swipe_to_open,
+   adw_flap_get_swipe_to_close, adw_flap_set_swipe_to_close,
+   adw_flap_get_fold_duration, adw_flap_set_fold_duration,
+   adw_flap_get_fold_policy, adw_flap_set_fold_policy,
+   adw_flap_get_fold_threshold_policy,
+   adw_flap_set_fold_threshold_policy,
+   adw_flap_get_transition_type, adw_flap_set_transition_type,
+   adw_flap_get_reveal_params, adw_flap_set_reveal_params;
+
+TYPE
+   AdwFlap = ADDRESS;
+
+(* GtkWidget *adw_flap_new(void) *)
+PROCEDURE adw_flap_new () : AdwFlap;
+
+(* GtkWidget *adw_flap_get_content(AdwFlap *self) *)
+PROCEDURE adw_flap_get_content (self: AdwFlap) : ADDRESS;
+
+(* void adw_flap_set_content(AdwFlap *self, GtkWidget *content) *)
+PROCEDURE adw_flap_set_content (self: AdwFlap; content: ADDRESS);
+
+(* GtkWidget *adw_flap_get_flap(AdwFlap *self) *)
+PROCEDURE adw_flap_get_flap (self: AdwFlap) : ADDRESS;
+
+(* void adw_flap_set_flap(AdwFlap *self, GtkWidget *flap) *)
+PROCEDURE adw_flap_set_flap (self: AdwFlap; flap: ADDRESS);
+
+(* GtkWidget *adw_flap_get_separator(AdwFlap *self) *)
+PROCEDURE adw_flap_get_separator (self: AdwFlap) : ADDRESS;
+
+(* void adw_flap_set_separator(AdwFlap *self, GtkWidget *separator) *)
+PROCEDURE adw_flap_set_separator (self: AdwFlap; separator: ADDRESS);
+
+(* GtkPackType adw_flap_get_flap_position(AdwFlap *self) *)
+PROCEDURE adw_flap_get_flap_position (self: AdwFlap) : CARDINAL;
+
+(* void adw_flap_set_flap_position(AdwFlap *self, GtkPackType position) *)
+PROCEDURE adw_flap_set_flap_position (self: AdwFlap; position: CARDINAL);
+
+(* gboolean adw_flap_get_reveal_flap(AdwFlap *self) *)
+PROCEDURE adw_flap_get_reveal_flap (self: AdwFlap) : INTEGER;
+
+(* void adw_flap_set_reveal_flap(AdwFlap *self, gboolean reveal_flap) *)
+PROCEDURE adw_flap_set_reveal_flap (self: AdwFlap; reveal_flap: INTEGER);
+
+(* double adw_flap_get_reveal_progress(AdwFlap *self) *)
+PROCEDURE adw_flap_get_reveal_progress (self: AdwFlap) : REAL;
+
+(* gboolean adw_flap_get_folded(AdwFlap *self) *)
+PROCEDURE adw_flap_get_folded (self: AdwFlap) : INTEGER;
+
+(* gboolean adw_flap_get_locked(AdwFlap *self) *)
+PROCEDURE adw_flap_get_locked (self: AdwFlap) : INTEGER;
+
+(* void adw_flap_set_locked(AdwFlap *self, gboolean locked) *)
+PROCEDURE adw_flap_set_locked (self: AdwFlap; locked: INTEGER);
+
+(* gboolean adw_flap_get_modal(AdwFlap *self) *)
+PROCEDURE adw_flap_get_modal (self: AdwFlap) : INTEGER;
+
+(* void adw_flap_set_modal(AdwFlap *self, gboolean modal) *)
+PROCEDURE adw_flap_set_modal (self: AdwFlap; modal: INTEGER);
+
+(* gboolean adw_flap_get_swipe_to_open(AdwFlap *self) *)
+PROCEDURE adw_flap_get_swipe_to_open (self: AdwFlap) : INTEGER;
+
+(* void adw_flap_set_swipe_to_open(AdwFlap *self, gboolean swipe_to_open) *)
+PROCEDURE adw_flap_set_swipe_to_open (self: AdwFlap; swipe_to_open: INTEGER);
+
+(* gboolean adw_flap_get_swipe_to_close(AdwFlap *self) *)
+PROCEDURE adw_flap_get_swipe_to_close (self: AdwFlap) : INTEGER;
+
+(* void adw_flap_set_swipe_to_close(AdwFlap *self, gboolean swipe_to_close) *)
+PROCEDURE adw_flap_set_swipe_to_close (self: AdwFlap;
+                                       swipe_to_close: INTEGER);
+
+(* guint adw_flap_get_fold_duration(AdwFlap *self) *)
+PROCEDURE adw_flap_get_fold_duration (self: AdwFlap) : CARDINAL;
+
+(* void adw_flap_set_fold_duration(AdwFlap *self, guint duration) *)
+PROCEDURE adw_flap_set_fold_duration (self: AdwFlap; duration: CARDINAL);
+
+(* AdwFlapFoldPolicy adw_flap_get_fold_policy(AdwFlap *self) *)
+PROCEDURE adw_flap_get_fold_policy (self: AdwFlap) : AdwFlapFoldPolicy;
+
+(* void adw_flap_set_fold_policy(AdwFlap *self, AdwFlapFoldPolicy policy) *)
+PROCEDURE adw_flap_set_fold_policy (self: AdwFlap; policy: AdwFlapFoldPolicy);
+
+(* AdwFoldThresholdPolicy adw_flap_get_fold_threshold_policy(AdwFlap *self) *)
+PROCEDURE adw_flap_get_fold_threshold_policy (self: AdwFlap)
+                                              : AdwFoldThresholdPolicy;
+
+(* void adw_flap_set_fold_threshold_policy(AdwFlap *self,
+                                           AdwFoldThresholdPolicy policy) *)
+PROCEDURE adw_flap_set_fold_threshold_policy (self: AdwFlap;
+                                              policy: AdwFoldThresholdPolicy);
+
+(* AdwFlapTransitionType adw_flap_get_transition_type(AdwFlap *self) *)
+PROCEDURE adw_flap_get_transition_type (self: AdwFlap)
+                                        : AdwFlapTransitionType;
+
+(* void adw_flap_set_transition_type(AdwFlap *self,
+                                     AdwFlapTransitionType transition_type) *)
+PROCEDURE adw_flap_set_transition_type (self: AdwFlap;
+                                        transition_type: AdwFlapTransitionType);
+
+(* AdwSpringParams *adw_flap_get_reveal_params(AdwFlap *self) *)
+PROCEDURE adw_flap_get_reveal_params (self: AdwFlap) : ADDRESS;
+
+(* void adw_flap_set_reveal_params(AdwFlap *self, AdwSpringParams *params) *)
+PROCEDURE adw_flap_set_reveal_params (self: AdwFlap; params: ADDRESS);
+
+END AdwFlap.

src/AdwLayout.def

@@ -0,0 +1,31 @@
+DEFINITION MODULE FOR "C" AdwLayout ;
+
+(*
+   m2-GTK4 - AdwLayout: a layout used by AdwMultiLayoutView.  Mapped onto
+   <libadwaita-1/adw-multi-layout-view.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwLayout,
+   adw_layout_new,
+   adw_layout_get_content,
+   adw_layout_get_name, adw_layout_set_name;
+
+TYPE
+   AdwLayout = ADDRESS;
+
+(* AdwLayout *adw_layout_new(GtkWidget *content) *)
+PROCEDURE adw_layout_new (content: ADDRESS) : AdwLayout;
+
+(* GtkWidget *adw_layout_get_content(AdwLayout *self) *)
+PROCEDURE adw_layout_get_content (self: AdwLayout) : ADDRESS;
+
+(* const char *adw_layout_get_name(AdwLayout *self) *)
+PROCEDURE adw_layout_get_name (self: AdwLayout) : ADDRESS;
+
+(* void adw_layout_set_name(AdwLayout *self, const char *name) *)
+PROCEDURE adw_layout_set_name (self: AdwLayout; name: ARRAY OF CHAR);
+
+END AdwLayout.

src/AdwLayoutSlot.def

@@ -0,0 +1,25 @@
+DEFINITION MODULE FOR "C" AdwLayoutSlot ;
+
+(*
+   m2-GTK4 - AdwLayoutSlot: a named slot placed in an AdwLayout into
+   which AdwMultiLayoutView puts a child.  Mapped onto
+   <libadwaita-1/adw-multi-layout-view.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwLayoutSlot,
+   adw_layout_slot_new,
+   adw_layout_slot_get_slot_id;
+
+TYPE
+   AdwLayoutSlot = ADDRESS;
+
+(* GtkWidget *adw_layout_slot_new(const char *slot_id) *)
+PROCEDURE adw_layout_slot_new (slot_id: ARRAY OF CHAR) : AdwLayoutSlot;
+
+(* const char *adw_layout_slot_get_slot_id(AdwLayoutSlot *self) *)
+PROCEDURE adw_layout_slot_get_slot_id (self: AdwLayoutSlot) : ADDRESS;
+
+END AdwLayoutSlot.

src/AdwLeaflet.def

@@ -0,0 +1,176 @@
+DEFINITION MODULE FOR "C" AdwLeaflet ;
+
+(*
+   m2-GTK4 - AdwLeaflet: a deprecated adaptive container that folds
+   between children.  Mapped onto <libadwaita-1/adw-leaflet.h>.
+
+   Prefer AdwNavigationSplitView / AdwOverlaySplitView for new code.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+FROM AdwEnums IMPORT AdwLeafletTransitionType, AdwNavigationDirection,
+   AdwFoldThresholdPolicy;
+
+EXPORT UNQUALIFIED
+   AdwLeaflet,
+   adw_leaflet_new,
+   adw_leaflet_append, adw_leaflet_prepend,
+   adw_leaflet_insert_child_after, adw_leaflet_reorder_child_after,
+   adw_leaflet_remove,
+   adw_leaflet_get_page, adw_leaflet_get_pages,
+   adw_leaflet_get_child_by_name, adw_leaflet_get_adjacent_child,
+   adw_leaflet_navigate,
+   adw_leaflet_get_visible_child, adw_leaflet_set_visible_child,
+   adw_leaflet_get_visible_child_name,
+   adw_leaflet_set_visible_child_name,
+   adw_leaflet_get_can_navigate_back, adw_leaflet_set_can_navigate_back,
+   adw_leaflet_get_can_navigate_forward,
+   adw_leaflet_set_can_navigate_forward,
+   adw_leaflet_get_can_unfold, adw_leaflet_set_can_unfold,
+   adw_leaflet_get_folded,
+   adw_leaflet_get_homogeneous, adw_leaflet_set_homogeneous,
+   adw_leaflet_get_transition_type, adw_leaflet_set_transition_type,
+   adw_leaflet_get_fold_threshold_policy,
+   adw_leaflet_set_fold_threshold_policy,
+   adw_leaflet_get_mode_transition_duration,
+   adw_leaflet_set_mode_transition_duration,
+   adw_leaflet_get_child_transition_params,
+   adw_leaflet_set_child_transition_params,
+   adw_leaflet_get_child_transition_running;
+
+TYPE
+   AdwLeaflet = ADDRESS;
+
+(* GtkWidget *adw_leaflet_new(void) *)
+PROCEDURE adw_leaflet_new () : AdwLeaflet;
+
+(* AdwLeafletPage *adw_leaflet_append(AdwLeaflet *self, GtkWidget *child) *)
+PROCEDURE adw_leaflet_append (self: AdwLeaflet; child: ADDRESS) : ADDRESS;
+
+(* AdwLeafletPage *adw_leaflet_prepend(AdwLeaflet *self, GtkWidget *child) *)
+PROCEDURE adw_leaflet_prepend (self: AdwLeaflet; child: ADDRESS) : ADDRESS;
+
+(* AdwLeafletPage *adw_leaflet_insert_child_after(AdwLeaflet *self,
+                                                   GtkWidget *child,
+                                                   GtkWidget *sibling) *)
+PROCEDURE adw_leaflet_insert_child_after (self: AdwLeaflet; child,
+                                          sibling: ADDRESS) : ADDRESS;
+
+(* void adw_leaflet_reorder_child_after(AdwLeaflet *self, GtkWidget *child,
+                                        GtkWidget *sibling) *)
+PROCEDURE adw_leaflet_reorder_child_after (self: AdwLeaflet; child,
+                                           sibling: ADDRESS);
+
+(* void adw_leaflet_remove(AdwLeaflet *self, GtkWidget *child) *)
+PROCEDURE adw_leaflet_remove (self: AdwLeaflet; child: ADDRESS);
+
+(* AdwLeafletPage *adw_leaflet_get_page(AdwLeaflet *self, GtkWidget *child) *)
+PROCEDURE adw_leaflet_get_page (self: AdwLeaflet; child: ADDRESS) : ADDRESS;
+
+(* GtkSelectionModel *adw_leaflet_get_pages(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_pages (self: AdwLeaflet) : ADDRESS;
+
+(* GtkWidget *adw_leaflet_get_child_by_name(AdwLeaflet *self,
+                                            const char *name) *)
+PROCEDURE adw_leaflet_get_child_by_name (self: AdwLeaflet;
+                                         name: ARRAY OF CHAR) : ADDRESS;
+
+(* GtkWidget *adw_leaflet_get_adjacent_child(AdwLeaflet *self,
+                                             AdwNavigationDirection direction) *)
+PROCEDURE adw_leaflet_get_adjacent_child (self: AdwLeaflet;
+                                          direction: AdwNavigationDirection)
+                                         : ADDRESS;
+
+(* gboolean adw_leaflet_navigate(AdwLeaflet *self,
+                                 AdwNavigationDirection direction) *)
+PROCEDURE adw_leaflet_navigate (self: AdwLeaflet;
+                                direction: AdwNavigationDirection) : INTEGER;
+
+(* GtkWidget *adw_leaflet_get_visible_child(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_visible_child (self: AdwLeaflet) : ADDRESS;
+
+(* void adw_leaflet_set_visible_child(AdwLeaflet *self, GtkWidget *child) *)
+PROCEDURE adw_leaflet_set_visible_child (self: AdwLeaflet; child: ADDRESS);
+
+(* const char *adw_leaflet_get_visible_child_name(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_visible_child_name (self: AdwLeaflet) : ADDRESS;
+
+(* void adw_leaflet_set_visible_child_name(AdwLeaflet *self,
+                                           const char *name) *)
+PROCEDURE adw_leaflet_set_visible_child_name (self: AdwLeaflet;
+                                              name: ARRAY OF CHAR);
+
+(* gboolean adw_leaflet_get_can_navigate_back(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_can_navigate_back (self: AdwLeaflet) : INTEGER;
+
+(* void adw_leaflet_set_can_navigate_back(AdwLeaflet *self,
+                                          gboolean can_navigate_back) *)
+PROCEDURE adw_leaflet_set_can_navigate_back (self: AdwLeaflet;
+                                             can_navigate_back: INTEGER);
+
+(* gboolean adw_leaflet_get_can_navigate_forward(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_can_navigate_forward (self: AdwLeaflet) : INTEGER;
+
+(* void adw_leaflet_set_can_navigate_forward(AdwLeaflet *self,
+                                             gboolean can_navigate_forward) *)
+PROCEDURE adw_leaflet_set_can_navigate_forward (self: AdwLeaflet;
+                                                can_navigate_forward: INTEGER);
+
+(* gboolean adw_leaflet_get_can_unfold(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_can_unfold (self: AdwLeaflet) : INTEGER;
+
+(* void adw_leaflet_set_can_unfold(AdwLeaflet *self, gboolean can_unfold) *)
+PROCEDURE adw_leaflet_set_can_unfold (self: AdwLeaflet; can_unfold: INTEGER);
+
+(* gboolean adw_leaflet_get_folded(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_folded (self: AdwLeaflet) : INTEGER;
+
+(* gboolean adw_leaflet_get_homogeneous(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_homogeneous (self: AdwLeaflet) : INTEGER;
+
+(* void adw_leaflet_set_homogeneous(AdwLeaflet *self, gboolean homogeneous) *)
+PROCEDURE adw_leaflet_set_homogeneous (self: AdwLeaflet;
+                                       homogeneous: INTEGER);
+
+(* AdwLeafletTransitionType adw_leaflet_get_transition_type(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_transition_type (self: AdwLeaflet)
+                                           : AdwLeafletTransitionType;
+
+(* void adw_leaflet_set_transition_type(AdwLeaflet *self,
+                                        AdwLeafletTransitionType transition) *)
+PROCEDURE adw_leaflet_set_transition_type (self: AdwLeaflet;
+                                           transition: AdwLeafletTransitionType);
+
+(* AdwFoldThresholdPolicy adw_leaflet_get_fold_threshold_policy(
+        AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_fold_threshold_policy (self: AdwLeaflet)
+                                                 : AdwFoldThresholdPolicy;
+
+(* void adw_leaflet_set_fold_threshold_policy(AdwLeaflet *self,
+                                              AdwFoldThresholdPolicy policy) *)
+PROCEDURE adw_leaflet_set_fold_threshold_policy
+              (self: AdwLeaflet; policy: AdwFoldThresholdPolicy);
+
+(* guint adw_leaflet_get_mode_transition_duration(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_mode_transition_duration (self: AdwLeaflet)
+                                                    : CARDINAL;
+
+(* void adw_leaflet_set_mode_transition_duration(AdwLeaflet *self,
+                                                 guint duration) *)
+PROCEDURE adw_leaflet_set_mode_transition_duration (self: AdwLeaflet;
+                                                    duration: CARDINAL);
+
+(* AdwSpringParams *adw_leaflet_get_child_transition_params(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_child_transition_params (self: AdwLeaflet)
+                                                   : ADDRESS;
+
+(* void adw_leaflet_set_child_transition_params(AdwLeaflet *self,
+                                                 AdwSpringParams *params) *)
+PROCEDURE adw_leaflet_set_child_transition_params (self: AdwLeaflet;
+                                                   params: ADDRESS);
+
+(* gboolean adw_leaflet_get_child_transition_running(AdwLeaflet *self) *)
+PROCEDURE adw_leaflet_get_child_transition_running (self: AdwLeaflet)
+                                                    : INTEGER;
+
+END AdwLeaflet.

src/AdwLeafletPage.def

@@ -0,0 +1,37 @@
+DEFINITION MODULE FOR "C" AdwLeafletPage ;
+
+(*
+   m2-GTK4 - AdwLeafletPage: the per-child object of an AdwLeaflet.
+   Mapped onto <libadwaita-1/adw-leaflet.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwLeafletPage,
+   adw_leaflet_page_get_child,
+   adw_leaflet_page_get_name, adw_leaflet_page_set_name,
+   adw_leaflet_page_get_navigatable, adw_leaflet_page_set_navigatable;
+
+TYPE
+   AdwLeafletPage = ADDRESS;
+
+(* GtkWidget *adw_leaflet_page_get_child(AdwLeafletPage *self) *)
+PROCEDURE adw_leaflet_page_get_child (self: AdwLeafletPage) : ADDRESS;
+
+(* const char *adw_leaflet_page_get_name(AdwLeafletPage *self) *)
+PROCEDURE adw_leaflet_page_get_name (self: AdwLeafletPage) : ADDRESS;
+
+(* void adw_leaflet_page_set_name(AdwLeafletPage *self, const char *name) *)
+PROCEDURE adw_leaflet_page_set_name (self: AdwLeafletPage;
+                                     name: ARRAY OF CHAR);
+
+(* gboolean adw_leaflet_page_get_navigatable(AdwLeafletPage *self) *)
+PROCEDURE adw_leaflet_page_get_navigatable (self: AdwLeafletPage) : INTEGER;
+
+(* void adw_leaflet_page_set_navigatable(AdwLeafletPage *self,
+                                         gboolean navigatable) *)
+PROCEDURE adw_leaflet_page_set_navigatable (self: AdwLeafletPage;
+                                            navigatable: INTEGER);
+
+END AdwLeafletPage.

src/AdwMultiLayoutView.def

@@ -0,0 +1,72 @@
+DEFINITION MODULE FOR "C" AdwMultiLayoutView ;
+
+(*
+   m2-GTK4 - AdwMultiLayoutView: a container that can switch between
+   several AdwLayout objects, each naming the slot children it uses
+   (AdwLayoutSlot).  Mapped onto
+   <libadwaita-1/adw-multi-layout-view.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwMultiLayoutView,
+   adw_multi_layout_view_new,
+   adw_multi_layout_view_add_layout, adw_multi_layout_view_remove_layout,
+   adw_multi_layout_view_get_layout, adw_multi_layout_view_set_layout,
+   adw_multi_layout_view_get_layout_name,
+   adw_multi_layout_view_set_layout_name,
+   adw_multi_layout_view_get_layout_by_name,
+   adw_multi_layout_view_set_child, adw_multi_layout_view_get_child;
+
+TYPE
+   AdwMultiLayoutView = ADDRESS;
+
+(* GtkWidget *adw_multi_layout_view_new(void) *)
+PROCEDURE adw_multi_layout_view_new () : AdwMultiLayoutView;
+
+(* void adw_multi_layout_view_add_layout(AdwMultiLayoutView *self,
+                                         AdwLayout *layout) *)
+PROCEDURE adw_multi_layout_view_add_layout (self: AdwMultiLayoutView;
+                                            layout: ADDRESS);
+
+(* void adw_multi_layout_view_remove_layout(AdwMultiLayoutView *self,
+                                            AdwLayout *layout) *)
+PROCEDURE adw_multi_layout_view_remove_layout (self: AdwMultiLayoutView;
+                                               layout: ADDRESS);
+
+(* AdwLayout *adw_multi_layout_view_get_layout(AdwMultiLayoutView *self) *)
+PROCEDURE adw_multi_layout_view_get_layout (self: AdwMultiLayoutView)
+                                            : ADDRESS;
+
+(* void adw_multi_layout_view_set_layout(AdwMultiLayoutView *self,
+                                          AdwLayout *layout) *)
+PROCEDURE adw_multi_layout_view_set_layout (self: AdwMultiLayoutView;
+                                            layout: ADDRESS);
+
+(* const char *adw_multi_layout_view_get_layout_name(AdwMultiLayoutView *self) *)
+PROCEDURE adw_multi_layout_view_get_layout_name (self: AdwMultiLayoutView)
+                                                 : ADDRESS;
+
+(* void adw_multi_layout_view_set_layout_name(AdwMultiLayoutView *self,
+                                              const char *name) *)
+PROCEDURE adw_multi_layout_view_set_layout_name (self: AdwMultiLayoutView;
+                                                 name: ARRAY OF CHAR);
+
+(* AdwLayout *adw_multi_layout_view_get_layout_by_name(
+                AdwMultiLayoutView *self, const char *name) *)
+PROCEDURE adw_multi_layout_view_get_layout_by_name
+              (self: AdwMultiLayoutView; name: ARRAY OF CHAR) : ADDRESS;
+
+(* void adw_multi_layout_view_set_child(AdwMultiLayoutView *self,
+                                        const char *id, GtkWidget *child) *)
+PROCEDURE adw_multi_layout_view_set_child (self: AdwMultiLayoutView;
+                                           id: ARRAY OF CHAR;
+                                           child: ADDRESS);
+
+(* GtkWidget *adw_multi_layout_view_get_child(AdwMultiLayoutView *self,
+                                              const char *id) *)
+PROCEDURE adw_multi_layout_view_get_child (self: AdwMultiLayoutView;
+                                           id: ARRAY OF CHAR) : ADDRESS;
+
+END AdwMultiLayoutView.

src/AdwNavigationSplitView.def

@@ -0,0 +1,131 @@
+DEFINITION MODULE FOR "C" AdwNavigationSplitView ;
+
+(*
+   m2-GTK4 - AdwNavigationSplitView: a split view that collapses to the
+   sidebar (used with AdwNavigationView).  Mapped onto
+   <libadwaita-1/adw-navigation-split-view.h>.
+
+   The sidebar position uses the GtkPackType values (start = 0, end = 1).
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwNavigationSplitView,
+   adw_navigation_split_view_new,
+   adw_navigation_split_view_get_sidebar,
+   adw_navigation_split_view_set_sidebar,
+   adw_navigation_split_view_get_content,
+   adw_navigation_split_view_set_content,
+   adw_navigation_split_view_get_collapsed,
+   adw_navigation_split_view_set_collapsed,
+   adw_navigation_split_view_get_show_content,
+   adw_navigation_split_view_set_show_content,
+   adw_navigation_split_view_get_min_sidebar_width,
+   adw_navigation_split_view_set_min_sidebar_width,
+   adw_navigation_split_view_get_max_sidebar_width,
+   adw_navigation_split_view_set_max_sidebar_width,
+   adw_navigation_split_view_get_sidebar_width_fraction,
+   adw_navigation_split_view_set_sidebar_width_fraction,
+   adw_navigation_split_view_get_sidebar_width_unit,
+   adw_navigation_split_view_set_sidebar_width_unit,
+   adw_navigation_split_view_get_sidebar_position,
+   adw_navigation_split_view_set_sidebar_position;
+
+TYPE
+   AdwNavigationSplitView = ADDRESS;
+
+(* GtkWidget *adw_navigation_split_view_new(void) *)
+PROCEDURE adw_navigation_split_view_new () : AdwNavigationSplitView;
+
+(* GtkWidget *adw_navigation_split_view_get_sidebar(
+                AdwNavigationSplitView *self) *)
+PROCEDURE adw_navigation_split_view_get_sidebar
+              (self: AdwNavigationSplitView) : ADDRESS;
+
+(* void adw_navigation_split_view_set_sidebar(AdwNavigationSplitView *self,
+                                              GtkWidget *sidebar) *)
+PROCEDURE adw_navigation_split_view_set_sidebar
+              (self: AdwNavigationSplitView; sidebar: ADDRESS);
+
+(* GtkWidget *adw_navigation_split_view_get_content(
+                AdwNavigationSplitView *self) *)
+PROCEDURE adw_navigation_split_view_get_content
+              (self: AdwNavigationSplitView) : ADDRESS;
+
+(* void adw_navigation_split_view_set_content(AdwNavigationSplitView *self,
+                                              GtkWidget *content) *)
+PROCEDURE adw_navigation_split_view_set_content
+              (self: AdwNavigationSplitView; content: ADDRESS);
+
+(* gboolean adw_navigation_split_view_get_collapsed(
+              AdwNavigationSplitView *self) *)
+PROCEDURE adw_navigation_split_view_get_collapsed
+              (self: AdwNavigationSplitView) : INTEGER;
+
+(* void adw_navigation_split_view_set_collapsed(
+          AdwNavigationSplitView *self, gboolean collapsed) *)
+PROCEDURE adw_navigation_split_view_set_collapsed
+              (self: AdwNavigationSplitView; collapsed: INTEGER);
+
+(* gboolean adw_navigation_split_view_get_show_content(
+              AdwNavigationSplitView *self) *)
+PROCEDURE adw_navigation_split_view_get_show_content
+              (self: AdwNavigationSplitView) : INTEGER;
+
+(* void adw_navigation_split_view_set_show_content(
+          AdwNavigationSplitView *self, gboolean show_content) *)
+PROCEDURE adw_navigation_split_view_set_show_content
+              (self: AdwNavigationSplitView; show_content: INTEGER);
+
+(* double adw_navigation_split_view_get_min_sidebar_width(
+              AdwNavigationSplitView *self) *)
+PROCEDURE adw_navigation_split_view_get_min_sidebar_width
+              (self: AdwNavigationSplitView) : REAL;
+
+(* void adw_navigation_split_view_set_min_sidebar_width(
+          AdwNavigationSplitView *self, double width) *)
+PROCEDURE adw_navigation_split_view_set_min_sidebar_width
+              (self: AdwNavigationSplitView; width: REAL);
+
+(* double adw_navigation_split_view_get_max_sidebar_width(
+              AdwNavigationSplitView *self) *)
+PROCEDURE adw_navigation_split_view_get_max_sidebar_width
+              (self: AdwNavigationSplitView) : REAL;
+
+(* void adw_navigation_split_view_set_max_sidebar_width(
+          AdwNavigationSplitView *self, double width) *)
+PROCEDURE adw_navigation_split_view_set_max_sidebar_width
+              (self: AdwNavigationSplitView; width: REAL);
+
+(* double adw_navigation_split_view_get_sidebar_width_fraction(
+              AdwNavigationSplitView *self) *)
+PROCEDURE adw_navigation_split_view_get_sidebar_width_fraction
+              (self: AdwNavigationSplitView) : REAL;
+
+(* void adw_navigation_split_view_set_sidebar_width_fraction(
+          AdwNavigationSplitView *self, double fraction) *)
+PROCEDURE adw_navigation_split_view_set_sidebar_width_fraction
+              (self: AdwNavigationSplitView; fraction: REAL);
+
+(* AdwLengthUnit adw_navigation_split_view_get_sidebar_width_unit(
+                    AdwNavigationSplitView *self) *)
+PROCEDURE adw_navigation_split_view_get_sidebar_width_unit
+              (self: AdwNavigationSplitView) : CARDINAL;
+
+(* void adw_navigation_split_view_set_sidebar_width_unit(
+          AdwNavigationSplitView *self, AdwLengthUnit unit) *)
+PROCEDURE adw_navigation_split_view_set_sidebar_width_unit
+              (self: AdwNavigationSplitView; unit: CARDINAL);
+
+(* GtkPackType adw_navigation_split_view_get_sidebar_position(
+                 AdwNavigationSplitView *self) *)
+PROCEDURE adw_navigation_split_view_get_sidebar_position
+              (self: AdwNavigationSplitView) : CARDINAL;
+
+(* void adw_navigation_split_view_set_sidebar_position(
+          AdwNavigationSplitView *self, GtkPackType position) *)
+PROCEDURE adw_navigation_split_view_set_sidebar_position
+              (self: AdwNavigationSplitView; position: CARDINAL);
+
+END AdwNavigationSplitView.

src/AdwOverlaySplitView.def

@@ -0,0 +1,161 @@
+DEFINITION MODULE FOR "C" AdwOverlaySplitView ;
+
+(*
+   m2-GTK4 - AdwOverlaySplitView: a split view where the sidebar overlays
+   the content when collapsed.  Mapped onto
+   <libadwaita-1/adw-overlay-split-view.h>.
+
+   The sidebar position uses the GtkPackType values (start = 0, end = 1).
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwOverlaySplitView,
+   adw_overlay_split_view_new,
+   adw_overlay_split_view_get_sidebar, adw_overlay_split_view_set_sidebar,
+   adw_overlay_split_view_get_content, adw_overlay_split_view_set_content,
+   adw_overlay_split_view_get_show_sidebar,
+   adw_overlay_split_view_set_show_sidebar,
+   adw_overlay_split_view_get_pin_sidebar,
+   adw_overlay_split_view_set_pin_sidebar,
+   adw_overlay_split_view_get_collapsed,
+   adw_overlay_split_view_set_collapsed,
+   adw_overlay_split_view_get_enable_show_gesture,
+   adw_overlay_split_view_set_enable_show_gesture,
+   adw_overlay_split_view_get_enable_hide_gesture,
+   adw_overlay_split_view_set_enable_hide_gesture,
+   adw_overlay_split_view_get_min_sidebar_width,
+   adw_overlay_split_view_set_min_sidebar_width,
+   adw_overlay_split_view_get_max_sidebar_width,
+   adw_overlay_split_view_set_max_sidebar_width,
+   adw_overlay_split_view_get_sidebar_width_fraction,
+   adw_overlay_split_view_set_sidebar_width_fraction,
+   adw_overlay_split_view_get_sidebar_width_unit,
+   adw_overlay_split_view_set_sidebar_width_unit,
+   adw_overlay_split_view_get_sidebar_position,
+   adw_overlay_split_view_set_sidebar_position;
+
+TYPE
+   AdwOverlaySplitView = ADDRESS;
+
+(* GtkWidget *adw_overlay_split_view_new(void) *)
+PROCEDURE adw_overlay_split_view_new () : AdwOverlaySplitView;
+
+(* GtkWidget *adw_overlay_split_view_get_sidebar(AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_sidebar (self: AdwOverlaySplitView)
+                                              : ADDRESS;
+
+(* void adw_overlay_split_view_set_sidebar(AdwOverlaySplitView *self,
+                                            GtkWidget *sidebar) *)
+PROCEDURE adw_overlay_split_view_set_sidebar (self: AdwOverlaySplitView;
+                                              sidebar: ADDRESS);
+
+(* GtkWidget *adw_overlay_split_view_get_content(AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_content (self: AdwOverlaySplitView)
+                                              : ADDRESS;
+
+(* void adw_overlay_split_view_set_content(AdwOverlaySplitView *self,
+                                            GtkWidget *content) *)
+PROCEDURE adw_overlay_split_view_set_content (self: AdwOverlaySplitView;
+                                              content: ADDRESS);
+
+(* gboolean adw_overlay_split_view_get_show_sidebar(
+              AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_show_sidebar
+              (self: AdwOverlaySplitView) : INTEGER;
+
+(* void adw_overlay_split_view_set_show_sidebar(AdwOverlaySplitView *self,
+                                                 gboolean show_sidebar) *)
+PROCEDURE adw_overlay_split_view_set_show_sidebar
+              (self: AdwOverlaySplitView; show_sidebar: INTEGER);
+
+(* gboolean adw_overlay_split_view_get_pin_sidebar(AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_pin_sidebar (self: AdwOverlaySplitView)
+                                                  : INTEGER;
+
+(* void adw_overlay_split_view_set_pin_sidebar(AdwOverlaySplitView *self,
+                                               gboolean pin_sidebar) *)
+PROCEDURE adw_overlay_split_view_set_pin_sidebar
+              (self: AdwOverlaySplitView; pin_sidebar: INTEGER);
+
+(* gboolean adw_overlay_split_view_get_collapsed(AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_collapsed (self: AdwOverlaySplitView)
+                                                : INTEGER;
+
+(* void adw_overlay_split_view_set_collapsed(AdwOverlaySplitView *self,
+                                             gboolean collapsed) *)
+PROCEDURE adw_overlay_split_view_set_collapsed (self: AdwOverlaySplitView;
+                                                collapsed: INTEGER);
+
+(* gboolean adw_overlay_split_view_get_enable_show_gesture(
+              AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_enable_show_gesture
+              (self: AdwOverlaySplitView) : INTEGER;
+
+(* void adw_overlay_split_view_set_enable_show_gesture(
+          AdwOverlaySplitView *self, gboolean enable_show_gesture) *)
+PROCEDURE adw_overlay_split_view_set_enable_show_gesture
+              (self: AdwOverlaySplitView; enable_show_gesture: INTEGER);
+
+(* gboolean adw_overlay_split_view_get_enable_hide_gesture(
+              AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_enable_hide_gesture
+              (self: AdwOverlaySplitView) : INTEGER;
+
+(* void adw_overlay_split_view_set_enable_hide_gesture(
+          AdwOverlaySplitView *self, gboolean enable_hide_gesture) *)
+PROCEDURE adw_overlay_split_view_set_enable_hide_gesture
+              (self: AdwOverlaySplitView; enable_hide_gesture: INTEGER);
+
+(* double adw_overlay_split_view_get_min_sidebar_width(
+            AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_min_sidebar_width
+              (self: AdwOverlaySplitView) : REAL;
+
+(* void adw_overlay_split_view_set_min_sidebar_width(
+          AdwOverlaySplitView *self, double width) *)
+PROCEDURE adw_overlay_split_view_set_min_sidebar_width
+              (self: AdwOverlaySplitView; width: REAL);
+
+(* double adw_overlay_split_view_get_max_sidebar_width(
+            AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_max_sidebar_width
+              (self: AdwOverlaySplitView) : REAL;
+
+(* void adw_overlay_split_view_set_max_sidebar_width(
+          AdwOverlaySplitView *self, double width) *)
+PROCEDURE adw_overlay_split_view_set_max_sidebar_width
+              (self: AdwOverlaySplitView; width: REAL);
+
+(* double adw_overlay_split_view_get_sidebar_width_fraction(
+            AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_sidebar_width_fraction
+              (self: AdwOverlaySplitView) : REAL;
+
+(* void adw_overlay_split_view_set_sidebar_width_fraction(
+          AdwOverlaySplitView *self, double fraction) *)
+PROCEDURE adw_overlay_split_view_set_sidebar_width_fraction
+              (self: AdwOverlaySplitView; fraction: REAL);
+
+(* AdwLengthUnit adw_overlay_split_view_get_sidebar_width_unit(
+                    AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_sidebar_width_unit
+              (self: AdwOverlaySplitView) : CARDINAL;
+
+(* void adw_overlay_split_view_set_sidebar_width_unit(
+          AdwOverlaySplitView *self, AdwLengthUnit unit) *)
+PROCEDURE adw_overlay_split_view_set_sidebar_width_unit
+              (self: AdwOverlaySplitView; unit: CARDINAL);
+
+(* GtkPackType adw_overlay_split_view_get_sidebar_position(
+                 AdwOverlaySplitView *self) *)
+PROCEDURE adw_overlay_split_view_get_sidebar_position
+              (self: AdwOverlaySplitView) : CARDINAL;
+
+(* void adw_overlay_split_view_set_sidebar_position(
+          AdwOverlaySplitView *self, GtkPackType position) *)
+PROCEDURE adw_overlay_split_view_set_sidebar_position
+              (self: AdwOverlaySplitView; position: CARDINAL);
+
+END AdwOverlaySplitView.

src/AdwPreferencesDialog.def

@@ -0,0 +1,85 @@
+DEFINITION MODULE FOR "C" AdwPreferencesDialog ;
+
+(*
+   m2-GTK4 - AdwPreferencesDialog: a preferences dialog (an AdwDialog
+   containing AdwPreferencesPages).  Mapped onto
+   <libadwaita-1/adw-preferences-dialog.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwPreferencesDialog,
+   adw_preferences_dialog_new,
+   adw_preferences_dialog_add, adw_preferences_dialog_remove,
+   adw_preferences_dialog_add_toast,
+   adw_preferences_dialog_get_visible_page,
+   adw_preferences_dialog_set_visible_page,
+   adw_preferences_dialog_get_visible_page_name,
+   adw_preferences_dialog_set_visible_page_name,
+   adw_preferences_dialog_push_subpage,
+   adw_preferences_dialog_pop_subpage,
+   adw_preferences_dialog_get_search_enabled,
+   adw_preferences_dialog_set_search_enabled;
+
+TYPE
+   AdwPreferencesDialog = ADDRESS;
+
+(* AdwDialog *adw_preferences_dialog_new(void) *)
+PROCEDURE adw_preferences_dialog_new () : AdwPreferencesDialog;
+
+(* void adw_preferences_dialog_add(AdwPreferencesDialog *self,
+                                   AdwPreferencesPage *page) *)
+PROCEDURE adw_preferences_dialog_add (self: AdwPreferencesDialog;
+                                      page: ADDRESS);
+
+(* void adw_preferences_dialog_remove(AdwPreferencesDialog *self,
+                                      AdwPreferencesPage *page) *)
+PROCEDURE adw_preferences_dialog_remove (self: AdwPreferencesDialog;
+                                         page: ADDRESS);
+
+(* void adw_preferences_dialog_add_toast(AdwPreferencesDialog *self,
+                                         AdwToast *toast) *)
+PROCEDURE adw_preferences_dialog_add_toast (self: AdwPreferencesDialog;
+                                            toast: ADDRESS);
+
+(* AdwPreferencesPage *adw_preferences_dialog_get_visible_page(
+                        AdwPreferencesDialog *self) *)
+PROCEDURE adw_preferences_dialog_get_visible_page
+              (self: AdwPreferencesDialog) : ADDRESS;
+
+(* void adw_preferences_dialog_set_visible_page(AdwPreferencesDialog *self,
+                                                AdwPreferencesPage *page) *)
+PROCEDURE adw_preferences_dialog_set_visible_page
+              (self: AdwPreferencesDialog; page: ADDRESS);
+
+(* const char *adw_preferences_dialog_get_visible_page_name(
+                AdwPreferencesDialog *self) *)
+PROCEDURE adw_preferences_dialog_get_visible_page_name
+              (self: AdwPreferencesDialog) : ADDRESS;
+
+(* void adw_preferences_dialog_set_visible_page_name(
+          AdwPreferencesDialog *self, const char *name) *)
+PROCEDURE adw_preferences_dialog_set_visible_page_name
+              (self: AdwPreferencesDialog; name: ARRAY OF CHAR);
+
+(* void adw_preferences_dialog_push_subpage(AdwPreferencesDialog *self,
+                                            AdwNavigationPage *page) *)
+PROCEDURE adw_preferences_dialog_push_subpage (self: AdwPreferencesDialog;
+                                               page: ADDRESS);
+
+(* gboolean adw_preferences_dialog_pop_subpage(AdwPreferencesDialog *self) *)
+PROCEDURE adw_preferences_dialog_pop_subpage (self: AdwPreferencesDialog)
+                                              : INTEGER;
+
+(* gboolean adw_preferences_dialog_get_search_enabled(
+              AdwPreferencesDialog *self) *)
+PROCEDURE adw_preferences_dialog_get_search_enabled
+              (self: AdwPreferencesDialog) : INTEGER;
+
+(* void adw_preferences_dialog_set_search_enabled(
+          AdwPreferencesDialog *self, gboolean search_enabled) *)
+PROCEDURE adw_preferences_dialog_set_search_enabled
+              (self: AdwPreferencesDialog; search_enabled: INTEGER);
+
+END AdwPreferencesDialog.

src/AdwPreferencesWindow.def

@@ -0,0 +1,108 @@
+DEFINITION MODULE FOR "C" AdwPreferencesWindow ;
+
+(*
+   m2-GTK4 - AdwPreferencesWindow: the (deprecated) preferences window.
+   Mapped onto <libadwaita-1/adw-preferences-window.h>.
+
+   Prefer AdwPreferencesDialog for new code.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwPreferencesWindow,
+   adw_preferences_window_new,
+   adw_preferences_window_add, adw_preferences_window_remove,
+   adw_preferences_window_add_toast,
+   adw_preferences_window_get_visible_page,
+   adw_preferences_window_set_visible_page,
+   adw_preferences_window_get_visible_page_name,
+   adw_preferences_window_set_visible_page_name,
+   adw_preferences_window_push_subpage,
+   adw_preferences_window_pop_subpage,
+   adw_preferences_window_present_subpage,
+   adw_preferences_window_close_subpage,
+   adw_preferences_window_get_search_enabled,
+   adw_preferences_window_set_search_enabled,
+   adw_preferences_window_get_can_navigate_back,
+   adw_preferences_window_set_can_navigate_back;
+
+TYPE
+   AdwPreferencesWindow = ADDRESS;
+
+(* GtkWidget *adw_preferences_window_new(void) *)
+PROCEDURE adw_preferences_window_new () : AdwPreferencesWindow;
+
+(* void adw_preferences_window_add(AdwPreferencesWindow *self,
+                                   AdwPreferencesPage *page) *)
+PROCEDURE adw_preferences_window_add (self: AdwPreferencesWindow;
+                                      page: ADDRESS);
+
+(* void adw_preferences_window_remove(AdwPreferencesWindow *self,
+                                      AdwPreferencesPage *page) *)
+PROCEDURE adw_preferences_window_remove (self: AdwPreferencesWindow;
+                                         page: ADDRESS);
+
+(* void adw_preferences_window_add_toast(AdwPreferencesWindow *self,
+                                         AdwToast *toast) *)
+PROCEDURE adw_preferences_window_add_toast (self: AdwPreferencesWindow;
+                                            toast: ADDRESS);
+
+(* AdwPreferencesPage *adw_preferences_window_get_visible_page(
+                        AdwPreferencesWindow *self) *)
+PROCEDURE adw_preferences_window_get_visible_page
+              (self: AdwPreferencesWindow) : ADDRESS;
+
+(* void adw_preferences_window_set_visible_page(AdwPreferencesWindow *self,
+                                                AdwPreferencesPage *page) *)
+PROCEDURE adw_preferences_window_set_visible_page
+              (self: AdwPreferencesWindow; page: ADDRESS);
+
+(* const char *adw_preferences_window_get_visible_page_name(
+                AdwPreferencesWindow *self) *)
+PROCEDURE adw_preferences_window_get_visible_page_name
+              (self: AdwPreferencesWindow) : ADDRESS;
+
+(* void adw_preferences_window_set_visible_page_name(
+          AdwPreferencesWindow *self, const char *name) *)
+PROCEDURE adw_preferences_window_set_visible_page_name
+              (self: AdwPreferencesWindow; name: ARRAY OF CHAR);
+
+(* void adw_preferences_window_push_subpage(AdwPreferencesWindow *self,
+                                            AdwNavigationPage *page) *)
+PROCEDURE adw_preferences_window_push_subpage (self: AdwPreferencesWindow;
+                                               page: ADDRESS);
+
+(* gboolean adw_preferences_window_pop_subpage(AdwPreferencesWindow *self) *)
+PROCEDURE adw_preferences_window_pop_subpage (self: AdwPreferencesWindow)
+                                              : INTEGER;
+
+(* void adw_preferences_window_present_subpage(AdwPreferencesWindow *self,
+                                               AdwNavigationPage *subpage) *)
+PROCEDURE adw_preferences_window_present_subpage
+              (self: AdwPreferencesWindow; subpage: ADDRESS);
+
+(* void adw_preferences_window_close_subpage(AdwPreferencesWindow *self) *)
+PROCEDURE adw_preferences_window_close_subpage (self: AdwPreferencesWindow);
+
+(* gboolean adw_preferences_window_get_search_enabled(
+              AdwPreferencesWindow *self) *)
+PROCEDURE adw_preferences_window_get_search_enabled
+              (self: AdwPreferencesWindow) : INTEGER;
+
+(* void adw_preferences_window_set_search_enabled(
+          AdwPreferencesWindow *self, gboolean search_enabled) *)
+PROCEDURE adw_preferences_window_set_search_enabled
+              (self: AdwPreferencesWindow; search_enabled: INTEGER);
+
+(* gboolean adw_preferences_window_get_can_navigate_back(
+              AdwPreferencesWindow *self) *)
+PROCEDURE adw_preferences_window_get_can_navigate_back
+              (self: AdwPreferencesWindow) : INTEGER;
+
+(* void adw_preferences_window_set_can_navigate_back(
+          AdwPreferencesWindow *self, gboolean can_navigate_back) *)
+PROCEDURE adw_preferences_window_set_can_navigate_back
+              (self: AdwPreferencesWindow; can_navigate_back: INTEGER);
+
+END AdwPreferencesWindow.

src/AdwPropertyAnimationTarget.def

@@ -0,0 +1,43 @@
+DEFINITION MODULE FOR "C" AdwPropertyAnimationTarget ;
+
+(*
+   m2-GTK4 - AdwPropertyAnimationTarget: an AdwAnimationTarget that
+   animates a numeric GObject property.  Mapped onto
+   <libadwaita-1/adw-animation-target.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwPropertyAnimationTarget,
+   adw_property_animation_target_new,
+   adw_property_animation_target_new_for_pspec,
+   adw_property_animation_target_get_object,
+   adw_property_animation_target_get_pspec;
+
+TYPE
+   AdwPropertyAnimationTarget = ADDRESS;
+
+(* AdwAnimationTarget *adw_property_animation_target_new(
+        GObject *object, const char *property_name) *)
+PROCEDURE adw_property_animation_target_new (object: ADDRESS;
+                                             property_name: ARRAY OF CHAR)
+                                            : ADDRESS;
+
+(* AdwAnimationTarget *adw_property_animation_target_new_for_pspec(
+        GObject *object, GParamSpec *pspec) *)
+PROCEDURE adw_property_animation_target_new_for_pspec (object: ADDRESS;
+                                                       pspec: ADDRESS)
+                                                      : ADDRESS;
+
+(* GObject *adw_property_animation_target_get_object(
+             AdwPropertyAnimationTarget *self) *)
+PROCEDURE adw_property_animation_target_get_object
+              (self: AdwPropertyAnimationTarget) : ADDRESS;
+
+(* GParamSpec *adw_property_animation_target_get_pspec(
+               AdwPropertyAnimationTarget *self) *)
+PROCEDURE adw_property_animation_target_get_pspec
+              (self: AdwPropertyAnimationTarget) : ADDRESS;
+
+END AdwPropertyAnimationTarget.

src/AdwSpringAnimation.def

@@ -0,0 +1,111 @@
+DEFINITION MODULE FOR "C" AdwSpringAnimation ;
+
+(*
+   m2-GTK4 - AdwSpringAnimation: a physical spring animation.
+   Mapped onto <libadwaita-1/adw-spring-animation.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwSpringAnimation,
+   adw_spring_animation_new,
+   adw_spring_animation_get_value_from,
+   adw_spring_animation_set_value_from,
+   adw_spring_animation_get_value_to, adw_spring_animation_set_value_to,
+   adw_spring_animation_get_spring_params,
+   adw_spring_animation_set_spring_params,
+   adw_spring_animation_get_initial_velocity,
+   adw_spring_animation_set_initial_velocity,
+   adw_spring_animation_get_epsilon, adw_spring_animation_set_epsilon,
+   adw_spring_animation_get_clamp, adw_spring_animation_set_clamp,
+   adw_spring_animation_get_estimated_duration,
+   adw_spring_animation_get_velocity,
+   adw_spring_animation_calculate_value,
+   adw_spring_animation_calculate_velocity;
+
+TYPE
+   AdwSpringAnimation = ADDRESS;
+
+(* AdwAnimation *adw_spring_animation_new(GtkWidget *widget, double from,
+                                           double to,
+                                           AdwSpringParams *spring_params,
+                                           AdwAnimationTarget *target) *)
+PROCEDURE adw_spring_animation_new (widget: ADDRESS;
+                                    valueFrom, valueTo: REAL;
+                                    spring_params: ADDRESS;
+                                    target: ADDRESS) : AdwSpringAnimation;
+
+(* double adw_spring_animation_get_value_from(AdwSpringAnimation *self) *)
+PROCEDURE adw_spring_animation_get_value_from (self: AdwSpringAnimation)
+                                               : REAL;
+
+(* void adw_spring_animation_set_value_from(AdwSpringAnimation *self,
+                                             double value) *)
+PROCEDURE adw_spring_animation_set_value_from (self: AdwSpringAnimation;
+                                               value: REAL);
+
+(* double adw_spring_animation_get_value_to(AdwSpringAnimation *self) *)
+PROCEDURE adw_spring_animation_get_value_to (self: AdwSpringAnimation) : REAL;
+
+(* void adw_spring_animation_set_value_to(AdwSpringAnimation *self,
+                                           double value) *)
+PROCEDURE adw_spring_animation_set_value_to (self: AdwSpringAnimation;
+                                             value: REAL);
+
+(* AdwSpringParams *adw_spring_animation_get_spring_params(
+                     AdwSpringAnimation *self) *)
+PROCEDURE adw_spring_animation_get_spring_params
+              (self: AdwSpringAnimation) : ADDRESS;
+
+(* void adw_spring_animation_set_spring_params(AdwSpringAnimation *self,
+                                               AdwSpringParams *spring_params) *)
+PROCEDURE adw_spring_animation_set_spring_params
+              (self: AdwSpringAnimation; spring_params: ADDRESS);
+
+(* double adw_spring_animation_get_initial_velocity(AdwSpringAnimation *self) *)
+PROCEDURE adw_spring_animation_get_initial_velocity
+              (self: AdwSpringAnimation) : REAL;
+
+(* void adw_spring_animation_set_initial_velocity(AdwSpringAnimation *self,
+                                                  double velocity) *)
+PROCEDURE adw_spring_animation_set_initial_velocity
+              (self: AdwSpringAnimation; velocity: REAL);
+
+(* double adw_spring_animation_get_epsilon(AdwSpringAnimation *self) *)
+PROCEDURE adw_spring_animation_get_epsilon (self: AdwSpringAnimation)
+                                            : REAL;
+
+(* void adw_spring_animation_set_epsilon(AdwSpringAnimation *self,
+                                          double epsilon) *)
+PROCEDURE adw_spring_animation_set_epsilon (self: AdwSpringAnimation;
+                                            epsilon: REAL);
+
+(* gboolean adw_spring_animation_get_clamp(AdwSpringAnimation *self) *)
+PROCEDURE adw_spring_animation_get_clamp (self: AdwSpringAnimation)
+                                          : INTEGER;
+
+(* void adw_spring_animation_set_clamp(AdwSpringAnimation *self,
+                                        gboolean clamp) *)
+PROCEDURE adw_spring_animation_set_clamp (self: AdwSpringAnimation;
+                                          clamp: INTEGER);
+
+(* guint adw_spring_animation_get_estimated_duration(AdwSpringAnimation *self) *)
+PROCEDURE adw_spring_animation_get_estimated_duration
+              (self: AdwSpringAnimation) : CARDINAL;
+
+(* double adw_spring_animation_get_velocity(AdwSpringAnimation *self) *)
+PROCEDURE adw_spring_animation_get_velocity (self: AdwSpringAnimation)
+                                             : REAL;
+
+(* double adw_spring_animation_calculate_value(AdwSpringAnimation *self,
+                                                guint time) *)
+PROCEDURE adw_spring_animation_calculate_value (self: AdwSpringAnimation;
+                                                time: CARDINAL) : REAL;
+
+(* double adw_spring_animation_calculate_velocity(AdwSpringAnimation *self,
+                                                   guint time) *)
+PROCEDURE adw_spring_animation_calculate_velocity (self: AdwSpringAnimation;
+                                                   time: CARDINAL) : REAL;
+
+END AdwSpringAnimation.

src/AdwSpringParams.def

@@ -0,0 +1,51 @@
+DEFINITION MODULE FOR "C" AdwSpringParams ;
+
+(*
+   m2-GTK4 - AdwSpringParams: physical parameters for a spring animation
+   (used by AdwSpringAnimation and the reveal/scroll params of the
+   adaptive widgets).  Mapped onto <libadwaita-1/adw-spring-animation.h>.
+
+   A reference is held with ref() and released with unref().
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwSpringParams,
+   adw_spring_params_new, adw_spring_params_new_full,
+   adw_spring_params_ref, adw_spring_params_unref,
+   adw_spring_params_get_damping, adw_spring_params_get_damping_ratio,
+   adw_spring_params_get_mass, adw_spring_params_get_stiffness;
+
+TYPE
+   AdwSpringParams = ADDRESS;
+
+(* AdwSpringParams *adw_spring_params_new(double damping_ratio, double mass,
+                                           double stiffness) *)
+PROCEDURE adw_spring_params_new (damping_ratio, mass,
+                                 stiffness: REAL) : AdwSpringParams;
+
+(* AdwSpringParams *adw_spring_params_new_full(double damping, double mass,
+                                                double stiffness) *)
+PROCEDURE adw_spring_params_new_full (damping, mass, stiffness: REAL)
+                                      : AdwSpringParams;
+
+(* AdwSpringParams *adw_spring_params_ref(AdwSpringParams *self) *)
+PROCEDURE adw_spring_params_ref (self: AdwSpringParams) : ADDRESS;
+
+(* void adw_spring_params_unref(AdwSpringParams *self) *)
+PROCEDURE adw_spring_params_unref (self: AdwSpringParams);
+
+(* double adw_spring_params_get_damping(AdwSpringParams *self) *)
+PROCEDURE adw_spring_params_get_damping (self: AdwSpringParams) : REAL;
+
+(* double adw_spring_params_get_damping_ratio(AdwSpringParams *self) *)
+PROCEDURE adw_spring_params_get_damping_ratio (self: AdwSpringParams) : REAL;
+
+(* double adw_spring_params_get_mass(AdwSpringParams *self) *)
+PROCEDURE adw_spring_params_get_mass (self: AdwSpringParams) : REAL;
+
+(* double adw_spring_params_get_stiffness(AdwSpringParams *self) *)
+PROCEDURE adw_spring_params_get_stiffness (self: AdwSpringParams) : REAL;
+
+END AdwSpringParams.

src/AdwStyleManager.def

@@ -0,0 +1,87 @@
+DEFINITION MODULE FOR "C" AdwStyleManager ;
+
+(*
+   m2-GTK4 - AdwStyleManager: the per-display Adwaita style singleton
+   (colour scheme, accent colour, fonts).  Mapped onto
+   <libadwaita-1/adw-style-manager.h>.
+
+   There is no constructor: use get_default() or get_for_display().
+   The accent colour uses the AdwAccentColor values and the colour
+   scheme the AdwColorScheme values, both from AdwEnums.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+FROM AdwEnums IMPORT AdwAccentColor, AdwColorScheme;
+
+EXPORT UNQUALIFIED
+   AdwStyleManager,
+   adw_style_manager_get_default,
+   adw_style_manager_get_for_display,
+   adw_style_manager_get_display,
+   adw_style_manager_get_dark,
+   adw_style_manager_get_high_contrast,
+   adw_style_manager_get_accent_color,
+   adw_style_manager_get_accent_color_rgba,
+   adw_style_manager_get_system_supports_accent_colors,
+   adw_style_manager_get_color_scheme, adw_style_manager_set_color_scheme,
+   adw_style_manager_get_system_supports_color_schemes,
+   adw_style_manager_get_document_font_name,
+   adw_style_manager_get_monospace_font_name;
+
+TYPE
+   AdwStyleManager = ADDRESS;
+
+(* AdwStyleManager *adw_style_manager_get_default(void) *)
+PROCEDURE adw_style_manager_get_default () : AdwStyleManager;
+
+(* AdwStyleManager *adw_style_manager_get_for_display(GdkDisplay *display) *)
+PROCEDURE adw_style_manager_get_for_display (display: ADDRESS)
+                                             : AdwStyleManager;
+
+(* GdkDisplay *adw_style_manager_get_display(AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_display (self: AdwStyleManager) : ADDRESS;
+
+(* gboolean adw_style_manager_get_dark(AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_dark (self: AdwStyleManager) : INTEGER;
+
+(* gboolean adw_style_manager_get_high_contrast(AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_high_contrast (self: AdwStyleManager)
+                                               : INTEGER;
+
+(* AdwAccentColor adw_style_manager_get_accent_color(AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_accent_color (self: AdwStyleManager)
+                                              : AdwAccentColor;
+
+(* GdkRGBA *adw_style_manager_get_accent_color_rgba(AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_accent_color_rgba (self: AdwStyleManager)
+                                                   : ADDRESS;
+
+(* gboolean adw_style_manager_get_system_supports_accent_colors(
+              AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_system_supports_accent_colors
+              (self: AdwStyleManager) : INTEGER;
+
+(* AdwColorScheme adw_style_manager_get_color_scheme(AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_color_scheme (self: AdwStyleManager)
+                                              : AdwColorScheme;
+
+(* void adw_style_manager_set_color_scheme(AdwStyleManager *self,
+                                            AdwColorScheme color_scheme) *)
+PROCEDURE adw_style_manager_set_color_scheme (self: AdwStyleManager;
+                                              color_scheme: AdwColorScheme);
+
+(* gboolean adw_style_manager_get_system_supports_color_schemes(
+              AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_system_supports_color_schemes
+              (self: AdwStyleManager) : INTEGER;
+
+(* const char *adw_style_manager_get_document_font_name(AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_document_font_name (self: AdwStyleManager)
+                                                    : ADDRESS;
+
+(* const char *adw_style_manager_get_monospace_font_name(
+                AdwStyleManager *self) *)
+PROCEDURE adw_style_manager_get_monospace_font_name (self: AdwStyleManager)
+                                                     : ADDRESS;
+
+END AdwStyleManager.

src/AdwSwipeTracker.def

@@ -0,0 +1,104 @@
+DEFINITION MODULE FOR "C" AdwSwipeTracker ;
+
+(*
+   m2-GTK4 - AdwSwipeTracker: tracks touchpad/touchscreen swipes for a
+   widget implementing AdwSwipeable (e.g. AdwCarousel, AdwFlap,
+   AdwLeaflet, AdwOverlaySplitView).  Mapped onto
+   <libadwaita-1/adw-swipe-tracker.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwSwipeTracker,
+   adw_swipe_tracker_new,
+   adw_swipe_tracker_get_swipeable,
+   adw_swipe_tracker_get_enabled, adw_swipe_tracker_set_enabled,
+   adw_swipe_tracker_get_reversed, adw_swipe_tracker_set_reversed,
+   adw_swipe_tracker_get_allow_mouse_drag,
+   adw_swipe_tracker_set_allow_mouse_drag,
+   adw_swipe_tracker_get_allow_long_swipes,
+   adw_swipe_tracker_set_allow_long_swipes,
+   adw_swipe_tracker_get_allow_window_handle,
+   adw_swipe_tracker_set_allow_window_handle,
+   adw_swipe_tracker_get_lower_overshoot,
+   adw_swipe_tracker_set_lower_overshoot,
+   adw_swipe_tracker_get_upper_overshoot,
+   adw_swipe_tracker_set_upper_overshoot,
+   adw_swipe_tracker_shift_position;
+
+TYPE
+   AdwSwipeTracker = ADDRESS;
+
+(* AdwSwipeTracker *adw_swipe_tracker_new(AdwSwipeable *swipeable) *)
+PROCEDURE adw_swipe_tracker_new (swipeable: ADDRESS) : AdwSwipeTracker;
+
+(* AdwSwipeable *adw_swipe_tracker_get_swipeable(AdwSwipeTracker *self) *)
+PROCEDURE adw_swipe_tracker_get_swipeable (self: AdwSwipeTracker) : ADDRESS;
+
+(* gboolean adw_swipe_tracker_get_enabled(AdwSwipeTracker *self) *)
+PROCEDURE adw_swipe_tracker_get_enabled (self: AdwSwipeTracker) : INTEGER;
+
+(* void adw_swipe_tracker_set_enabled(AdwSwipeTracker *self,
+                                      gboolean enabled) *)
+PROCEDURE adw_swipe_tracker_set_enabled (self: AdwSwipeTracker;
+                                         enabled: INTEGER);
+
+(* gboolean adw_swipe_tracker_get_reversed(AdwSwipeTracker *self) *)
+PROCEDURE adw_swipe_tracker_get_reversed (self: AdwSwipeTracker) : INTEGER;
+
+(* void adw_swipe_tracker_set_reversed(AdwSwipeTracker *self,
+                                       gboolean reversed) *)
+PROCEDURE adw_swipe_tracker_set_reversed (self: AdwSwipeTracker;
+                                          reversed: INTEGER);
+
+(* gboolean adw_swipe_tracker_get_allow_mouse_drag(AdwSwipeTracker *self) *)
+PROCEDURE adw_swipe_tracker_get_allow_mouse_drag (self: AdwSwipeTracker)
+                                                  : INTEGER;
+
+(* void adw_swipe_tracker_set_allow_mouse_drag(AdwSwipeTracker *self,
+                                               gboolean allow_mouse_drag) *)
+PROCEDURE adw_swipe_tracker_set_allow_mouse_drag (self: AdwSwipeTracker;
+                                                  allow_mouse_drag: INTEGER);
+
+(* gboolean adw_swipe_tracker_get_allow_long_swipes(AdwSwipeTracker *self) *)
+PROCEDURE adw_swipe_tracker_get_allow_long_swipes (self: AdwSwipeTracker)
+                                                   : INTEGER;
+
+(* void adw_swipe_tracker_set_allow_long_swipes(AdwSwipeTracker *self,
+                                                gboolean allow_long_swipes) *)
+PROCEDURE adw_swipe_tracker_set_allow_long_swipes (self: AdwSwipeTracker;
+                                                   allow_long_swipes: INTEGER);
+
+(* gboolean adw_swipe_tracker_get_allow_window_handle(AdwSwipeTracker *self) *)
+PROCEDURE adw_swipe_tracker_get_allow_window_handle (self: AdwSwipeTracker)
+                                                     : INTEGER;
+
+(* void adw_swipe_tracker_set_allow_window_handle(AdwSwipeTracker *self,
+                                                  gboolean allow_window_handle) *)
+PROCEDURE adw_swipe_tracker_set_allow_window_handle
+              (self: AdwSwipeTracker; allow_window_handle: INTEGER);
+
+(* gboolean adw_swipe_tracker_get_lower_overshoot(AdwSwipeTracker *self) *)
+PROCEDURE adw_swipe_tracker_get_lower_overshoot (self: AdwSwipeTracker)
+                                                 : INTEGER;
+
+(* void adw_swipe_tracker_set_lower_overshoot(AdwSwipeTracker *self,
+                                              gboolean overshoot) *)
+PROCEDURE adw_swipe_tracker_set_lower_overshoot (self: AdwSwipeTracker;
+                                                 overshoot: INTEGER);
+
+(* gboolean adw_swipe_tracker_get_upper_overshoot(AdwSwipeTracker *self) *)
+PROCEDURE adw_swipe_tracker_get_upper_overshoot (self: AdwSwipeTracker)
+                                                 : INTEGER;
+
+(* void adw_swipe_tracker_set_upper_overshoot(AdwSwipeTracker *self,
+                                              gboolean overshoot) *)
+PROCEDURE adw_swipe_tracker_set_upper_overshoot (self: AdwSwipeTracker;
+                                                 overshoot: INTEGER);
+
+(* void adw_swipe_tracker_shift_position(AdwSwipeTracker *self, double delta) *)
+PROCEDURE adw_swipe_tracker_shift_position (self: AdwSwipeTracker;
+                                            delta: REAL);
+
+END AdwSwipeTracker.

src/AdwTabBar.def

@@ -0,0 +1,88 @@
+DEFINITION MODULE FOR "C" AdwTabBar ;
+
+(*
+   m2-GTK4 - AdwTabBar: the tab strip for an AdwTabView.  Mapped onto
+   <libadwaita-1/adw-tab-bar.h>.
+
+   Note: setup_extra_drop_target() is variadic and is left out.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwTabBar,
+   adw_tab_bar_new,
+   adw_tab_bar_get_view, adw_tab_bar_set_view,
+   adw_tab_bar_get_autohide, adw_tab_bar_set_autohide,
+   adw_tab_bar_get_expand_tabs, adw_tab_bar_set_expand_tabs,
+   adw_tab_bar_get_inverted, adw_tab_bar_set_inverted,
+   adw_tab_bar_get_is_overflowing, adw_tab_bar_get_tabs_revealed,
+   adw_tab_bar_get_start_action_widget,
+   adw_tab_bar_set_start_action_widget,
+   adw_tab_bar_get_end_action_widget, adw_tab_bar_set_end_action_widget,
+   adw_tab_bar_get_extra_drag_preload, adw_tab_bar_set_extra_drag_preload,
+   adw_tab_bar_get_extra_drag_preferred_action;
+
+TYPE
+   AdwTabBar = ADDRESS;
+
+(* GtkWidget *adw_tab_bar_new(void) *)
+PROCEDURE adw_tab_bar_new () : AdwTabBar;
+
+(* AdwTabView *adw_tab_bar_get_view(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_view (self: AdwTabBar) : ADDRESS;
+
+(* void adw_tab_bar_set_view(AdwTabBar *self, AdwTabView *view) *)
+PROCEDURE adw_tab_bar_set_view (self: AdwTabBar; view: ADDRESS);
+
+(* gboolean adw_tab_bar_get_autohide(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_autohide (self: AdwTabBar) : INTEGER;
+
+(* void adw_tab_bar_set_autohide(AdwTabBar *self, gboolean autohide) *)
+PROCEDURE adw_tab_bar_set_autohide (self: AdwTabBar; autohide: INTEGER);
+
+(* gboolean adw_tab_bar_get_expand_tabs(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_expand_tabs (self: AdwTabBar) : INTEGER;
+
+(* void adw_tab_bar_set_expand_tabs(AdwTabBar *self, gboolean expand_tabs) *)
+PROCEDURE adw_tab_bar_set_expand_tabs (self: AdwTabBar; expand_tabs: INTEGER);
+
+(* gboolean adw_tab_bar_get_inverted(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_inverted (self: AdwTabBar) : INTEGER;
+
+(* void adw_tab_bar_set_inverted(AdwTabBar *self, gboolean inverted) *)
+PROCEDURE adw_tab_bar_set_inverted (self: AdwTabBar; inverted: INTEGER);
+
+(* gboolean adw_tab_bar_get_is_overflowing(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_is_overflowing (self: AdwTabBar) : INTEGER;
+
+(* gboolean adw_tab_bar_get_tabs_revealed(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_tabs_revealed (self: AdwTabBar) : INTEGER;
+
+(* GtkWidget *adw_tab_bar_get_start_action_widget(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_start_action_widget (self: AdwTabBar) : ADDRESS;
+
+(* void adw_tab_bar_set_start_action_widget(AdwTabBar *self,
+                                            GtkWidget *widget) *)
+PROCEDURE adw_tab_bar_set_start_action_widget (self: AdwTabBar;
+                                               widget: ADDRESS);
+
+(* GtkWidget *adw_tab_bar_get_end_action_widget(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_end_action_widget (self: AdwTabBar) : ADDRESS;
+
+(* void adw_tab_bar_set_end_action_widget(AdwTabBar *self, GtkWidget *widget) *)
+PROCEDURE adw_tab_bar_set_end_action_widget (self: AdwTabBar;
+                                             widget: ADDRESS);
+
+(* gboolean adw_tab_bar_get_extra_drag_preload(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_extra_drag_preload (self: AdwTabBar) : INTEGER;
+
+(* void adw_tab_bar_set_extra_drag_preload(AdwTabBar *self, gboolean preload) *)
+PROCEDURE adw_tab_bar_set_extra_drag_preload (self: AdwTabBar;
+                                              preload: INTEGER);
+
+(* GdkDragAction adw_tab_bar_get_extra_drag_preferred_action(AdwTabBar *self) *)
+PROCEDURE adw_tab_bar_get_extra_drag_preferred_action (self: AdwTabBar)
+                                                       : CARDINAL;
+
+END AdwTabBar.

src/AdwTabButton.def

@@ -0,0 +1,27 @@
+DEFINITION MODULE FOR "C" AdwTabButton ;
+
+(*
+   m2-GTK4 - AdwTabButton: a button that opens an AdwTabOverview.
+   Mapped onto <libadwaita-1/adw-tab-button.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwTabButton,
+   adw_tab_button_new,
+   adw_tab_button_get_view, adw_tab_button_set_view;
+
+TYPE
+   AdwTabButton = ADDRESS;
+
+(* GtkWidget *adw_tab_button_new(void) *)
+PROCEDURE adw_tab_button_new () : AdwTabButton;
+
+(* AdwTabView *adw_tab_button_get_view(AdwTabButton *self) *)
+PROCEDURE adw_tab_button_get_view (self: AdwTabButton) : ADDRESS;
+
+(* void adw_tab_button_set_view(AdwTabButton *self, AdwTabView *view) *)
+PROCEDURE adw_tab_button_set_view (self: AdwTabButton; view: ADDRESS);
+
+END AdwTabButton.

src/AdwTabOverview.def

@@ -0,0 +1,128 @@
+DEFINITION MODULE FOR "C" AdwTabOverview ;
+
+(*
+   m2-GTK4 - AdwTabOverview: a full-window overview of an AdwTabView's
+   pages.  Mapped onto <libadwaita-1/adw-tab-overview.h>.
+
+   Note: setup_extra_drop_target() is variadic and is left out.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwTabOverview,
+   adw_tab_overview_new,
+   adw_tab_overview_get_child, adw_tab_overview_set_child,
+   adw_tab_overview_get_view, adw_tab_overview_set_view,
+   adw_tab_overview_get_open, adw_tab_overview_set_open,
+   adw_tab_overview_get_inverted, adw_tab_overview_set_inverted,
+   adw_tab_overview_get_enable_new_tab,
+   adw_tab_overview_set_enable_new_tab,
+   adw_tab_overview_get_enable_search,
+   adw_tab_overview_set_enable_search,
+   adw_tab_overview_get_search_active,
+   adw_tab_overview_get_secondary_menu,
+   adw_tab_overview_set_secondary_menu,
+   adw_tab_overview_get_show_start_title_buttons,
+   adw_tab_overview_set_show_start_title_buttons,
+   adw_tab_overview_get_show_end_title_buttons,
+   adw_tab_overview_set_show_end_title_buttons,
+   adw_tab_overview_get_extra_drag_preload,
+   adw_tab_overview_set_extra_drag_preload,
+   adw_tab_overview_get_extra_drag_preferred_action;
+
+TYPE
+   AdwTabOverview = ADDRESS;
+
+(* GtkWidget *adw_tab_overview_new(void) *)
+PROCEDURE adw_tab_overview_new () : AdwTabOverview;
+
+(* GtkWidget *adw_tab_overview_get_child(AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_child (self: AdwTabOverview) : ADDRESS;
+
+(* void adw_tab_overview_set_child(AdwTabOverview *self, GtkWidget *child) *)
+PROCEDURE adw_tab_overview_set_child (self: AdwTabOverview; child: ADDRESS);
+
+(* AdwTabView *adw_tab_overview_get_view(AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_view (self: AdwTabOverview) : ADDRESS;
+
+(* void adw_tab_overview_set_view(AdwTabOverview *self, AdwTabView *view) *)
+PROCEDURE adw_tab_overview_set_view (self: AdwTabOverview; view: ADDRESS);
+
+(* gboolean adw_tab_overview_get_open(AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_open (self: AdwTabOverview) : INTEGER;
+
+(* void adw_tab_overview_set_open(AdwTabOverview *self, gboolean open) *)
+PROCEDURE adw_tab_overview_set_open (self: AdwTabOverview; open: INTEGER);
+
+(* gboolean adw_tab_overview_get_inverted(AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_inverted (self: AdwTabOverview) : INTEGER;
+
+(* void adw_tab_overview_set_inverted(AdwTabOverview *self, gboolean inverted) *)
+PROCEDURE adw_tab_overview_set_inverted (self: AdwTabOverview;
+                                         inverted: INTEGER);
+
+(* gboolean adw_tab_overview_get_enable_new_tab(AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_enable_new_tab (self: AdwTabOverview)
+                                               : INTEGER;
+
+(* void adw_tab_overview_set_enable_new_tab(AdwTabOverview *self,
+                                             gboolean enable_new_tab) *)
+PROCEDURE adw_tab_overview_set_enable_new_tab (self: AdwTabOverview;
+                                               enable_new_tab: INTEGER);
+
+(* gboolean adw_tab_overview_get_enable_search(AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_enable_search (self: AdwTabOverview) : INTEGER;
+
+(* void adw_tab_overview_set_enable_search(AdwTabOverview *self,
+                                           gboolean enable_search) *)
+PROCEDURE adw_tab_overview_set_enable_search (self: AdwTabOverview;
+                                              enable_search: INTEGER);
+
+(* gboolean adw_tab_overview_get_search_active(AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_search_active (self: AdwTabOverview) : INTEGER;
+
+(* GMenuModel *adw_tab_overview_get_secondary_menu(AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_secondary_menu (self: AdwTabOverview)
+                                               : ADDRESS;
+
+(* void adw_tab_overview_set_secondary_menu(AdwTabOverview *self,
+                                             GMenuModel *secondary_menu) *)
+PROCEDURE adw_tab_overview_set_secondary_menu (self: AdwTabOverview;
+                                               secondary_menu: ADDRESS);
+
+(* gboolean adw_tab_overview_get_show_start_title_buttons(
+              AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_show_start_title_buttons
+              (self: AdwTabOverview) : INTEGER;
+
+(* void adw_tab_overview_set_show_start_title_buttons(
+          AdwTabOverview *self, gboolean show_start_title_buttons) *)
+PROCEDURE adw_tab_overview_set_show_start_title_buttons
+              (self: AdwTabOverview; show_start_title_buttons: INTEGER);
+
+(* gboolean adw_tab_overview_get_show_end_title_buttons(
+              AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_show_end_title_buttons
+              (self: AdwTabOverview) : INTEGER;
+
+(* void adw_tab_overview_set_show_end_title_buttons(
+          AdwTabOverview *self, gboolean show_end_title_buttons) *)
+PROCEDURE adw_tab_overview_set_show_end_title_buttons
+              (self: AdwTabOverview; show_end_title_buttons: INTEGER);
+
+(* gboolean adw_tab_overview_get_extra_drag_preload(AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_extra_drag_preload (self: AdwTabOverview)
+                                                   : INTEGER;
+
+(* void adw_tab_overview_set_extra_drag_preload(AdwTabOverview *self,
+                                                 gboolean preload) *)
+PROCEDURE adw_tab_overview_set_extra_drag_preload (self: AdwTabOverview;
+                                                   preload: INTEGER);
+
+(* GdkDragAction adw_tab_overview_get_extra_drag_preferred_action(
+                  AdwTabOverview *self) *)
+PROCEDURE adw_tab_overview_get_extra_drag_preferred_action
+              (self: AdwTabOverview) : CARDINAL;
+
+END AdwTabOverview.

src/AdwTabPage.def

@@ -0,0 +1,135 @@
+DEFINITION MODULE FOR "C" AdwTabPage ;
+
+(*
+   m2-GTK4 - AdwTabPage: the per-page object of an AdwTabView.  Mapped
+   onto <libadwaita-1/adw-tab-view.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwTabPage,
+   adw_tab_page_get_child, adw_tab_page_get_parent,
+   adw_tab_page_get_title, adw_tab_page_set_title,
+   adw_tab_page_get_tooltip, adw_tab_page_set_tooltip,
+   adw_tab_page_get_icon, adw_tab_page_set_icon,
+   adw_tab_page_get_loading, adw_tab_page_set_loading,
+   adw_tab_page_get_needs_attention,
+   adw_tab_page_set_needs_attention,
+   adw_tab_page_get_selected, adw_tab_page_get_pinned,
+   adw_tab_page_get_indicator_icon, adw_tab_page_set_indicator_icon,
+   adw_tab_page_get_indicator_tooltip,
+   adw_tab_page_set_indicator_tooltip,
+   adw_tab_page_get_indicator_activatable,
+   adw_tab_page_set_indicator_activatable,
+   adw_tab_page_get_live_thumbnail, adw_tab_page_set_live_thumbnail,
+   adw_tab_page_get_thumbnail_xalign, adw_tab_page_set_thumbnail_xalign,
+   adw_tab_page_get_thumbnail_yalign, adw_tab_page_set_thumbnail_yalign,
+   adw_tab_page_get_keyword, adw_tab_page_set_keyword,
+   adw_tab_page_invalidate_thumbnail;
+
+TYPE
+   AdwTabPage = ADDRESS;
+
+(* GtkWidget *adw_tab_page_get_child(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_child (self: AdwTabPage) : ADDRESS;
+
+(* AdwTabPage *adw_tab_page_get_parent(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_parent (self: AdwTabPage) : ADDRESS;
+
+(* const char *adw_tab_page_get_title(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_title (self: AdwTabPage) : ADDRESS;
+
+(* void adw_tab_page_set_title(AdwTabPage *self, const char *title) *)
+PROCEDURE adw_tab_page_set_title (self: AdwTabPage; title: ARRAY OF CHAR);
+
+(* const char *adw_tab_page_get_tooltip(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_tooltip (self: AdwTabPage) : ADDRESS;
+
+(* void adw_tab_page_set_tooltip(AdwTabPage *self, const char *tooltip) *)
+PROCEDURE adw_tab_page_set_tooltip (self: AdwTabPage;
+                                    tooltip: ARRAY OF CHAR);
+
+(* GIcon *adw_tab_page_get_icon(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_icon (self: AdwTabPage) : ADDRESS;
+
+(* void adw_tab_page_set_icon(AdwTabPage *self, GIcon *icon) *)
+PROCEDURE adw_tab_page_set_icon (self: AdwTabPage; icon: ADDRESS);
+
+(* gboolean adw_tab_page_get_loading(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_loading (self: AdwTabPage) : INTEGER;
+
+(* void adw_tab_page_set_loading(AdwTabPage *self, gboolean loading) *)
+PROCEDURE adw_tab_page_set_loading (self: AdwTabPage; loading: INTEGER);
+
+(* gboolean adw_tab_page_get_needs_attention(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_needs_attention (self: AdwTabPage) : INTEGER;
+
+(* void adw_tab_page_set_needs_attention(AdwTabPage *self,
+                                         gboolean needs_attention) *)
+PROCEDURE adw_tab_page_set_needs_attention (self: AdwTabPage;
+                                            needs_attention: INTEGER);
+
+(* gboolean adw_tab_page_get_selected(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_selected (self: AdwTabPage) : INTEGER;
+
+(* gboolean adw_tab_page_get_pinned(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_pinned (self: AdwTabPage) : INTEGER;
+
+(* GIcon *adw_tab_page_get_indicator_icon(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_indicator_icon (self: AdwTabPage) : ADDRESS;
+
+(* void adw_tab_page_set_indicator_icon(AdwTabPage *self, GIcon *icon) *)
+PROCEDURE adw_tab_page_set_indicator_icon (self: AdwTabPage;
+                                           indicator_icon: ADDRESS);
+
+(* const char *adw_tab_page_get_indicator_tooltip(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_indicator_tooltip (self: AdwTabPage) : ADDRESS;
+
+(* void adw_tab_page_set_indicator_tooltip(AdwTabPage *self,
+                                           const char *tooltip) *)
+PROCEDURE adw_tab_page_set_indicator_tooltip (self: AdwTabPage;
+                                              tooltip: ARRAY OF CHAR);
+
+(* gboolean adw_tab_page_get_indicator_activatable(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_indicator_activatable (self: AdwTabPage)
+                                                  : INTEGER;
+
+(* void adw_tab_page_set_indicator_activatable(AdwTabPage *self,
+                                               gboolean activatable) *)
+PROCEDURE adw_tab_page_set_indicator_activatable (self: AdwTabPage;
+                                                  activatable: INTEGER);
+
+(* gboolean adw_tab_page_get_live_thumbnail(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_live_thumbnail (self: AdwTabPage) : INTEGER;
+
+(* void adw_tab_page_set_live_thumbnail(AdwTabPage *self,
+                                        gboolean live_thumbnail) *)
+PROCEDURE adw_tab_page_set_live_thumbnail (self: AdwTabPage;
+                                           live_thumbnail: INTEGER);
+
+(* float adw_tab_page_get_thumbnail_xalign(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_thumbnail_xalign (self: AdwTabPage) : SHORTREAL;
+
+(* void adw_tab_page_set_thumbnail_xalign(AdwTabPage *self, float xalign) *)
+PROCEDURE adw_tab_page_set_thumbnail_xalign (self: AdwTabPage;
+                                             xalign: SHORTREAL);
+
+(* float adw_tab_page_get_thumbnail_yalign(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_thumbnail_yalign (self: AdwTabPage) : SHORTREAL;
+
+(* void adw_tab_page_set_thumbnail_yalign(AdwTabPage *self, float yalign) *)
+PROCEDURE adw_tab_page_set_thumbnail_yalign (self: AdwTabPage;
+                                             yalign: SHORTREAL);
+
+(* const char *adw_tab_page_get_keyword(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_get_keyword (self: AdwTabPage) : ADDRESS;
+
+(* void adw_tab_page_set_keyword(AdwTabPage *self, const char *keyword) *)
+PROCEDURE adw_tab_page_set_keyword (self: AdwTabPage;
+                                    keyword: ARRAY OF CHAR);
+
+(* void adw_tab_page_invalidate_thumbnail(AdwTabPage *self) *)
+PROCEDURE adw_tab_page_invalidate_thumbnail (self: AdwTabPage);
+
+END AdwTabPage.

src/AdwTabView.def

@@ -0,0 +1,191 @@
+DEFINITION MODULE FOR "C" AdwTabView ;
+
+(*
+   m2-GTK4 - AdwTabView: a dynamic tab container.  Mapped onto
+   <libadwaita-1/adw-tab-view.h>.
+
+   Pages are AdwTabPage objects, created by add_page()/append()/insert()
+   and friends.  The shortcuts bitmask takes the ADW_TAB_VIEW_SHORTCUT_*
+   values from AdwEnums.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwTabView,
+   adw_tab_view_new,
+   adw_tab_view_add_page, adw_tab_view_insert, adw_tab_view_append,
+   adw_tab_view_prepend,
+   adw_tab_view_insert_pinned, adw_tab_view_append_pinned,
+   adw_tab_view_prepend_pinned,
+   adw_tab_view_close_page, adw_tab_view_close_page_finish,
+   adw_tab_view_close_other_pages,
+   adw_tab_view_close_pages_before, adw_tab_view_close_pages_after,
+   adw_tab_view_get_n_pages, adw_tab_view_get_n_pinned_pages,
+   adw_tab_view_get_nth_page, adw_tab_view_get_page,
+   adw_tab_view_get_page_position, adw_tab_view_get_pages,
+   adw_tab_view_get_selected_page, adw_tab_view_set_selected_page,
+   adw_tab_view_get_default_icon, adw_tab_view_set_default_icon,
+   adw_tab_view_get_menu_model, adw_tab_view_set_menu_model,
+   adw_tab_view_get_shortcuts, adw_tab_view_set_shortcuts,
+   adw_tab_view_add_shortcuts, adw_tab_view_remove_shortcuts,
+   adw_tab_view_set_page_pinned,
+   adw_tab_view_get_is_transferring_page,
+   adw_tab_view_reorder_backward, adw_tab_view_reorder_forward,
+   adw_tab_view_reorder_first, adw_tab_view_reorder_last,
+   adw_tab_view_reorder_page,
+   adw_tab_view_select_next_page, adw_tab_view_select_previous_page,
+   adw_tab_view_transfer_page, adw_tab_view_invalidate_thumbnails;
+
+TYPE
+   AdwTabView = ADDRESS;
+
+(* AdwTabView *adw_tab_view_new(void) *)
+PROCEDURE adw_tab_view_new () : AdwTabView;
+
+(* AdwTabPage *adw_tab_view_add_page(AdwTabView *self, GtkWidget *child,
+                                     AdwTabPage *parent) *)
+PROCEDURE adw_tab_view_add_page (self: AdwTabView; child, parent: ADDRESS)
+                                 : ADDRESS;
+
+(* AdwTabPage *adw_tab_view_insert(AdwTabView *self, GtkWidget *child,
+                                    int position) *)
+PROCEDURE adw_tab_view_insert (self: AdwTabView; child: ADDRESS;
+                               position: INTEGER) : ADDRESS;
+
+(* AdwTabPage *adw_tab_view_append(AdwTabView *self, GtkWidget *child) *)
+PROCEDURE adw_tab_view_append (self: AdwTabView; child: ADDRESS) : ADDRESS;
+
+(* AdwTabPage *adw_tab_view_prepend(AdwTabView *self, GtkWidget *child) *)
+PROCEDURE adw_tab_view_prepend (self: AdwTabView; child: ADDRESS) : ADDRESS;
+
+(* AdwTabPage *adw_tab_view_insert_pinned(AdwTabView *self, GtkWidget *child,
+                                           int position) *)
+PROCEDURE adw_tab_view_insert_pinned (self: AdwTabView; child: ADDRESS;
+                                      position: INTEGER) : ADDRESS;
+
+(* AdwTabPage *adw_tab_view_append_pinned(AdwTabView *self, GtkWidget *child) *)
+PROCEDURE adw_tab_view_append_pinned (self: AdwTabView; child: ADDRESS)
+                                      : ADDRESS;
+
+(* AdwTabPage *adw_tab_view_prepend_pinned(AdwTabView *self, GtkWidget *child) *)
+PROCEDURE adw_tab_view_prepend_pinned (self: AdwTabView; child: ADDRESS)
+                                       : ADDRESS;
+
+(* void adw_tab_view_close_page(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_close_page (self: AdwTabView; page: ADDRESS);
+
+(* void adw_tab_view_close_page_finish(AdwTabView *self, AdwTabPage *page,
+                                       gboolean confirm) *)
+PROCEDURE adw_tab_view_close_page_finish (self: AdwTabView; page: ADDRESS;
+                                          confirm: INTEGER);
+
+(* void adw_tab_view_close_other_pages(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_close_other_pages (self: AdwTabView; page: ADDRESS);
+
+(* void adw_tab_view_close_pages_before(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_close_pages_before (self: AdwTabView; page: ADDRESS);
+
+(* void adw_tab_view_close_pages_after(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_close_pages_after (self: AdwTabView; page: ADDRESS);
+
+(* int adw_tab_view_get_n_pages(AdwTabView *self) *)
+PROCEDURE adw_tab_view_get_n_pages (self: AdwTabView) : INTEGER;
+
+(* int adw_tab_view_get_n_pinned_pages(AdwTabView *self) *)
+PROCEDURE adw_tab_view_get_n_pinned_pages (self: AdwTabView) : INTEGER;
+
+(* AdwTabPage *adw_tab_view_get_nth_page(AdwTabView *self, int position) *)
+PROCEDURE adw_tab_view_get_nth_page (self: AdwTabView; position: INTEGER)
+                                     : ADDRESS;
+
+(* AdwTabPage *adw_tab_view_get_page(AdwTabView *self, GtkWidget *child) *)
+PROCEDURE adw_tab_view_get_page (self: AdwTabView; child: ADDRESS) : ADDRESS;
+
+(* int adw_tab_view_get_page_position(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_get_page_position (self: AdwTabView; page: ADDRESS)
+                                          : INTEGER;
+
+(* GtkSelectionModel *adw_tab_view_get_pages(AdwTabView *self) *)
+PROCEDURE adw_tab_view_get_pages (self: AdwTabView) : ADDRESS;
+
+(* AdwTabPage *adw_tab_view_get_selected_page(AdwTabView *self) *)
+PROCEDURE adw_tab_view_get_selected_page (self: AdwTabView) : ADDRESS;
+
+(* void adw_tab_view_set_selected_page(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_set_selected_page (self: AdwTabView; page: ADDRESS);
+
+(* GIcon *adw_tab_view_get_default_icon(AdwTabView *self) *)
+PROCEDURE adw_tab_view_get_default_icon (self: AdwTabView) : ADDRESS;
+
+(* void adw_tab_view_set_default_icon(AdwTabView *self, GIcon *default_icon) *)
+PROCEDURE adw_tab_view_set_default_icon (self: AdwTabView;
+                                         default_icon: ADDRESS);
+
+(* GMenuModel *adw_tab_view_get_menu_model(AdwTabView *self) *)
+PROCEDURE adw_tab_view_get_menu_model (self: AdwTabView) : ADDRESS;
+
+(* void adw_tab_view_set_menu_model(AdwTabView *self, GMenuModel *menu_model) *)
+PROCEDURE adw_tab_view_set_menu_model (self: AdwTabView; menu_model: ADDRESS);
+
+(* AdwTabViewShortcuts adw_tab_view_get_shortcuts(AdwTabView *self) *)
+PROCEDURE adw_tab_view_get_shortcuts (self: AdwTabView) : CARDINAL;
+
+(* void adw_tab_view_set_shortcuts(AdwTabView *self,
+                                    AdwTabViewShortcuts shortcuts) *)
+PROCEDURE adw_tab_view_set_shortcuts (self: AdwTabView; shortcuts: CARDINAL);
+
+(* void adw_tab_view_add_shortcuts(AdwTabView *self,
+                                    AdwTabViewShortcuts shortcuts) *)
+PROCEDURE adw_tab_view_add_shortcuts (self: AdwTabView; shortcuts: CARDINAL);
+
+(* void adw_tab_view_remove_shortcuts(AdwTabView *self,
+                                       AdwTabViewShortcuts shortcuts) *)
+PROCEDURE adw_tab_view_remove_shortcuts (self: AdwTabView;
+                                         shortcuts: CARDINAL);
+
+(* void adw_tab_view_set_page_pinned(AdwTabView *self, AdwTabPage *page,
+                                      gboolean pinned) *)
+PROCEDURE adw_tab_view_set_page_pinned (self: AdwTabView; page: ADDRESS;
+                                        pinned: INTEGER);
+
+(* gboolean adw_tab_view_get_is_transferring_page(AdwTabView *self) *)
+PROCEDURE adw_tab_view_get_is_transferring_page (self: AdwTabView) : INTEGER;
+
+(* gboolean adw_tab_view_reorder_backward(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_reorder_backward (self: AdwTabView; page: ADDRESS)
+                                         : INTEGER;
+
+(* gboolean adw_tab_view_reorder_forward(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_reorder_forward (self: AdwTabView; page: ADDRESS)
+                                        : INTEGER;
+
+(* gboolean adw_tab_view_reorder_first(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_reorder_first (self: AdwTabView; page: ADDRESS)
+                                      : INTEGER;
+
+(* gboolean adw_tab_view_reorder_last(AdwTabView *self, AdwTabPage *page) *)
+PROCEDURE adw_tab_view_reorder_last (self: AdwTabView; page: ADDRESS)
+                                     : INTEGER;
+
+(* gboolean adw_tab_view_reorder_page(AdwTabView *self, AdwTabPage *page,
+                                       int position) *)
+PROCEDURE adw_tab_view_reorder_page (self: AdwTabView; page: ADDRESS;
+                                     position: INTEGER) : INTEGER;
+
+(* gboolean adw_tab_view_select_next_page(AdwTabView *self) *)
+PROCEDURE adw_tab_view_select_next_page (self: AdwTabView) : INTEGER;
+
+(* gboolean adw_tab_view_select_previous_page(AdwTabView *self) *)
+PROCEDURE adw_tab_view_select_previous_page (self: AdwTabView) : INTEGER;
+
+(* void adw_tab_view_transfer_page(AdwTabView *self, AdwTabPage *page,
+                                    AdwTabView *other_view, int position) *)
+PROCEDURE adw_tab_view_transfer_page (self: AdwTabView; page: ADDRESS;
+                                      other_view: ADDRESS;
+                                      position: INTEGER);
+
+(* void adw_tab_view_invalidate_thumbnails(AdwTabView *self) *)
+PROCEDURE adw_tab_view_invalidate_thumbnails (self: AdwTabView);
+
+END AdwTabView.

src/AdwTimedAnimation.def

@@ -0,0 +1,96 @@
+DEFINITION MODULE FOR "C" AdwTimedAnimation ;
+
+(*
+   m2-GTK4 - AdwTimedAnimation: a value animation over a fixed duration
+   with an easing curve.  Mapped onto
+   <libadwaita-1/adw-timed-animation.h>.
+
+   The easing uses the AdwEasing values from AdwEnums.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+FROM AdwEnums IMPORT AdwEasing;
+
+EXPORT UNQUALIFIED
+   AdwTimedAnimation,
+   adw_timed_animation_new,
+   adw_timed_animation_get_value_from, adw_timed_animation_set_value_from,
+   adw_timed_animation_get_value_to, adw_timed_animation_set_value_to,
+   adw_timed_animation_get_duration, adw_timed_animation_set_duration,
+   adw_timed_animation_get_easing, adw_timed_animation_set_easing,
+   adw_timed_animation_get_repeat_count,
+   adw_timed_animation_set_repeat_count,
+   adw_timed_animation_get_alternate, adw_timed_animation_set_alternate,
+   adw_timed_animation_get_reverse, adw_timed_animation_set_reverse;
+
+TYPE
+   AdwTimedAnimation = ADDRESS;
+
+(* AdwAnimation *adw_timed_animation_new(GtkWidget *widget, double from,
+                                          double to, guint duration,
+                                          AdwAnimationTarget *target) *)
+PROCEDURE adw_timed_animation_new (widget: ADDRESS; valueFrom, valueTo: REAL;
+                                   duration: CARDINAL; target: ADDRESS)
+                                  : AdwTimedAnimation;
+
+(* double adw_timed_animation_get_value_from(AdwTimedAnimation *self) *)
+PROCEDURE adw_timed_animation_get_value_from (self: AdwTimedAnimation)
+                                              : REAL;
+
+(* void adw_timed_animation_set_value_from(AdwTimedAnimation *self,
+                                            double value) *)
+PROCEDURE adw_timed_animation_set_value_from (self: AdwTimedAnimation;
+                                              value: REAL);
+
+(* double adw_timed_animation_get_value_to(AdwTimedAnimation *self) *)
+PROCEDURE adw_timed_animation_get_value_to (self: AdwTimedAnimation) : REAL;
+
+(* void adw_timed_animation_set_value_to(AdwTimedAnimation *self,
+                                          double value) *)
+PROCEDURE adw_timed_animation_set_value_to (self: AdwTimedAnimation;
+                                            value: REAL);
+
+(* guint adw_timed_animation_get_duration(AdwTimedAnimation *self) *)
+PROCEDURE adw_timed_animation_get_duration (self: AdwTimedAnimation)
+                                            : CARDINAL;
+
+(* void adw_timed_animation_set_duration(AdwTimedAnimation *self,
+                                          guint duration) *)
+PROCEDURE adw_timed_animation_set_duration (self: AdwTimedAnimation;
+                                            duration: CARDINAL);
+
+(* AdwEasing adw_timed_animation_get_easing(AdwTimedAnimation *self) *)
+PROCEDURE adw_timed_animation_get_easing (self: AdwTimedAnimation) : AdwEasing;
+
+(* void adw_timed_animation_set_easing(AdwTimedAnimation *self,
+                                        AdwEasing easing) *)
+PROCEDURE adw_timed_animation_set_easing (self: AdwTimedAnimation;
+                                          easing: AdwEasing);
+
+(* guint adw_timed_animation_get_repeat_count(AdwTimedAnimation *self) *)
+PROCEDURE adw_timed_animation_get_repeat_count (self: AdwTimedAnimation)
+                                                : CARDINAL;
+
+(* void adw_timed_animation_set_repeat_count(AdwTimedAnimation *self,
+                                              guint repeat_count) *)
+PROCEDURE adw_timed_animation_set_repeat_count (self: AdwTimedAnimation;
+                                                repeat_count: CARDINAL);
+
+(* gboolean adw_timed_animation_get_alternate(AdwTimedAnimation *self) *)
+PROCEDURE adw_timed_animation_get_alternate (self: AdwTimedAnimation)
+                                             : INTEGER;
+
+(* void adw_timed_animation_set_alternate(AdwTimedAnimation *self,
+                                           gboolean alternate) *)
+PROCEDURE adw_timed_animation_set_alternate (self: AdwTimedAnimation;
+                                             alternate: INTEGER);
+
+(* gboolean adw_timed_animation_get_reverse(AdwTimedAnimation *self) *)
+PROCEDURE adw_timed_animation_get_reverse (self: AdwTimedAnimation) : INTEGER;
+
+(* void adw_timed_animation_set_reverse(AdwTimedAnimation *self,
+                                         gboolean reverse) *)
+PROCEDURE adw_timed_animation_set_reverse (self: AdwTimedAnimation;
+                                           reverse: INTEGER);
+
+END AdwTimedAnimation.

src/AdwToggle.def

@@ -0,0 +1,75 @@
+DEFINITION MODULE FOR "C" AdwToggle ;
+
+(*
+   m2-GTK4 - AdwToggle: a single toggle inside an AdwToggleGroup.
+   Mapped onto <libadwaita-1/adw-toggle-group.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwToggle,
+   adw_toggle_new,
+   adw_toggle_get_child, adw_toggle_set_child,
+   adw_toggle_get_icon_name, adw_toggle_set_icon_name,
+   adw_toggle_get_label, adw_toggle_set_label,
+   adw_toggle_get_name, adw_toggle_set_name,
+   adw_toggle_get_tooltip, adw_toggle_set_tooltip,
+   adw_toggle_get_use_underline, adw_toggle_set_use_underline,
+   adw_toggle_get_enabled, adw_toggle_set_enabled,
+   adw_toggle_get_index;
+
+TYPE
+   AdwToggle = ADDRESS;
+
+(* GtkWidget *adw_toggle_new(void) *)
+PROCEDURE adw_toggle_new () : AdwToggle;
+
+(* GtkWidget *adw_toggle_get_child(AdwToggle *self) *)
+PROCEDURE adw_toggle_get_child (self: AdwToggle) : ADDRESS;
+
+(* void adw_toggle_set_child(AdwToggle *self, GtkWidget *child) *)
+PROCEDURE adw_toggle_set_child (self: AdwToggle; child: ADDRESS);
+
+(* const char *adw_toggle_get_icon_name(AdwToggle *self) *)
+PROCEDURE adw_toggle_get_icon_name (self: AdwToggle) : ADDRESS;
+
+(* void adw_toggle_set_icon_name(AdwToggle *self, const char *icon_name) *)
+PROCEDURE adw_toggle_set_icon_name (self: AdwToggle;
+                                    icon_name: ARRAY OF CHAR);
+
+(* const char *adw_toggle_get_label(AdwToggle *self) *)
+PROCEDURE adw_toggle_get_label (self: AdwToggle) : ADDRESS;
+
+(* void adw_toggle_set_label(AdwToggle *self, const char *label) *)
+PROCEDURE adw_toggle_set_label (self: AdwToggle; label: ARRAY OF CHAR);
+
+(* const char *adw_toggle_get_name(AdwToggle *self) *)
+PROCEDURE adw_toggle_get_name (self: AdwToggle) : ADDRESS;
+
+(* void adw_toggle_set_name(AdwToggle *self, const char *name) *)
+PROCEDURE adw_toggle_set_name (self: AdwToggle; name: ARRAY OF CHAR);
+
+(* const char *adw_toggle_get_tooltip(AdwToggle *self) *)
+PROCEDURE adw_toggle_get_tooltip (self: AdwToggle) : ADDRESS;
+
+(* void adw_toggle_set_tooltip(AdwToggle *self, const char *tooltip) *)
+PROCEDURE adw_toggle_set_tooltip (self: AdwToggle; tooltip: ARRAY OF CHAR);
+
+(* gboolean adw_toggle_get_use_underline(AdwToggle *self) *)
+PROCEDURE adw_toggle_get_use_underline (self: AdwToggle) : INTEGER;
+
+(* void adw_toggle_set_use_underline(AdwToggle *self, gboolean use_underline) *)
+PROCEDURE adw_toggle_set_use_underline (self: AdwToggle;
+                                        use_underline: INTEGER);
+
+(* gboolean adw_toggle_get_enabled(AdwToggle *self) *)
+PROCEDURE adw_toggle_get_enabled (self: AdwToggle) : INTEGER;
+
+(* void adw_toggle_set_enabled(AdwToggle *self, gboolean enabled) *)
+PROCEDURE adw_toggle_set_enabled (self: AdwToggle; enabled: INTEGER);
+
+(* guint adw_toggle_get_index(AdwToggle *self) *)
+PROCEDURE adw_toggle_get_index (self: AdwToggle) : CARDINAL;
+
+END AdwToggle.

src/AdwToggleGroup.def

@@ -0,0 +1,82 @@
+DEFINITION MODULE FOR "C" AdwToggleGroup ;
+
+(*
+   m2-GTK4 - AdwToggleGroup: a group of mutually exclusive AdwToggles.
+   Mapped onto <libadwaita-1/adw-toggle-group.h>.
+*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+EXPORT UNQUALIFIED
+   AdwToggleGroup,
+   adw_toggle_group_new,
+   adw_toggle_group_add, adw_toggle_group_remove,
+   adw_toggle_group_remove_all,
+   adw_toggle_group_get_n_toggles, adw_toggle_group_get_toggle,
+   adw_toggle_group_get_toggle_by_name, adw_toggle_group_get_toggles,
+   adw_toggle_group_get_active, adw_toggle_group_set_active,
+   adw_toggle_group_get_active_name, adw_toggle_group_set_active_name,
+   adw_toggle_group_get_homogeneous, adw_toggle_group_set_homogeneous,
+   adw_toggle_group_get_can_shrink, adw_toggle_group_set_can_shrink;
+
+TYPE
+   AdwToggleGroup = ADDRESS;
+
+(* GtkWidget *adw_toggle_group_new(void) *)
+PROCEDURE adw_toggle_group_new () : AdwToggleGroup;
+
+(* void adw_toggle_group_add(AdwToggleGroup *self, AdwToggle *toggle) *)
+PROCEDURE adw_toggle_group_add (self: AdwToggleGroup; toggle: ADDRESS);
+
+(* void adw_toggle_group_remove(AdwToggleGroup *self, AdwToggle *toggle) *)
+PROCEDURE adw_toggle_group_remove (self: AdwToggleGroup; toggle: ADDRESS);
+
+(* void adw_toggle_group_remove_all(AdwToggleGroup *self) *)
+PROCEDURE adw_toggle_group_remove_all (self: AdwToggleGroup);
+
+(* guint adw_toggle_group_get_n_toggles(AdwToggleGroup *self) *)
+PROCEDURE adw_toggle_group_get_n_toggles (self: AdwToggleGroup) : CARDINAL;
+
+(* AdwToggle *adw_toggle_group_get_toggle(AdwToggleGroup *self, guint index) *)
+PROCEDURE adw_toggle_group_get_toggle (self: AdwToggleGroup; index: CARDINAL)
+                                       : ADDRESS;
+
+(* AdwToggle *adw_toggle_group_get_toggle_by_name(AdwToggleGroup *self,
+                                                   const char *name) *)
+PROCEDURE adw_toggle_group_get_toggle_by_name (self: AdwToggleGroup;
+                                               name: ARRAY OF CHAR) : ADDRESS;
+
+(* GtkSelectionModel *adw_toggle_group_get_toggles(AdwToggleGroup *self) *)
+PROCEDURE adw_toggle_group_get_toggles (self: AdwToggleGroup) : ADDRESS;
+
+(* guint adw_toggle_group_get_active(AdwToggleGroup *self) *)
+PROCEDURE adw_toggle_group_get_active (self: AdwToggleGroup) : CARDINAL;
+
+(* void adw_toggle_group_set_active(AdwToggleGroup *self, guint active) *)
+PROCEDURE adw_toggle_group_set_active (self: AdwToggleGroup; active: CARDINAL);
+
+(* const char *adw_toggle_group_get_active_name(AdwToggleGroup *self) *)
+PROCEDURE adw_toggle_group_get_active_name (self: AdwToggleGroup) : ADDRESS;
+
+(* void adw_toggle_group_set_active_name(AdwToggleGroup *self,
+                                         const char *name) *)
+PROCEDURE adw_toggle_group_set_active_name (self: AdwToggleGroup;
+                                            name: ARRAY OF CHAR);
+
+(* gboolean adw_toggle_group_get_homogeneous(AdwToggleGroup *self) *)
+PROCEDURE adw_toggle_group_get_homogeneous (self: AdwToggleGroup) : INTEGER;
+
+(* void adw_toggle_group_set_homogeneous(AdwToggleGroup *self,
+                                         gboolean homogeneous) *)
+PROCEDURE adw_toggle_group_set_homogeneous (self: AdwToggleGroup;
+                                            homogeneous: INTEGER);
+
+(* gboolean adw_toggle_group_get_can_shrink(AdwToggleGroup *self) *)
+PROCEDURE adw_toggle_group_get_can_shrink (self: AdwToggleGroup) : INTEGER;
+
+(* void adw_toggle_group_set_can_shrink(AdwToggleGroup *self,
+                                        gboolean can_shrink) *)
+PROCEDURE adw_toggle_group_set_can_shrink (self: AdwToggleGroup;
+                                           can_shrink: INTEGER);
+
+END AdwToggleGroup.

tests/run_tests.sh

@@ -17,7 +17,7 @@ TESTS="test_glib test_version test_widgets test_inputs test_inputs2 test_contain
 if pkg-config --exists libadwaita-1 2>/dev/null; then
   CFLAGS="$CFLAGS $(pkg-config --cflags libadwaita-1)"
   LIBS="$LIBS $(pkg-config --libs libadwaita-1)"
-  TESTS="$TESTS test_adw test_adw_widgets"
+  TESTS="$TESTS test_adw test_adw_widgets test_adw_widgets2"
 fi
 
 # OpenGL (GtkGLArea examples/tests).
@@ -63,7 +63,7 @@ for t in $TESTS; do
        "$ROOT/tests/$t.mod" "$OBJ/GtkUtils.o" "$OBJ/GtkClosures.o" \
        "$OBJ/m2gtkshim.o" $DEMO_OBJS -o "$BIN/$t" $LIBS
   case "$t" in
-    test_widgets|test_inputs|test_inputs2|test_containers|test_containers2|test_actions|test_closure|test_headerbar|test_filedialog|test_views|test_builder|test_utility|test_css|test_popover|test_dialogs|test_models|test_drawing|test_gestures|test_models2|test_widgets3|test_shim|test_shim2|test_shim3|test_dnd|test_media|test_gl|test_print|test_text|test_expr|test_constraints|test_shortcuts|test_snapshot|test_lastwidgets|test_adw|test_application|test_demos|test_adw_widgets) needs_display=1 ;;
+    test_widgets|test_inputs|test_inputs2|test_containers|test_containers2|test_actions|test_closure|test_headerbar|test_filedialog|test_views|test_builder|test_utility|test_css|test_popover|test_dialogs|test_models|test_drawing|test_gestures|test_models2|test_widgets3|test_shim|test_shim2|test_shim3|test_dnd|test_media|test_gl|test_print|test_text|test_expr|test_constraints|test_shortcuts|test_snapshot|test_lastwidgets|test_adw|test_application|test_demos|test_adw_widgets|test_adw_widgets2) needs_display=1 ;;
     *) needs_display=0 ;;
   esac
   if [ "$needs_display" = 1 ] && [ -z "$DISPLAY" ] && [ -z "$WAYLAND_DISPLAY" ]; then

tests/test_adw_widgets2.mod

@@ -0,0 +1,278 @@
+MODULE test_adw_widgets2 ;
+
+(*
+   m2-GTK4 test - the second batch of libadwaita (GNOME) widgets:
+   dialogs, tabs, carousel, toggles, adaptive views, breakpoints, style
+   manager, swipe tracker and animations.  Requires a display.
+*)
+
+FROM GtkApplication IMPORT gtk_application_new;
+FROM Gio IMPORT g_application_run, g_application_quit;
+FROM GtkWindow IMPORT gtk_application_window_new, gtk_window_set_child,
+   gtk_window_present;
+FROM GtkBox IMPORT gtk_box_new, gtk_box_append;
+FROM GtkLabel IMPORT gtk_label_new;
+FROM GtkEnums IMPORT GtkVertical;
+FROM GtkUtils IMPORT Connect;
+FROM AdwDialog IMPORT adw_dialog_new, adw_dialog_set_child,
+   adw_dialog_set_title, adw_dialog_get_title;
+FROM AdwAlertDialog IMPORT adw_alert_dialog_new,
+   adw_alert_dialog_add_response, adw_alert_dialog_has_response;
+FROM AdwAboutDialog IMPORT adw_about_dialog_new,
+   adw_about_dialog_set_application_name;
+FROM AdwPreferencesDialog IMPORT adw_preferences_dialog_new,
+   adw_preferences_dialog_add;
+FROM AdwPreferencesWindow IMPORT adw_preferences_window_new,
+   adw_preferences_window_add;
+FROM AdwPreferencesPage IMPORT adw_preferences_page_new;
+FROM AdwTabView IMPORT adw_tab_view_new, adw_tab_view_append,
+   adw_tab_view_get_n_pages, adw_tab_view_get_nth_page,
+   adw_tab_view_set_shortcuts, adw_tab_view_get_shortcuts;
+FROM AdwTabBar IMPORT adw_tab_bar_new, adw_tab_bar_set_view;
+FROM AdwTabButton IMPORT adw_tab_button_new, adw_tab_button_set_view;
+FROM AdwTabOverview IMPORT adw_tab_overview_new, adw_tab_overview_set_view;
+FROM AdwCarousel IMPORT adw_carousel_new, adw_carousel_append,
+   adw_carousel_get_n_pages;
+FROM AdwCarouselIndicatorDots IMPORT adw_carousel_indicator_dots_new,
+   adw_carousel_indicator_dots_set_carousel;
+FROM AdwCarouselIndicatorLines IMPORT adw_carousel_indicator_lines_new,
+   adw_carousel_indicator_lines_set_carousel;
+FROM AdwToggle IMPORT adw_toggle_new, adw_toggle_set_label;
+FROM AdwToggleGroup IMPORT adw_toggle_group_new, adw_toggle_group_add,
+   adw_toggle_group_get_n_toggles;
+FROM AdwFlap IMPORT adw_flap_new, adw_flap_set_content, adw_flap_set_flap;
+FROM AdwLeaflet IMPORT adw_leaflet_new, adw_leaflet_append;
+FROM AdwOverlaySplitView IMPORT adw_overlay_split_view_new,
+   adw_overlay_split_view_set_content, adw_overlay_split_view_set_sidebar;
+FROM AdwNavigationSplitView IMPORT adw_navigation_split_view_new,
+   adw_navigation_split_view_set_content,
+   adw_navigation_split_view_set_sidebar;
+FROM AdwNavigationPage IMPORT adw_navigation_page_new;
+FROM AdwBottomSheet IMPORT adw_bottom_sheet_new,
+   adw_bottom_sheet_set_content, adw_bottom_sheet_set_sheet;
+FROM AdwBreakpoint IMPORT adw_breakpoint_new, adw_breakpoint_get_condition;
+FROM AdwBreakpointCondition IMPORT adw_breakpoint_condition_parse;
+FROM AdwMultiLayoutView IMPORT adw_multi_layout_view_new,
+   adw_multi_layout_view_add_layout, adw_multi_layout_view_set_child;
+FROM AdwLayout IMPORT adw_layout_new, adw_layout_set_name;
+FROM AdwLayoutSlot IMPORT adw_layout_slot_new;
+FROM AdwStyleManager IMPORT adw_style_manager_get_default,
+   adw_style_manager_set_color_scheme, adw_style_manager_get_color_scheme;
+FROM AdwEnums IMPORT AdwColorSchemePreferDark, AdwColorSchemePreferLight,
+   AdwTabViewShortcutAll, AdwEasingEaseInOut;
+FROM AdwSwipeTracker IMPORT adw_swipe_tracker_new;
+FROM AdwSpringParams IMPORT adw_spring_params_new;
+FROM AdwTimedAnimation IMPORT adw_timed_animation_new,
+   adw_timed_animation_set_easing;
+FROM AdwSpringAnimation IMPORT adw_spring_animation_new;
+FROM AdwPropertyAnimationTarget IMPORT adw_property_animation_target_new;
+FROM AdwCallbackAnimationTarget IMPORT adw_callback_animation_target_new;
+FROM AdwAnimation IMPORT adw_animation_get_widget;
+FROM SYSTEM IMPORT ADDRESS, ADR;
+FROM libc IMPORT printf;
+
+CONST
+   AppId = "org.example.m2gtk4.TestAdwWidgets2";
+
+VAR
+   app: ADDRESS;
+   passed: BOOLEAN;
+   failures: INTEGER;
+
+PROCEDURE Check (cond: BOOLEAN; what: ARRAY OF CHAR);
+BEGIN
+   IF cond THEN
+      printf("  ok - %s\n", what)
+   ELSE
+      printf("  NOT OK - %s\n", what);
+      INC(failures)
+   END
+END Check;
+
+(* void on_anim_value(double value, gpointer user_data) *)
+PROCEDURE OnAnimValue (value: REAL; user: ADDRESS);
+BEGIN
+END OnAnimValue;
+
+PROCEDURE OnActivate (application: ADDRESS; data: ADDRESS);
+VAR
+   window, box: ADDRESS;
+   dialog, alert, about, prefdlg, prefwin, page: ADDRESS;
+   tabview, tabbar, tabbtn, tabover, tabpage, label: ADDRESS;
+   carousel, dots, lines: ADDRESS;
+   tg, toggle: ADDRESS;
+   flap, leaflet, osplit, nsplit, sheet: ADDRESS;
+   cond, bp, mlv, layout, slot: ADDRESS;
+   sm, tracker, spring: ADDRESS;
+   target, anim: ADDRESS;
+BEGIN
+   failures := 0;
+
+   window := gtk_application_window_new(application);
+
+   (* dialogs *)
+   dialog := adw_dialog_new();
+   adw_dialog_set_title (dialog, "A dialog");
+   adw_dialog_set_child (dialog, gtk_label_new("content"));
+   Check(adw_dialog_get_title (dialog) # NIL, "AdwDialog");
+
+   alert := adw_alert_dialog_new ("Heading", "Body");
+   adw_alert_dialog_add_response (alert, "ok", "OK");
+   Check(adw_alert_dialog_has_response (alert, "ok") # 0,
+         "AdwAlertDialog response");
+
+   about := adw_about_dialog_new();
+   adw_about_dialog_set_application_name (about, "m2-GTK4");
+   Check(about # NIL, "AdwAboutDialog");
+
+   page := adw_preferences_page_new();
+   prefdlg := adw_preferences_dialog_new();
+   adw_preferences_dialog_add (prefdlg, page);
+   Check(prefdlg # NIL, "AdwPreferencesDialog");
+
+   prefwin := adw_preferences_window_new();
+   adw_preferences_window_add (prefwin, adw_preferences_page_new());
+   Check(prefwin # NIL, "AdwPreferencesWindow");
+
+   (* tabs *)
+   tabview := adw_tab_view_new();
+   label := gtk_label_new("Page 1");
+   tabpage := adw_tab_view_append (tabview, label);
+   label := gtk_label_new("Page 2");
+   tabpage := adw_tab_view_append (tabview, label);
+   Check(adw_tab_view_get_n_pages (tabview) = 2, "AdwTabView pages");
+   Check(adw_tab_view_get_nth_page (tabview, 1) # NIL, "AdwTabView nth page");
+   adw_tab_view_set_shortcuts (tabview, AdwTabViewShortcutAll);
+   Check(adw_tab_view_get_shortcuts (tabview) # 0, "AdwTabView shortcuts");
+
+   tabbar := adw_tab_bar_new();
+   adw_tab_bar_set_view (tabbar, tabview);
+   Check(tabbar # NIL, "AdwTabBar");
+
+   tabbtn := adw_tab_button_new();
+   adw_tab_button_set_view (tabbtn, tabview);
+   Check(tabbtn # NIL, "AdwTabButton");
+
+   tabover := adw_tab_overview_new();
+   adw_tab_overview_set_view (tabover, tabview);
+   Check(tabover # NIL, "AdwTabOverview");
+
+   (* carousel *)
+   carousel := adw_carousel_new();
+   adw_carousel_append (carousel, gtk_label_new("One"));
+   adw_carousel_append (carousel, gtk_label_new("Two"));
+   Check(adw_carousel_get_n_pages (carousel) = 2, "AdwCarousel pages");
+
+   dots := adw_carousel_indicator_dots_new();
+   adw_carousel_indicator_dots_set_carousel (dots, carousel);
+   lines := adw_carousel_indicator_lines_new();
+   adw_carousel_indicator_lines_set_carousel (lines, carousel);
+   Check((dots # NIL) AND (lines # NIL), "AdwCarousel indicators");
+
+   (* toggles *)
+   tg := adw_toggle_group_new();
+   toggle := adw_toggle_new();
+   adw_toggle_set_label (toggle, "One");
+   adw_toggle_group_add (tg, toggle);
+   toggle := adw_toggle_new();
+   adw_toggle_set_label (toggle, "Two");
+   adw_toggle_group_add (tg, toggle);
+   Check(adw_toggle_group_get_n_toggles (tg) = 2, "AdwToggleGroup toggles");
+
+   (* adaptive views *)
+   flap := adw_flap_new();
+   adw_flap_set_content (flap, gtk_label_new("content"));
+   adw_flap_set_flap (flap, gtk_label_new("flap"));
+   Check(flap # NIL, "AdwFlap");
+
+   leaflet := adw_leaflet_new();
+   page := adw_leaflet_append (leaflet, gtk_label_new("page"));
+   page := adw_leaflet_append (leaflet, gtk_label_new("page2"));
+   Check(leaflet # NIL, "AdwLeaflet");
+
+   osplit := adw_overlay_split_view_new();
+   adw_overlay_split_view_set_sidebar (osplit, gtk_label_new("sidebar"));
+   adw_overlay_split_view_set_content (osplit, gtk_label_new("content"));
+   Check(osplit # NIL, "AdwOverlaySplitView");
+
+   nsplit := adw_navigation_split_view_new();
+   adw_navigation_split_view_set_sidebar
+      (nsplit, adw_navigation_page_new (gtk_label_new("sidebar"), "Side"));
+   adw_navigation_split_view_set_content
+      (nsplit, adw_navigation_page_new (gtk_label_new("content"), "Main"));
+   Check(nsplit # NIL, "AdwNavigationSplitView");
+
+   sheet := adw_bottom_sheet_new();
+   adw_bottom_sheet_set_content (sheet, gtk_label_new("content"));
+   adw_bottom_sheet_set_sheet (sheet, gtk_label_new("sheet"));
+   Check(sheet # NIL, "AdwBottomSheet");
+
+   (* breakpoints *)
+   cond := adw_breakpoint_condition_parse ("max-width: 600px");
+   bp := adw_breakpoint_new (cond);
+   Check(adw_breakpoint_get_condition (bp) # NIL, "AdwBreakpoint condition");
+
+   (* multi layout view *)
+   mlv := adw_multi_layout_view_new();
+   layout := adw_layout_new (gtk_label_new("layout"));
+   adw_layout_set_name (layout, "main");
+   adw_multi_layout_view_add_layout (mlv, layout);
+   slot := adw_layout_slot_new ("slot1");
+   adw_multi_layout_view_set_child (mlv, "slot1", gtk_label_new("child"));
+   Check((mlv # NIL) AND (slot # NIL), "AdwMultiLayoutView");
+
+   (* style manager *)
+   sm := adw_style_manager_get_default();
+   adw_style_manager_set_color_scheme (sm, AdwColorSchemePreferDark);
+   Check(adw_style_manager_get_color_scheme (sm) = AdwColorSchemePreferDark,
+         "AdwStyleManager colour scheme");
+   adw_style_manager_set_color_scheme (sm, AdwColorSchemePreferLight);
+
+   (* swipe tracker (carousel implements AdwSwipeable) *)
+   tracker := adw_swipe_tracker_new (carousel);
+   Check(tracker # NIL, "AdwSwipeTracker");
+
+   (* animations *)
+   spring := adw_spring_params_new (0.9, 1.0, 100.0);
+   target := adw_property_animation_target_new (label, "opacity");
+   anim := adw_timed_animation_new (label, 0.0, 1.0, 200, target);
+   adw_timed_animation_set_easing (anim, AdwEasingEaseInOut);
+   Check(adw_animation_get_widget (anim) = label, "AdwTimedAnimation");
+   anim := adw_spring_animation_new (label, 0.0, 1.0, spring, target);
+   Check(anim # NIL, "AdwSpringAnimation");
+   target := adw_callback_animation_target_new (ADR(OnAnimValue), NIL, NIL);
+   Check(target # NIL, "AdwCallbackAnimationTarget");
+
+   (* build a small window *)
+   box := gtk_box_new (GtkVertical, 12);
+   gtk_box_append (box, gtk_label_new("libadwaita widgets, batch 2"));
+   gtk_box_append (box, carousel);
+   gtk_box_append (box, tg);
+   gtk_window_set_child (window, box);
+   gtk_window_present (window);
+
+   passed := (failures = 0);
+   g_application_quit (application)
+END OnActivate;
+
+VAR
+   rc: INTEGER;
+BEGIN
+   passed := FALSE;
+   failures := 0;
+   app := gtk_application_new(AppId, 0);
+   IF app = NIL THEN
+      printf("test_adw_widgets2: FAIL (no app)\n");
+      HALT(1)
+   END;
+   Connect(app, "activate", ADR(OnActivate), NIL);
+   rc := g_application_run(app, 0, NIL);
+
+   IF passed THEN
+      printf("test_adw_widgets2: PASS\n");
+      HALT(0)
+   ELSE
+      printf("test_adw_widgets2: FAIL\n");
+      HALT(1)
+   END
+END test_adw_widgets2.