From 95dc7e43a23300b3eacbb7e1e0a9d4f31a8bd5a0 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Thu, 24 Apr 2025 20:12:26 +0200 Subject: adw: extract class definitions --- adw/CMakeLists.txt | 23 +++-------- adw/include/adwaitamm/actionrow.hpp | 23 +++-------- adw/include/adwaitamm/alertdialog.hpp | 28 +++++-------- adw/include/adwaitamm/application.hpp | 35 +++++++--------- adw/include/adwaitamm/applicationwindow.hpp | 30 ++++++-------- adw/include/adwaitamm/breakpoint.hpp | 23 +++-------- adw/include/adwaitamm/dialog.hpp | 31 +++++---------- adw/include/adwaitamm/helpers/gobj_mixin.hpp | 32 +++++++++------ adw/include/adwaitamm/preferencesdialog.hpp | 32 +++++---------- adw/include/adwaitamm/preferencespage.hpp | 27 +++++-------- adw/include/adwaitamm/preferencesrow.hpp | 23 +++-------- adw/include/adwaitamm/private/actionrow_p.hpp | 33 ++++++++++++++++ adw/include/adwaitamm/private/alertdialog_p.hpp | 33 ++++++++++++++++ adw/include/adwaitamm/private/application_p.hpp | 33 ++++++++++++++++ .../adwaitamm/private/applicationwindow_p.hpp | 33 ++++++++++++++++ adw/include/adwaitamm/private/breakpoint_p.hpp | 34 ++++++++++++++++ adw/include/adwaitamm/private/dialog_p.hpp | 33 ++++++++++++++++ .../adwaitamm/private/preferencesdialog_p.hpp | 33 ++++++++++++++++ .../adwaitamm/private/preferencespage_p.hpp | 33 ++++++++++++++++ adw/include/adwaitamm/private/preferencesrow_p.hpp | 36 +++++++++++++++++ adw/include/adwaitamm/private/stylemanager_p.hpp | 32 +++++++++++++++ adw/include/adwaitamm/private/switchrow_p.hpp | 35 ++++++++++++++++ adw/include/adwaitamm/private/toast_p.hpp | 34 ++++++++++++++++ adw/include/adwaitamm/private/toastoverlay_p.hpp | 33 ++++++++++++++++ adw/include/adwaitamm/stylemanager.hpp | 25 +++--------- adw/include/adwaitamm/switchrow.hpp | 23 +++-------- adw/include/adwaitamm/toast.hpp | 46 +++++++++++----------- adw/include/adwaitamm/toastoverlay.hpp | 23 +++-------- adw/src/actionrow.cpp | 24 +---------- adw/src/alertdialog.cpp | 24 +---------- adw/src/application.cpp | 24 +---------- adw/src/applicationwindow.cpp | 25 ++---------- adw/src/breakpoint.cpp | 25 +----------- adw/src/dialog.cpp | 25 +----------- adw/src/preferencesdialog.cpp | 24 +---------- adw/src/preferencespage.cpp | 25 ++---------- adw/src/preferencesrow.cpp | 25 ++---------- adw/src/private/actionrow_p.cpp | 35 ++++++++++++++++ adw/src/private/alertdialog_p.cpp | 37 +++++++++++++++++ adw/src/private/application_p.cpp | 33 ++++++++++++++++ adw/src/private/applicationwindow_p.cpp | 33 ++++++++++++++++ adw/src/private/breakpoint_p.cpp | 32 +++++++++++++++ adw/src/private/dialog_p.cpp | 37 +++++++++++++++++ adw/src/private/preferencesdialog_p.cpp | 37 +++++++++++++++++ adw/src/private/preferencespage_p.cpp | 35 ++++++++++++++++ adw/src/private/preferencesrow_p.cpp | 34 ++++++++++++++++ adw/src/private/stylemanager_p.cpp | 30 ++++++++++++++ adw/src/private/switch_row_p.cpp | 32 +++++++++++++++ adw/src/private/toast_p.cpp | 29 ++++++++++++++ adw/src/private/toastoverlay_p.cpp | 37 +++++++++++++++++ adw/src/stylemanager.cpp | 24 +---------- adw/src/switchrow.cpp | 24 +---------- adw/src/toast.cpp | 24 +---------- adw/src/toastoverlay.cpp | 24 +---------- adw/src/wrap_init.cpp | 15 ++++++- 55 files changed, 1067 insertions(+), 565 deletions(-) create mode 100644 adw/include/adwaitamm/private/actionrow_p.hpp create mode 100644 adw/include/adwaitamm/private/alertdialog_p.hpp create mode 100644 adw/include/adwaitamm/private/application_p.hpp create mode 100644 adw/include/adwaitamm/private/applicationwindow_p.hpp create mode 100644 adw/include/adwaitamm/private/breakpoint_p.hpp create mode 100644 adw/include/adwaitamm/private/dialog_p.hpp create mode 100644 adw/include/adwaitamm/private/preferencesdialog_p.hpp create mode 100644 adw/include/adwaitamm/private/preferencespage_p.hpp create mode 100644 adw/include/adwaitamm/private/preferencesrow_p.hpp create mode 100644 adw/include/adwaitamm/private/stylemanager_p.hpp create mode 100644 adw/include/adwaitamm/private/switchrow_p.hpp create mode 100644 adw/include/adwaitamm/private/toast_p.hpp create mode 100644 adw/include/adwaitamm/private/toastoverlay_p.hpp create mode 100644 adw/src/private/actionrow_p.cpp create mode 100644 adw/src/private/alertdialog_p.cpp create mode 100644 adw/src/private/application_p.cpp create mode 100644 adw/src/private/applicationwindow_p.cpp create mode 100644 adw/src/private/breakpoint_p.cpp create mode 100644 adw/src/private/dialog_p.cpp create mode 100644 adw/src/private/preferencesdialog_p.cpp create mode 100644 adw/src/private/preferencespage_p.cpp create mode 100644 adw/src/private/preferencesrow_p.cpp create mode 100644 adw/src/private/stylemanager_p.cpp create mode 100644 adw/src/private/switch_row_p.cpp create mode 100644 adw/src/private/toast_p.cpp create mode 100644 adw/src/private/toastoverlay_p.cpp diff --git a/adw/CMakeLists.txt b/adw/CMakeLists.txt index 6ca4ad0..6b08199 100644 --- a/adw/CMakeLists.txt +++ b/adw/CMakeLists.txt @@ -14,23 +14,12 @@ pkg_check_modules("adwaita" IMPORTED_TARGET REQUIRED "libadwaita-1>=1.7.0") pkg_check_modules("giomm" IMPORTED_TARGET REQUIRED "giomm-2.68>=2.80") pkg_check_modules("glibmm" IMPORTED_TARGET REQUIRED "glibmm-2.68>=2.80") -add_library("adwaitamm" - "src/helpers/async_callback.cpp" - "src/actionrow.cpp" - "src/alertdialog.cpp" - "src/application.cpp" - "src/applicationwindow.cpp" - "src/breakpoint.cpp" - "src/dialog.cpp" - "src/enums.cpp" - "src/preferencesdialog.cpp" - "src/preferencespage.cpp" - "src/preferencesrow.cpp" - "src/stylemanager.cpp" - "src/switchrow.cpp" - "src/toast.cpp" - "src/toastoverlay.cpp" - "src/wrap_init.cpp" +add_library("adwaitamm") + +file(GLOB_RECURSE ADWAITAMM_SOURCES RELATIVE "${PROJECT_SOURCE_DIR}" CONFIGURE_DEPENDS "src/**.cpp") + +target_sources("adwaitamm" PRIVATE + ${ADWAITAMM_SOURCES} ) file(GLOB_RECURSE ADWAITAMM_HEADERS RELATIVE "${PROJECT_SOURCE_DIR}" CONFIGURE_DEPENDS "include/**/*.hpp") diff --git a/adw/include/adwaitamm/actionrow.hpp b/adw/include/adwaitamm/actionrow.hpp index 5b99ab7..6a34e15 100644 --- a/adw/include/adwaitamm/actionrow.hpp +++ b/adw/include/adwaitamm/actionrow.hpp @@ -24,23 +24,10 @@ namespace Adwaita struct ActionRow : PreferencesRow, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = AdwPreferencesRowClass; - using BaseClassType = AdwActionRowClass; - using BaseObjectType = AdwActionRow; - using CppClassParent = PreferencesRow::Class; - using CppObjectType = ActionRow; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwActionRow; + using BaseClassType = AdwActionRowClass; + using CppObjectType = ActionRow; + using CppClassType = struct ActionRow_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -87,6 +74,8 @@ namespace Adwaita auto property_title_lines() const noexcept -> Glib::PropertyProxy_ReadOnly; protected: + friend struct ActionRow_Class; + explicit ActionRow(Glib::ConstructParams const & params); explicit ActionRow(BaseObjectType * gobj); }; diff --git a/adw/include/adwaitamm/alertdialog.hpp b/adw/include/adwaitamm/alertdialog.hpp index 2a34a45..fb0d88f 100644 --- a/adw/include/adwaitamm/alertdialog.hpp +++ b/adw/include/adwaitamm/alertdialog.hpp @@ -17,8 +17,9 @@ #include -using AdwAlertDialog = struct _AdwAlertDialog; -using AdwAlertDialogClass = struct _AdwAlertDialogClass; +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE namespace Adwaita { @@ -27,23 +28,10 @@ namespace Adwaita struct AlertDialog : Dialog, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = AdwDialogClass; - using BaseClassType = AdwAlertDialogClass; - using BaseObjectType = AdwAlertDialog; - using CppClassParent = Dialog::Class; - using CppObjectType = AlertDialog; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwAlertDialog; + using BaseClassType = AdwAlertDialogClass; + using CppObjectType = AlertDialog; + using CppClassType = struct AlertDialog_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -67,6 +55,8 @@ namespace Adwaita auto set_response_appearance(Glib::ustring id, ResponseAppearance value) -> void; protected: + friend AlertDialog_Class; + explicit AlertDialog(Glib::ConstructParams const & params); explicit AlertDialog(BaseObjectType * gobj); }; diff --git a/adw/include/adwaitamm/application.hpp b/adw/include/adwaitamm/application.hpp index 5242d50..0cbc24f 100644 --- a/adw/include/adwaitamm/application.hpp +++ b/adw/include/adwaitamm/application.hpp @@ -4,6 +4,7 @@ #include "adwaitamm/helpers/gobj_mixin.hpp" #include +#include #include #include @@ -11,31 +12,21 @@ #include -using AdwApplication = struct _AdwApplication; -using AdwApplicationClass = struct _AdwApplicationClass; +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE namespace Adwaita { struct Application : Gtk::Application, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = GtkApplicationClass; - using BaseClassType = AdwApplicationClass; - using BaseObjectType = AdwApplication; - using CppClassParent = struct Gtk::Application_Class; - using CppObjectType = Application; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwApplication; + using BaseClassType = AdwApplicationClass; + using CppObjectType = Application; + using CppClassType = struct Application_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -46,13 +37,15 @@ namespace Adwaita auto operator=(Application const & other) noexcept -> Application & = delete; auto operator=(Application && other) noexcept -> Application & = default; - auto static create(Glib::ustring const & id = {}, - Gio::Application::Flags flags = Gio::Application::Flags::NONE) -> Glib::RefPtr; + auto static create(Glib::ustring const & id = {}, Gio::Application::Flags flags = Gio::Application::Flags::NONE) + -> Glib::RefPtr; auto static get_type() -> GType; auto static get_base_type() -> GType; protected: + friend Application_Class; + explicit Application(Glib::ConstructParams const & params); explicit Application(BaseObjectType * gobj); explicit Application(Glib::ustring const & id = {}, Gio::Application::Flags flags = Gio::Application::Flags::NONE); diff --git a/adw/include/adwaitamm/applicationwindow.hpp b/adw/include/adwaitamm/applicationwindow.hpp index 310795e..454fad5 100644 --- a/adw/include/adwaitamm/applicationwindow.hpp +++ b/adw/include/adwaitamm/applicationwindow.hpp @@ -11,31 +11,21 @@ #include #include -using AdwApplicationWindow = struct _AdwApplicationWindow; -using AdwApplicationWindowClass = struct _AdwApplicationWindowClass; +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE namespace Adwaita { struct ApplicationWindow : Gtk::ApplicationWindow, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = GtkApplicationWindowClass; - using BaseClassType = AdwApplicationWindowClass; - using BaseObjectType = AdwApplicationWindow; - using CppClassParent = struct Gtk::ApplicationWindow_Class; - using CppObjectType = ApplicationWindow; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwApplicationWindow; + using BaseClassType = AdwApplicationWindowClass; + using CppObjectType = ApplicationWindow; + using CppClassType = struct ApplicationWindow_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -51,6 +41,8 @@ namespace Adwaita auto static get_base_type() -> GType; protected: + friend ApplicationWindow_Class; + explicit ApplicationWindow(Glib::ConstructParams const & params); explicit ApplicationWindow(BaseObjectType * gobj); }; diff --git a/adw/include/adwaitamm/breakpoint.hpp b/adw/include/adwaitamm/breakpoint.hpp index 13e9f1e..7bcb2d9 100644 --- a/adw/include/adwaitamm/breakpoint.hpp +++ b/adw/include/adwaitamm/breakpoint.hpp @@ -52,23 +52,10 @@ namespace Adwaita Gtk::Buildable, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = GObjectClass; - using BaseClassType = AdwBreakpointClass; - using BaseObjectType = AdwBreakpoint; - using CppClassParent = struct Glib::Object_Class; - using CppObjectType = Breakpoint; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwBreakpoint; + using BaseClassType = AdwBreakpointClass; + using CppObjectType = Breakpoint; + using CppClassType = struct Breakpoint_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -87,6 +74,8 @@ namespace Adwaita auto property_condition() const -> Glib::PropertyProxy_ReadOnly; protected: + friend Breakpoint_Class; + explicit Breakpoint(BreakpointCondition & condition); explicit Breakpoint(Glib::ConstructParams const & params); explicit Breakpoint(BaseObjectType * gobj); diff --git a/adw/include/adwaitamm/dialog.hpp b/adw/include/adwaitamm/dialog.hpp index 44dde25..eeaeda1 100644 --- a/adw/include/adwaitamm/dialog.hpp +++ b/adw/include/adwaitamm/dialog.hpp @@ -15,34 +15,21 @@ #include -using AdwDialog = struct _AdwDialog; -using AdwDialogClass = struct _AdwDialogClass; +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE namespace Adwaita { - struct Dialog_Class; - struct Dialog : Gtk::Widget, Gtk::ShortcutManager, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = GtkWidgetClass; - using BaseClassType = AdwDialogClass; - using BaseObjectType = AdwDialog; - using CppClassParent = struct Gtk::Widget_Class; - using CppObjectType = Dialog; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + + using BaseObjectType = AdwDialog; + using BaseClassType = AdwDialogClass; + using CppObjectType = Dialog; + using CppClassType = struct Dialog_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -71,6 +58,8 @@ namespace Adwaita auto set_title(Glib::ustring const & str) -> void; protected: + friend Dialog_Class; + explicit Dialog(Glib::ConstructParams const & params); explicit Dialog(BaseObjectType * gobj); }; diff --git a/adw/include/adwaitamm/helpers/gobj_mixin.hpp b/adw/include/adwaitamm/helpers/gobj_mixin.hpp index fbdaa4e..762136e 100644 --- a/adw/include/adwaitamm/helpers/gobj_mixin.hpp +++ b/adw/include/adwaitamm/helpers/gobj_mixin.hpp @@ -8,27 +8,35 @@ namespace Adwaita::helpers { - template + template + struct copy_const + { + using type = TargetType; + }; + + template + struct copy_const + { + using type = std::add_const_t; + }; + + template + using copy_const_t = typename copy_const::type; + + template struct gobj_mixin { template auto gobj(this Self && self) noexcept { - using clean_type = std::remove_reference_t; - using gobj_type = std::conditional_t, std::add_const_t, Glib::Object>; - using cast_type = std::conditional_t, std::add_const_t, AdwType>; - - return reinterpret_cast(static_cast(self).gobj()); + using base_type = copy_const_t, BaseType>; + return reinterpret_cast(self.::Glib::Object::gobj()); } template - auto gobj_copy(this Self && self) noexcept -> AdwType * + auto gobj_copy(this Self && self) noexcept { - using clean_type = std::remove_reference_t; - using gobj_type = std::conditional_t, std::add_const_t, Glib::Object>; - - static_cast(self).reference(); - return const_cast(self.gobj()); + return reinterpret_cast(self.::Glib::Object::gobj_copy()); } }; diff --git a/adw/include/adwaitamm/preferencesdialog.hpp b/adw/include/adwaitamm/preferencesdialog.hpp index 2beaf64..080651f 100644 --- a/adw/include/adwaitamm/preferencesdialog.hpp +++ b/adw/include/adwaitamm/preferencesdialog.hpp @@ -1,9 +1,9 @@ #ifndef LIBADWAITAMM_PREFERENCES_DIALOG_HPP #define LIBADWAITAMM_PREFERENCES_DIALOG_HPP +#include "adwaitamm/preferencespage.hpp" #include "dialog.hpp" #include "helpers/gobj_mixin.hpp" -#include "adwaitamm/preferencespage.hpp" #include #include @@ -15,33 +15,19 @@ #include -using AdwPreferencesDialog = struct _AdwPreferencesDialog; -using AdwPreferencesDialogClass = struct _AdwPreferencesDialogClass; +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE namespace Adwaita { - struct PreferencesDialog_Class; - struct PreferencesDialog : Dialog, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = AdwDialogClass; - using BaseClassType = AdwPreferencesDialogClass; - using BaseObjectType = AdwPreferencesDialog; - using CppClassParent = Dialog::Class; - using CppObjectType = PreferencesDialog; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwPreferencesDialog; + using BaseClassType = AdwPreferencesDialogClass; + using CppObjectType = PreferencesDialog; + using CppClassType = struct PreferencesDialog_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -60,6 +46,8 @@ namespace Adwaita auto set_visible_page(PreferencesPage & page) -> void; protected: + friend PreferencesDialog_Class; + explicit PreferencesDialog(Glib::ConstructParams const & params); explicit PreferencesDialog(BaseObjectType * gobj); }; diff --git a/adw/include/adwaitamm/preferencespage.hpp b/adw/include/adwaitamm/preferencespage.hpp index 7e7e9ed..311796f 100644 --- a/adw/include/adwaitamm/preferencespage.hpp +++ b/adw/include/adwaitamm/preferencespage.hpp @@ -13,31 +13,20 @@ #include -using AdwPreferencesPage = struct _AdwPreferencesPage; -using AdwPreferencesPageClass = struct _AdwPreferencesPageClass; +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE namespace Adwaita { struct PreferencesPage : Gtk::Widget, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = GtkWidgetClass; - using BaseClassType = AdwPreferencesPageClass; - using BaseObjectType = AdwPreferencesPage; - using CppClassParent = struct Gtk::Widget_Class; - using CppObjectType = PreferencesPage; - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwPreferencesPage; + using BaseClassType = AdwPreferencesPageClass; + using CppObjectType = PreferencesPage; + using CppClassType = struct PreferencesPage_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -53,6 +42,8 @@ namespace Adwaita auto static get_base_type() -> GType; protected: + friend PreferencesPage_Class; + explicit PreferencesPage(Glib::ConstructParams const & params); explicit PreferencesPage(BaseObjectType * gobj); }; diff --git a/adw/include/adwaitamm/preferencesrow.hpp b/adw/include/adwaitamm/preferencesrow.hpp index 6c1d6bb..3bbaaec 100644 --- a/adw/include/adwaitamm/preferencesrow.hpp +++ b/adw/include/adwaitamm/preferencesrow.hpp @@ -22,23 +22,10 @@ namespace Adwaita struct PreferencesRow : Gtk::ListBoxRow, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = GtkListBoxRowClass; - using BaseClassType = AdwPreferencesRowClass; - using BaseObjectType = AdwPreferencesRow; - using CppClassParent = struct Gtk::ListBoxRow_Class; - using CppObjectType = PreferencesRow; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwPreferencesRow; + using BaseClassType = AdwPreferencesRowClass; + using CppObjectType = PreferencesRow; + using CppClassType = struct PreferencesRow_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -73,6 +60,8 @@ namespace Adwaita auto property_use_underline() const -> Glib::PropertyProxy_ReadOnly; protected: + friend PreferencesRow_Class; + explicit PreferencesRow(Glib::ConstructParams const & params); explicit PreferencesRow(BaseObjectType * gobj); }; diff --git a/adw/include/adwaitamm/private/actionrow_p.hpp b/adw/include/adwaitamm/private/actionrow_p.hpp new file mode 100644 index 0000000..5ccce02 --- /dev/null +++ b/adw/include/adwaitamm/private/actionrow_p.hpp @@ -0,0 +1,33 @@ +#ifndef LIBADWAITAMM_PRIVATE_ACTION_ROW_P_HPP +#define LIBADWAITAMM_PRIVATE_ACTION_ROW_P_HPP + +#include + +#include +#include + +#include + +using AdwActionRow = struct _AdwActionRow; +using AdwActionRowClass = struct _AdwActionRowClass; +using AdwPreferencesRowClass = struct _AdwPreferencesRowClass; + +namespace Adwaita +{ + + struct ActionRow_Class : Glib::Class + { + using BaseClassParent = AdwPreferencesRowClass; + using BaseClassType = AdwActionRowClass; + using BaseObjectType = AdwActionRow; + using CppClassParent = struct PreferencesRow_Class; + using CppObjectType = struct ActionRow; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; + +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/alertdialog_p.hpp b/adw/include/adwaitamm/private/alertdialog_p.hpp new file mode 100644 index 0000000..949b4b8 --- /dev/null +++ b/adw/include/adwaitamm/private/alertdialog_p.hpp @@ -0,0 +1,33 @@ +#ifndef LIBADWAITAMM_PRIVATE_ALERT_DIALOG_P_HPP +#define LIBADWAITAMM_PRIVATE_ALERT_DIALOG_P_HPP + +#include "adwaitamm/private/dialog_p.hpp" + +#include +#include + +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + struct AlertDialog_Class : Glib::Class + { + using BaseClassParent = AdwDialogClass; + using BaseClassType = AdwAlertDialogClass; + using BaseObjectType = AdwAlertDialog; + using CppClassParent = Dialog_Class; + using CppObjectType = struct AlertDialog; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/application_p.hpp b/adw/include/adwaitamm/private/application_p.hpp new file mode 100644 index 0000000..b9ac5f6 --- /dev/null +++ b/adw/include/adwaitamm/private/application_p.hpp @@ -0,0 +1,33 @@ +#ifndef LIBADWAITAMM_PRIVATE_APPLICATION_P_HPP +#define LIBADWAITAMM_PRIVATE_APPLICATION_P_HPP + +#include +#include + +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + struct Application; + + struct Application_Class : Glib::Class + { + using BaseClassParent = GtkApplicationClass; + using BaseClassType = AdwApplicationClass; + using BaseObjectType = AdwApplication; + using CppClassParent = Gtk::Application_Class; + using CppObjectType = Application; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/applicationwindow_p.hpp b/adw/include/adwaitamm/private/applicationwindow_p.hpp new file mode 100644 index 0000000..d44629e --- /dev/null +++ b/adw/include/adwaitamm/private/applicationwindow_p.hpp @@ -0,0 +1,33 @@ +#ifndef LIBADWAITAMM_PRIVATE_APPLICATION_WINDOW_P_HPP +#define LIBADWAITAMM_PRIVATE_APPLICATION_WINDOW_P_HPP + +#include +#include + +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + struct ApplicationWindow; + + struct ApplicationWindow_Class : Glib::Class + { + using BaseClassParent = GtkApplicationWindowClass; + using BaseClassType = AdwApplicationWindowClass; + using BaseObjectType = AdwApplicationWindow; + using CppClassParent = Gtk::ApplicationWindow_Class; + using CppObjectType = ApplicationWindow; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/breakpoint_p.hpp b/adw/include/adwaitamm/private/breakpoint_p.hpp new file mode 100644 index 0000000..b4f6bc4 --- /dev/null +++ b/adw/include/adwaitamm/private/breakpoint_p.hpp @@ -0,0 +1,34 @@ +#ifndef LIBADWAITAMM_PRIVATE_BREAKPOINT_P_HPP +#define LIBADWAITAMM_PRIVATE_BREAKPOINT_P_HPP + +#include + +#include +#include +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + + struct Breakpoint_Class : Glib::Class + { + using BaseClassParent = GObjectClass; + using BaseClassType = AdwBreakpointClass; + using BaseObjectType = AdwBreakpoint; + using CppClassParent = struct Glib::Object_Class; + using CppObjectType = struct Breakpoint; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; + +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/dialog_p.hpp b/adw/include/adwaitamm/private/dialog_p.hpp new file mode 100644 index 0000000..5f02dba --- /dev/null +++ b/adw/include/adwaitamm/private/dialog_p.hpp @@ -0,0 +1,33 @@ +#ifndef LIBADWAITAMM_PRIVATE_DIALOG_P_HPP +#define LIBADWAITAMM_PRIVATE_DIALOG_P_HPP + +#include +#include + +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + struct Dialog; + + struct Dialog_Class : Glib::Class + { + using BaseClassParent = GtkWidgetClass; + using BaseClassType = AdwDialogClass; + using BaseObjectType = AdwDialog; + using CppClassParent = Gtk::Widget_Class; + using CppObjectType = Dialog; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/preferencesdialog_p.hpp b/adw/include/adwaitamm/private/preferencesdialog_p.hpp new file mode 100644 index 0000000..14f1038 --- /dev/null +++ b/adw/include/adwaitamm/private/preferencesdialog_p.hpp @@ -0,0 +1,33 @@ +#ifndef LIBADWAITAMM_PRIVATE_PREFERENCES_DIALOG_P_HPP +#define LIBADWAITAMM_PRIVATE_PREFERENCES_DIALOG_P_HPP + +#include "adwaitamm/private/dialog_p.hpp" + +#include +#include + +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + struct PreferencesDialog_Class : Glib::Class + { + using BaseClassParent = AdwDialogClass; + using BaseClassType = AdwPreferencesDialogClass; + using BaseObjectType = AdwPreferencesDialog; + using CppClassParent = Dialog_Class; + using CppObjectType = struct PreferencesDialog; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/preferencespage_p.hpp b/adw/include/adwaitamm/private/preferencespage_p.hpp new file mode 100644 index 0000000..0a84a99 --- /dev/null +++ b/adw/include/adwaitamm/private/preferencespage_p.hpp @@ -0,0 +1,33 @@ +#ifndef LIBADWAITAMM_PRIVATE_PREFERENCES_PAGE_P_HPP +#define LIBADWAITAMM_PRIVATE_PREFERENCES_PAGE_P_HPP + +#include +#include + +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + struct PreferencesPage; + + struct PreferencesPage_Class : Glib::Class + { + using BaseClassParent = GtkWidgetClass; + using BaseClassType = AdwPreferencesPageClass; + using BaseObjectType = AdwPreferencesPage; + using CppClassParent = Gtk::Widget_Class; + using CppObjectType = PreferencesPage; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/preferencesrow_p.hpp b/adw/include/adwaitamm/private/preferencesrow_p.hpp new file mode 100644 index 0000000..be0b25b --- /dev/null +++ b/adw/include/adwaitamm/private/preferencesrow_p.hpp @@ -0,0 +1,36 @@ +#ifndef LIBADWAITAMM_PRIVATE_PREFERENCES_ROW_P_HPP +#define LIBADWAITAMM_PRIVATE_PREFERENCES_ROW_P_HPP + +#include +#include + +#include + +using AdwPreferencesRow = struct _AdwPreferencesRow; +using AdwPreferencesRowClass = struct _AdwPreferencesRowClass; + +namespace Gtk +{ + struct ListBoxRow_Class; +} // namespace Gtk + +namespace Adwaita +{ + struct PreferencesRow; + + struct PreferencesRow_Class : Glib::Class + { + using BaseClassParent = GtkListBoxRowClass; + using BaseClassType = AdwPreferencesRowClass; + using BaseObjectType = AdwPreferencesRow; + using CppClassParent = Gtk::ListBoxRow_Class; + using CppObjectType = PreferencesRow; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; + +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/stylemanager_p.hpp b/adw/include/adwaitamm/private/stylemanager_p.hpp new file mode 100644 index 0000000..a37eedd --- /dev/null +++ b/adw/include/adwaitamm/private/stylemanager_p.hpp @@ -0,0 +1,32 @@ +#ifndef LIBADWAITAMM_PRIVATE_STYLE_MANAGER_P_HPP +#define LIBADWAITAMM_PRIVATE_STYLE_MANAGER_P_HPP + +#include +#include +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + + struct StyleManager_Class : Glib::Class + { + using BaseClassParent = GObjectClass; + using BaseClassType = AdwStyleManagerClass; + using BaseObjectType = AdwStyleManager; + using CppClassParent = Glib::Object_Class; + using CppObjectType = struct StyleManager; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; + +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/switchrow_p.hpp b/adw/include/adwaitamm/private/switchrow_p.hpp new file mode 100644 index 0000000..7c2288b --- /dev/null +++ b/adw/include/adwaitamm/private/switchrow_p.hpp @@ -0,0 +1,35 @@ +#ifndef LIBADWAITAMM_PRIVATE_SWITCH_ROW_P_HPP +#define LIBADWAITAMM_PRIVATE_SWITCH_ROW_P_HPP + +#include "adwaitamm/private/actionrow_p.hpp" + +#include + +#include +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + + struct SwitchRow_Class : Glib::Class + { + using BaseClassParent = AdwActionRowClass; + using BaseClassType = AdwSwitchRowClass; + using BaseObjectType = AdwSwitchRow; + using CppClassParent = ActionRow_Class; + using CppObjectType = struct SwitchRow; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; + +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/toast_p.hpp b/adw/include/adwaitamm/private/toast_p.hpp new file mode 100644 index 0000000..2431b32 --- /dev/null +++ b/adw/include/adwaitamm/private/toast_p.hpp @@ -0,0 +1,34 @@ +#ifndef LIBADWAITAMM_PRIVATE_TOAST_P_HPP +#define LIBADWAITAMM_PRIVATE_TOAST_P_HPP + +#include + +#include +#include +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + + struct Toast_Class : Glib::Class + { + using BaseClassParent = GObjectClass; + using BaseClassType = AdwToastClass; + using BaseObjectType = AdwToast; + using CppClassParent = struct Glib::Object_Class; + using CppObjectType = struct Toast; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; + +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/private/toastoverlay_p.hpp b/adw/include/adwaitamm/private/toastoverlay_p.hpp new file mode 100644 index 0000000..3fa651b --- /dev/null +++ b/adw/include/adwaitamm/private/toastoverlay_p.hpp @@ -0,0 +1,33 @@ +#ifndef LIBADWAITAMM_PRIVATE_TOAST_OVERLAY_P_HPP +#define LIBADWAITAMM_PRIVATE_TOAST_OVERLAY_P_HPP + +#include +#include + +#include + +#include + +#define _ADWAITA_INSIDE +#include +#undef _ADWAITA_INSIDE + +namespace Adwaita +{ + struct ToastOverlay; + + struct ToastOverlay_Class : Glib::Class + { + using BaseClassParent = GtkWidgetClass; + using BaseClassType = AdwToastOverlayClass; + using BaseObjectType = AdwToastOverlay; + using CppClassParent = Gtk::Widget_Class; + using CppObjectType = ToastOverlay; + + auto init() -> Glib::Class const &; + auto static class_init_function(void * gclass, void * data) -> void; + auto static wrap_new(GObject * object) -> Glib::ObjectBase *; + }; +} // namespace Adwaita + +#endif \ No newline at end of file diff --git a/adw/include/adwaitamm/stylemanager.hpp b/adw/include/adwaitamm/stylemanager.hpp index 3d370c3..15f0f0e 100644 --- a/adw/include/adwaitamm/stylemanager.hpp +++ b/adw/include/adwaitamm/stylemanager.hpp @@ -21,8 +21,6 @@ #include #undef _ADWAITA_INSIDE -using AdwStyleManager = struct _AdwStyleManager; - namespace Adwaita { enum struct AccentColor; @@ -31,23 +29,10 @@ namespace Adwaita struct StyleManager final : Glib::Object, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = GObjectClass; - using BaseClassType = AdwStyleManagerClass; - using BaseObjectType = AdwStyleManager; - using CppClassParent = struct Glib::Object_Class; - using CppObjectType = StyleManager; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwStyleManager; + using BaseClassType = AdwStyleManagerClass; + using CppObjectType = StyleManager; + using CppClassType = struct StyleManager_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -77,6 +62,8 @@ namespace Adwaita auto set_color_scheme(ColorScheme value) -> void; protected: + friend StyleManager_Class; + explicit StyleManager(Glib::ConstructParams const & params); explicit StyleManager(BaseObjectType * gobj); explicit StyleManager(); diff --git a/adw/include/adwaitamm/switchrow.hpp b/adw/include/adwaitamm/switchrow.hpp index 622b58a..c95544e 100644 --- a/adw/include/adwaitamm/switchrow.hpp +++ b/adw/include/adwaitamm/switchrow.hpp @@ -26,23 +26,10 @@ namespace Adwaita struct SwitchRow final : ActionRow, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = AdwActionRowClass; - using BaseClassType = AdwSwitchRowClass; - using BaseObjectType = AdwSwitchRow; - using CppClassParent = ActionRow::Class; - using CppObjectType = SwitchRow; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwSwitchRow; + using BaseClassType = AdwSwitchRowClass; + using CppObjectType = struct SwitchRow; + using CppClassType = struct SwitchRow_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -64,6 +51,8 @@ namespace Adwaita auto property_active() const -> Glib::PropertyProxy_ReadOnly; protected: + friend SwitchRow_Class; + explicit SwitchRow(Glib::ConstructParams const & params); explicit SwitchRow(BaseObjectType * gobj); }; diff --git a/adw/include/adwaitamm/toast.hpp b/adw/include/adwaitamm/toast.hpp index 2c4718b..4aee04d 100644 --- a/adw/include/adwaitamm/toast.hpp +++ b/adw/include/adwaitamm/toast.hpp @@ -21,47 +21,40 @@ #include #undef _ADWAITA_INSIDE -using AdwToast = struct _AdwToast; - namespace Adwaita { + struct Toast_Class; + enum struct ToastPriority; struct Toast final : Glib::Object, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = GObjectClass; - using BaseClassType = AdwToastClass; - using BaseObjectType = AdwToast; - using CppClassParent = struct Glib::Object_Class; - using CppObjectType = Toast; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; - - using helpers::gobj_mixin::gobj; - using helpers::gobj_mixin::gobj_copy; + using BaseObjectType = AdwToast; + using BaseClassType = AdwToastClass; + using CppObjectType = Toast; + using CppClassType = Toast_Class; +#pragma mark - Special Member Functions Toast(Toast const & other) = delete; Toast(Toast && other) noexcept = default; auto operator=(Toast const & other) noexcept -> Toast & = delete; auto operator=(Toast && other) noexcept -> Toast & = default; - auto static create(Glib::ustring const & title) -> Glib::RefPtr; +#pragma mark - GObject Support + using helpers::gobj_mixin::gobj; + using helpers::gobj_mixin::gobj_copy; auto static get_type() -> GType; auto static get_base_type() -> GType; +#pragma mark - Factories + auto static create(Glib::ustring const & title) -> Glib::RefPtr; + +#pragma mark - Functions auto dismiss() -> void; + +#pragma mark - Getters auto get_action_name() const -> Glib::ustring; auto get_action_target_value() const -> Glib::VariantBase; auto get_button_label() const -> Glib::ustring; @@ -70,6 +63,8 @@ namespace Adwaita auto get_timeout() const -> unsigned; auto get_title() const -> Glib::ustring; auto get_use_markup() const -> bool; + +#pragma mark - Setters auto set_action_name(Glib::ustring value) -> void; auto set_action_target_value(Glib::VariantBase const & value) -> void; auto set_button_label(Glib::ustring value) -> void; @@ -80,6 +75,7 @@ namespace Adwaita auto set_title(Glib::ustring value) -> void; auto set_use_markup(bool value) -> void; +#pragma mark - Properties auto property_action_name() -> Glib::PropertyProxy; auto property_action_name() const -> Glib::PropertyProxy_ReadOnly; auto property_action_target() -> Glib::PropertyProxy; @@ -97,10 +93,14 @@ namespace Adwaita auto property_use_markup() -> Glib::PropertyProxy; auto property_use_markup() const -> Glib::PropertyProxy_ReadOnly; +#pragma mark - Signals auto signal_button_clicked() -> Glib::SignalProxy; auto signal_dismissed() -> Glib::SignalProxy; protected: + friend Toast_Class; + +#pragma mark - Constructors explicit Toast(Glib::ustring const & title); explicit Toast(Glib::ConstructParams const & params); explicit Toast(BaseObjectType * gobj); diff --git a/adw/include/adwaitamm/toastoverlay.hpp b/adw/include/adwaitamm/toastoverlay.hpp index 5e2742d..581d14b 100644 --- a/adw/include/adwaitamm/toastoverlay.hpp +++ b/adw/include/adwaitamm/toastoverlay.hpp @@ -22,23 +22,10 @@ namespace Adwaita struct ToastOverlay final : Gtk::Widget, helpers::gobj_mixin { - struct Class : Glib::Class - { - using BaseClassParent = GtkWidgetClass; - using BaseClassType = AdwToastOverlayClass; - using BaseObjectType = AdwToastOverlay; - using CppClassParent = struct Gtk::Widget_Class; - using CppObjectType = ToastOverlay; - - auto init() -> Glib::Class const &; - auto static class_init_function(void * gclass, void * data) -> void; - auto static wrap_new(GObject * object) -> Glib::ObjectBase *; - }; - - using BaseObjectType = Class::BaseObjectType; - using BaseClassType = Class::BaseClassType; - using CppObjectType = Class::CppObjectType; - using CppClassType = Class; + using BaseObjectType = AdwToastOverlay; + using BaseClassType = AdwToastOverlayClass; + using CppObjectType = ToastOverlay; + using CppClassType = struct ToastOverlay_Class; using helpers::gobj_mixin::gobj; using helpers::gobj_mixin::gobj_copy; @@ -62,6 +49,8 @@ namespace Adwaita auto property_child() const -> Glib::PropertyProxy_ReadOnly; protected: + friend ToastOverlay_Class; + explicit ToastOverlay(Glib::ConstructParams const & params); explicit ToastOverlay(BaseObjectType * gobj); }; diff --git a/adw/src/actionrow.cpp b/adw/src/actionrow.cpp index 297cefc..8242a6e 100644 --- a/adw/src/actionrow.cpp +++ b/adw/src/actionrow.cpp @@ -1,4 +1,5 @@ #include "adwaitamm/actionrow.hpp" +#include "adwaitamm/private/actionrow_p.hpp" #include "adwaitamm/preferencesrow.hpp" @@ -26,30 +27,9 @@ namespace Adwaita { namespace { - auto constinit _class = ActionRow::Class{}; + auto constinit _class = ActionRow_Class{}; } // namespace - auto ActionRow::Class::init() -> Glib::Class const & - { - if (!gtype_) - { - class_init_func_ = &class_init_function; - register_derived_type(adw_action_row_get_type()); - } - return *this; - } - - auto ActionRow::Class::class_init_function(void * gclass, void * data) -> void - { - auto const klass = static_cast(gclass); - CppClassParent::class_init_function(klass, data); - } - - auto ActionRow::Class::wrap_new(GObject * object) -> Glib::ObjectBase * - { - return Gtk::manage(new ActionRow(ADW_ACTION_ROW(object))); - } - auto ActionRow::get_type() -> GType { return _class.init().get_type(); diff --git a/adw/src/alertdialog.cpp b/adw/src/alertdialog.cpp index 585d9e8..24c5705 100644 --- a/adw/src/alertdialog.cpp +++ b/adw/src/alertdialog.cpp @@ -1,4 +1,5 @@ #include "adwaitamm/alertdialog.hpp" +#include "adwaitamm/private/alertdialog_p.hpp" #include "adwaitamm/dialog.hpp" @@ -31,30 +32,9 @@ namespace Adwaita namespace { - auto constinit _class = AlertDialog::Class{}; + auto constinit _class = AlertDialog_Class{}; } // namespace - auto AlertDialog::Class::init() -> Glib::Class const & - { - if (!gtype_) - { - class_init_func_ = &class_init_function; - register_derived_type(adw_alert_dialog_get_type()); - } - return *this; - } - - auto AlertDialog::Class::class_init_function(void * gclass, void * data) -> void - { - auto const klass = static_cast(gclass); - CppClassParent::class_init_function(klass, data); - } - - auto AlertDialog::Class::wrap_new(GObject * object) -> Glib::ObjectBase * - { - return Gtk::manage(new AlertDialog(ADW_ALERT_DIALOG(object))); - } - auto AlertDialog::create(Glib::ustring heading, Glib::ustring body) -> Glib::RefPtr { return Glib::RefPtr{new AlertDialog(heading, body)}; diff --git a/adw/src/application.cpp b/adw/src/application.cpp index 57a0aaa..55caff5 100644 --- a/adw/src/application.cpp +++ b/adw/src/application.cpp @@ -1,4 +1,5 @@ #include "adwaitamm/application.hpp" +#include "adwaitamm/private/application_p.hpp" #include "adwaitamm/wrap_init.hpp" @@ -23,30 +24,9 @@ namespace Adwaita { namespace { - auto constinit _class = Application::Class{}; + auto constinit _class = Application_Class{}; } // namespace - auto Application::Class::init() -> Glib::Class const & - { - if (!gtype_) - { - class_init_func_ = &Application::Class::class_init_function; - register_derived_type(adw_application_get_type()); - } - return *this; - } - - auto Application::Class::class_init_function(void * gclass, void * data) -> void - { - auto const klass = static_cast(gclass); - Gtk::Application_Class::class_init_function(klass, data); - } - - auto Application::Class::wrap_new(GObject * object) -> Glib::ObjectBase * - { - return new Application(ADW_APPLICATION(object)); - } - auto Application::get_type() -> GType { return _class.init().get_type(); diff --git a/adw/src/applicationwindow.cpp b/adw/src/applicationwindow.cpp index f4de581..50817d2 100644 --- a/adw/src/applicationwindow.cpp +++ b/adw/src/applicationwindow.cpp @@ -1,5 +1,7 @@ #include "adwaitamm/applicationwindow.hpp" +#include "adwaitamm/private/applicationwindow_p.hpp" + #include #include #include @@ -22,30 +24,9 @@ namespace Adwaita { namespace { - auto constinit _class = ApplicationWindow::Class{}; + auto constinit _class = ApplicationWindow_Class{}; } // namespace - auto ApplicationWindow::Class::init() -> Glib::Class const & - { - if (!gtype_) - { - class_init_func_ = &class_init_function; - register_derived_type(adw_application_window_get_type()); - } - return *this; - } - - auto ApplicationWindow::Class::class_init_function(void * gclass, void * data) -> void - { - auto const klass = static_cast(gclass); - CppClassParent::class_init_function(klass, data); - } - - auto ApplicationWindow::Class::wrap_new(GObject * object) -> Glib::ObjectBase * - { - return new ApplicationWindow(ADW_APPLICATION_WINDOW(object)); - } - auto ApplicationWindow::get_type() -> GType { return _class.init().get_type(); diff --git a/adw/src/breakpoint.cpp b/adw/src/breakpoint.cpp index 01e68ca..e19db41 100644 --- a/adw/src/breakpoint.cpp +++ b/adw/src/breakpoint.cpp @@ -1,4 +1,5 @@ #include "adwaitamm/breakpoint.hpp" +#include "adwaitamm/private/breakpoint_p.hpp" #include "adwaitamm/enums.hpp" @@ -88,31 +89,9 @@ namespace Adwaita { namespace { - auto constinit _class = Breakpoint::Class{}; + auto constinit _class = Breakpoint_Class{}; } // namespace - auto Breakpoint::Class::init() -> Glib::Class const & - { - if (!gtype_) - { - class_init_func_ = &class_init_function; - gtype_ = adw_breakpoint_get_type(); - Gtk::Buildable::add_interface(get_type()); - } - return *this; - } - - auto Breakpoint::Class::class_init_function(void * gclass, void * data) -> void - { - auto const klass = static_cast(gclass); - CppClassParent::class_init_function(klass, data); - } - - auto Breakpoint::Class::wrap_new(GObject * object) -> Glib::ObjectBase * - { - return new Breakpoint{ADW_BREAKPOINT(object)}; - } - Breakpoint::Breakpoint(BreakpointCondition & condition) : Glib::ObjectBase{nullptr} , Glib::Object{Glib::ConstructParams{_class.init(), "condition", condition.m_object, nullptr}} diff --git a/adw/src/dialog.cpp b/adw/src/dialog.cpp index e240d7f..6f34d3d 100644 --- a/adw/src/dialog.cpp +++ b/adw/src/dialog.cpp @@ -1,6 +1,7 @@ #include "adwaitamm/dialog.hpp" #include "adwaitamm/breakpoint.hpp" +#include "adwaitamm/private/dialog_p.hpp" #include #include @@ -25,31 +26,9 @@ namespace Adwaita namespace { - auto constinit _class = Dialog::Class{}; + auto constinit _class = Dialog_Class{}; } // namespace - auto Dialog::Class::init() -> Glib::Class const & - { - if (!gtype_) - { - class_init_func_ = &class_init_function; - register_derived_type(adw_dialog_get_type()); - Gtk::ShortcutManager::add_interface(get_type()); - } - return *this; - } - - auto Dialog::Class::class_init_function(void * gclass, void * data) -> void - { - auto const klass = static_cast(gclass); - CppClassParent::class_init_function(klass, data); - } - - auto Dialog::Class::wrap_new(GObject * object) -> Glib::ObjectBase * - { - return Gtk::manage(new Dialog(ADW_DIALOG(object))); - } - auto Dialog::get_type() -> GType { return _class.init().get_type(); diff --git a/adw/src/preferencesdialog.cpp b/adw/src/preferencesdialog.cpp index 8c69fef..19c9e35 100644 --- a/adw/src/preferencesdialog.cpp +++ b/adw/src/preferencesdialog.cpp @@ -2,6 +2,7 @@ #include "adwaitamm/dialog.hpp" #include "adwaitamm/preferencespage.hpp" +#include "adwaitamm/private/preferencesdialog_p.hpp" #include #include @@ -24,30 +25,9 @@ namespace Adwaita { namespace { - auto constinit _class = PreferencesDialog::Class{}; + auto constinit _class = PreferencesDialog_Class{}; } // namespace - auto PreferencesDialog::Class::init() -> Glib::Class const & - { - if (!gtype_) - { - class_init_func_ = &class_init_function; - register_derived_type(adw_preferences_dialog_get_type()); - } - return *this; - } - - auto PreferencesDialog::Class::class_init_function(void * gclass, void * data) -> void - { - auto const klass = static_cast(gclass); - CppClassParent::class_init_function(klass, data); - } - - auto PreferencesDialog::Class::wrap_new(GObject * object) -> Glib::ObjectBase * - { - return Gtk::manage(new PreferencesDialog(ADW_PREFERENCES_DIALOG(object))); - } - auto PreferencesDialog::get_type() -> GType { return _class.init().get_type(); diff --git a/adw/src/preferencespage.cpp b/adw/src/preferencespage.cpp index e2b3e80..0c10d97 100644 --- a/adw/src/preferencespage.cpp +++ b/adw/src/preferencespage.cpp @@ -1,5 +1,7 @@ #include "adwaitamm/preferencespage.hpp" +#include "adwaitamm/private/preferencespage_p.hpp" + #include #include #include @@ -21,30 +23,9 @@ namespace Adwaita { namespace { - auto constinit _class = PreferencesPage::Class{}; + auto constinit _class = PreferencesPage_Class{}; } // namespace - auto PreferencesPage::Class::init() -> Glib::Class const & - { - if (!gtype_) - { - class_init_func_ = &class_init_function; - register_derived_type(adw_preferences_page_get_type()); - } - return *this; - } - - auto PreferencesPage::Class::class_init_function(void * gclass, void * data) -> void - { - auto const klass = static_cast(gclass); - CppClassParent::class_init_function(klass, data); - } - - auto PreferencesPage::Class::wrap_new(GObject * object) -> Glib::ObjectBase * - { - return Gtk::manage(new PreferencesPage(ADW_PREFERENCES_PAGE(object))); - } - auto PreferencesPage::get_type() -> GType { return _class.init().get_type(); diff --git a/adw/src/preferencesrow.cpp b/adw/src/preferencesrow.cpp index fe6410f..e54bebe 100644 --- a/adw/src/preferencesrow.cpp +++ b/adw/src/preferencesrow.cpp @@ -1,5 +1,7 @@ #include "adwaitamm/preferencesrow.hpp" +#include "adwaitamm/private/preferencesrow_p.hpp" + #include #include #include @@ -22,30 +24,9 @@ namespace Adwaita { namespace { - auto constinit _class = PreferencesRow::Class{}; + auto constinit _class = PreferencesRow_Class{}; } // namespace - auto PreferencesRow::Class::init() -> Glib::Class const & - { - if (!gtype_) - { - class_init_func_ = &class_init_function; - register_derived_type(adw_preferences_row_get_type()); - } - return *this; - } - - auto PreferencesRow::Class::class_init_function(void * gclass, void * data) -> void - { - auto const klass = static_cast(gclass); - CppClassParent::class_init_function(klass, data); - } - - auto PreferencesRow::Class::wrap_new(GObject * object) -> Glib::ObjectBase * - { - return Gtk::manage(new PreferencesRow(ADW_PREFERENCES_ROW(object))); - } - auto PreferencesRow::get_type() -> GType { return _class.init().get_type(); diff --git a/adw/src/private/actionrow_p.cpp b/adw/src/private/actionrow_p.cpp new file mode 100644 index 0000000..843c330 --- /dev/null +++ b/adw/src/private/actionrow_p.cpp @@ -0,0 +1,35 @@ +#include "adwaitamm/private/actionrow_p.hpp" + +#include "adwaitamm/actionrow.hpp" +#include "adwaitamm/private/preferencesrow_p.hpp" // IWYU pragma: keep - Required for CppClassParent:: + +#include +#include + +#include + +#include + +namespace Adwaita +{ + auto ActionRow_Class::init() -> Glib::Class const & + { + if (!gtype_) + { + class_init_func_ = &class_init_function; + register_derived_type(adw_action_row_get_type()); + } + return *this; + } + + auto ActionRow_Class::class_init_function(void * gclass, void * data) -> void + { + auto const klass = static_cast(gclass); + CppClassParent::class_init_function(klass, data); + } + + auto ActionRow_Class::wrap_new(GObject * object) -> Glib::ObjectBase * + { + return Gtk::manage(new ActionRow(ADW_ACTION_ROW(object))); + } +} // namespace Adwaita \ No newline at end of file diff --git a/adw/src/private/alertdialog_p.cpp b/adw/src/private/alertdialog_p.cpp new file mode 100644 index 0000000..524446f --- /dev/null +++ b/adw/src/private/alertdialog_p.cpp @@ -0,0 +1,37 @@ +#include "adwaitamm/private/alertdialog_p.hpp" + +#include "adwaitamm/alertdialog.hpp" + +#include +#include +#include + +#include +#include +#include + +#include + +namespace Adwaita +{ + auto AlertDialog_Class::init() -> Glib::Class const & + { + if (!gtype_) + { + class_init_func_ = &class_init_function; + register_derived_type(adw_alert_dialog_get_type()); + } + return *this; + } + + auto AlertDialog_Class::class_init_function(void * gclass, void * data) -> void + { + auto const klass = static_cast(gclass); + CppClassParent::class_init_function(klass, data); + } + + auto AlertDialog_Class::wrap_new(GObject * object) -> Glib::ObjectBase * + { + return Gtk::manage(new AlertDialog(ADW_ALERT_DIALOG(object))); + } +} // namespace Adwaita \ No newline at end of file diff --git a/adw/src/private/application_p.cpp b/adw/src/private/application_p.cpp new file mode 100644 index 0000000..62a0b98 --- /dev/null +++ b/adw/src/private/application_p.cpp @@ -0,0 +1,33 @@ +#include "adwaitamm/private/application_p.hpp" + +#include "adwaitamm/application.hpp" + +#include +#include +#include + +#include + +namespace Adwaita +{ + auto Application_Class::init() -> Glib::Class const & + { + if (!gtype_) + { + class_init_func_ = &class_init_function; + register_derived_type(adw_application_get_type()); + } + return *this; + } + + auto Application_Class::class_init_function(void * gclass, void * data) -> void + { + auto const klass = static_cast(gclass); + CppClassParent::class_init_function(klass, data); + } + + auto Application_Class::wrap_new(GObject * object) -> Glib::ObjectBase * + { + return new Application(ADW_APPLICATION(object)); + } +} // namespace Adwaita \ No newline at end of file diff --git a/adw/src/private/applicationwindow_p.cpp b/adw/src/private/applicationwindow_p.cpp new file mode 100644 index 0000000..b2ba636 --- /dev/null +++ b/adw/src/private/applicationwindow_p.cpp @@ -0,0 +1,33 @@ +#include "adwaitamm/private/applicationwindow_p.hpp" + +#include "adwaitamm/applicationwindow.hpp" + +#include +#include +#include + +#include + +