adw: extract class definitions

55 files changed, 1067 insertions, 565 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6ca4ad0..6b08199 100644
--- a/CMakeLists.txt
+++ b/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/include/adwaitamm/actionrow.hpp b/include/adwaitamm/actionrow.hpp
index 5b99ab7..6a34e15 100644
--- a/include/adwaitamm/actionrow.hpp
+++ b/include/adwaitamm/actionrow.hpp
@@ -24,23 +24,10 @@ namespace Adwaita
   struct ActionRow : PreferencesRow,
                      helpers::gobj_mixin<ActionRow, AdwActionRow>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::gobj_copy;
@@ -87,6 +74,8 @@ namespace Adwaita
     auto property_title_lines() const noexcept -> Glib::PropertyProxy_ReadOnly<int>;
 
   protected:
+    friend struct ActionRow_Class;
+
     explicit ActionRow(Glib::ConstructParams const & params);
     explicit ActionRow(BaseObjectType * gobj);
   };
diff --git a/include/adwaitamm/alertdialog.hpp b/include/adwaitamm/alertdialog.hpp
index 2a34a45..fb0d88f 100644
--- a/include/adwaitamm/alertdialog.hpp
+++ b/include/adwaitamm/alertdialog.hpp
@@ -17,8 +17,9 @@
 
 #include <glib-object.h>
 
-using AdwAlertDialog = struct _AdwAlertDialog;
-using AdwAlertDialogClass = struct _AdwAlertDialogClass;
+#define _ADWAITA_INSIDE
+#include <adw-alert-dialog.h>
+#undef _ADWAITA_INSIDE
 
 namespace Adwaita
 {
@@ -27,23 +28,10 @@ namespace Adwaita
   struct AlertDialog : Dialog,
                        helpers::gobj_mixin<AlertDialog, AdwAlertDialog>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::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/include/adwaitamm/application.hpp b/include/adwaitamm/application.hpp
index 5242d50..0cbc24f 100644
--- a/include/adwaitamm/application.hpp
+++ b/include/adwaitamm/application.hpp
@@ -4,6 +4,7 @@
 #include "adwaitamm/helpers/gobj_mixin.hpp"
 
 #include <glibmm/class.h>
+#include <glibmm/object.h>
 #include <glibmm/refptr.h>
 #include <glibmm/ustring.h>
 
@@ -11,31 +12,21 @@
 
 #include <gtkmm/application.h>
 
-using AdwApplication = struct _AdwApplication;
-using AdwApplicationClass = struct _AdwApplicationClass;
+#include <glib-object.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-application.h>
+#undef _ADWAITA_INSIDE
 
 namespace Adwaita
 {
   struct Application : Gtk::Application,
                        helpers::gobj_mixin<Application, AdwApplication>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::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<Application>;
+    auto static create(Glib::ustring const & id = {}, Gio::Application::Flags flags = Gio::Application::Flags::NONE)
+        -> Glib::RefPtr<Application>;
 
     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/include/adwaitamm/applicationwindow.hpp b/include/adwaitamm/applicationwindow.hpp
index 310795e..454fad5 100644
--- a/include/adwaitamm/applicationwindow.hpp
+++ b/include/adwaitamm/applicationwindow.hpp
@@ -11,31 +11,21 @@
 #include <gtkmm/application.h>
 #include <gtkmm/applicationwindow.h>
 
-using AdwApplicationWindow = struct _AdwApplicationWindow;
-using AdwApplicationWindowClass = struct _AdwApplicationWindowClass;
+#include <glib-object.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-application-window.h>
+#undef _ADWAITA_INSIDE
 
 namespace Adwaita
 {
   struct ApplicationWindow : Gtk::ApplicationWindow,
                              helpers::gobj_mixin<ApplicationWindow, AdwApplicationWindow>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::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/include/adwaitamm/breakpoint.hpp b/include/adwaitamm/breakpoint.hpp
index 13e9f1e..7bcb2d9 100644
--- a/include/adwaitamm/breakpoint.hpp
+++ b/include/adwaitamm/breakpoint.hpp
@@ -52,23 +52,10 @@ namespace Adwaita
                             Gtk::Buildable,
                             helpers::gobj_mixin<Breakpoint, AdwBreakpoint>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::gobj_copy;
@@ -87,6 +74,8 @@ namespace Adwaita
     auto property_condition() const -> Glib::PropertyProxy_ReadOnly<BreakpointCondition *>;
 
   protected:
+    friend Breakpoint_Class;
+
     explicit Breakpoint(BreakpointCondition & condition);
     explicit Breakpoint(Glib::ConstructParams const & params);
     explicit Breakpoint(BaseObjectType * gobj);
diff --git a/include/adwaitamm/dialog.hpp b/include/adwaitamm/dialog.hpp
index 44dde25..eeaeda1 100644
--- a/include/adwaitamm/dialog.hpp
+++ b/include/adwaitamm/dialog.hpp
@@ -15,34 +15,21 @@
 
 #include <glib-object.h>
 
-using AdwDialog = struct _AdwDialog;
-using AdwDialogClass = struct _AdwDialogClass;
+#define _ADWAITA_INSIDE
+#include <adw-dialog.h>
+#undef _ADWAITA_INSIDE
 
 namespace Adwaita
 {
-  struct Dialog_Class;
-
   struct Dialog : Gtk::Widget,
                   Gtk::ShortcutManager,
                   helpers::gobj_mixin<Dialog, AdwDialog>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::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/include/adwaitamm/helpers/gobj_mixin.hpp b/include/adwaitamm/helpers/gobj_mixin.hpp
index fbdaa4e..762136e 100644
--- a/include/adwaitamm/helpers/gobj_mixin.hpp
+++ b/include/adwaitamm/helpers/gobj_mixin.hpp
@@ -8,27 +8,35 @@
 namespace Adwaita::helpers
 {
 
-  template<typename Type, typename AdwType>
+  template<typename SourceType, typename TargetType>
+  struct copy_const
+  {
+    using type = TargetType;
+  };
+
+  template<typename SourceType, typename TargetType>
+  struct copy_const<SourceType const, TargetType>
+  {
+    using type = std::add_const_t<TargetType>;
+  };
+
+  template<typename SourceType, typename TargetType>
+  using copy_const_t = typename copy_const<SourceType, TargetType>::type;
+
+  template<typename CppType, typename BaseType>
   struct gobj_mixin
   {
     template<typename Self>
     auto gobj(this Self && self) noexcept
     {
-      using clean_type = std::remove_reference_t<Self>;
-      using gobj_type = std::conditional_t<std::is_const_v<clean_type>, std::add_const_t<Glib::Object>, Glib::Object>;
-      using cast_type = std::conditional_t<std::is_const_v<clean_type>, std::add_const_t<AdwType>, AdwType>;
-
-      return reinterpret_cast<cast_type *>(static_cast<gobj_type &&>(self).gobj());
+      using base_type = copy_const_t<std::remove_reference_t<Self>, BaseType>;   
+      return reinterpret_cast<base_type *>(self.::Glib::Object::gobj());
     }
 
     template<typename Self>
-    auto gobj_copy(this Self && self) noexcept -> AdwType *
+    auto gobj_copy(this Self && self) noexcept
     {
-      using clean_type = std::remove_reference_t<Self>;
-      using gobj_type = std::conditional_t<std::is_const_v<clean_type>, std::add_const_t<Glib::Object>, Glib::Object>;
-
-      static_cast<gobj_type &&>(self).reference();
-      return const_cast<AdwType *>(self.gobj());
+      return reinterpret_cast<BaseType *>(self.::Glib::Object::gobj_copy());
     }
   };
 
diff --git a/include/adwaitamm/preferencesdialog.hpp b/include/adwaitamm/preferencesdialog.hpp
index 2beaf64..080651f 100644
--- a/include/adwaitamm/preferencesdialog.hpp
+++ b/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 <glibmm/class.h>
 #include <glibmm/object.h>
@@ -15,33 +15,19 @@
 
 #include <glib-object.h>
 
-using AdwPreferencesDialog = struct _AdwPreferencesDialog;
-using AdwPreferencesDialogClass = struct _AdwPreferencesDialogClass;
+#define _ADWAITA_INSIDE
+#include <adw-preferences-dialog.h>
+#undef _ADWAITA_INSIDE
 
 namespace Adwaita
 {
-  struct PreferencesDialog_Class;
-
   struct PreferencesDialog : Dialog,
                              helpers::gobj_mixin<PreferencesDialog, AdwPreferencesDialog>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::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/include/adwaitamm/preferencespage.hpp b/include/adwaitamm/preferencespage.hpp
index 7e7e9ed..311796f 100644
--- a/include/adwaitamm/preferencespage.hpp
+++ b/include/adwaitamm/preferencespage.hpp
@@ -13,31 +13,20 @@
 
 #include <glib-object.h>
 
-using AdwPreferencesPage = struct _AdwPreferencesPage;
-using AdwPreferencesPageClass = struct _AdwPreferencesPageClass;
+#define _ADWAITA_INSIDE
+#include <adw-preferences-page.h>
+#undef _ADWAITA_INSIDE
 
 namespace Adwaita
 {
   struct PreferencesPage : Gtk::Widget,
                            helpers::gobj_mixin<PreferencesPage, AdwPreferencesPage>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::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/include/adwaitamm/preferencesrow.hpp b/include/adwaitamm/preferencesrow.hpp
index 6c1d6bb..3bbaaec 100644
--- a/include/adwaitamm/preferencesrow.hpp
+++ b/include/adwaitamm/preferencesrow.hpp
@@ -22,23 +22,10 @@ namespace Adwaita
   struct PreferencesRow : Gtk::ListBoxRow,
                           helpers::gobj_mixin<PreferencesRow, AdwPreferencesRow>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::gobj_copy;
@@ -73,6 +60,8 @@ namespace Adwaita
     auto property_use_underline() const -> Glib::PropertyProxy_ReadOnly<bool>;
 
   protected:
+    friend PreferencesRow_Class;
+
     explicit PreferencesRow(Glib::ConstructParams const & params);
     explicit PreferencesRow(BaseObjectType * gobj);
   };
diff --git a/include/adwaitamm/private/actionrow_p.hpp b/include/adwaitamm/private/actionrow_p.hpp
new file mode 100644
index 0000000..5ccce02
--- /dev/null
+++ b/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 <sigc++/signal.h>
+
+#include <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <glib-object.h>
+
+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/include/adwaitamm/private/alertdialog_p.hpp b/include/adwaitamm/private/alertdialog_p.hpp
new file mode 100644
index 0000000..949b4b8
--- /dev/null
+++ b/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 <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/widget.h>
+
+#include <gtk/gtk.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-alert-dialog.h>
+#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/include/adwaitamm/private/application_p.hpp b/include/adwaitamm/private/application_p.hpp
new file mode 100644
index 0000000..b9ac5f6
--- /dev/null
+++ b/include/adwaitamm/private/application_p.hpp
@@ -0,0 +1,33 @@
+#ifndef LIBADWAITAMM_PRIVATE_APPLICATION_P_HPP
+#define LIBADWAITAMM_PRIVATE_APPLICATION_P_HPP
+
+#include <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/application.h>
+
+#include <gtk/gtk.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-application.h>
+#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/include/adwaitamm/private/applicationwindow_p.hpp b/include/adwaitamm/private/applicationwindow_p.hpp
new file mode 100644
index 0000000..d44629e
--- /dev/null
+++ b/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 <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/applicationwindow.h>
+
+#include <gtk/gtk.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-application-window.h>
+#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/include/adwaitamm/private/breakpoint_p.hpp b/include/adwaitamm/private/breakpoint_p.hpp
new file mode 100644
index 0000000..b4f6bc4
--- /dev/null
+++ b/include/adwaitamm/private/breakpoint_p.hpp
@@ -0,0 +1,34 @@
+#ifndef LIBADWAITAMM_PRIVATE_BREAKPOINT_P_HPP
+#define LIBADWAITAMM_PRIVATE_BREAKPOINT_P_HPP
+
+#include <sigc++/signal.h>
+
+#include <glibmm/class.h>
+#include <glibmm/objectbase.h>
+#include <glibmm/private/object_p.h>
+
+#include <glib-object.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-breakpoint.h>
+#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/include/adwaitamm/private/dialog_p.hpp b/include/adwaitamm/private/dialog_p.hpp
new file mode 100644
index 0000000..5f02dba
--- /dev/null
+++ b/include/adwaitamm/private/dialog_p.hpp
@@ -0,0 +1,33 @@
+#ifndef LIBADWAITAMM_PRIVATE_DIALOG_P_HPP
+#define LIBADWAITAMM_PRIVATE_DIALOG_P_HPP
+
+#include <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/widget.h>
+
+#include <gtk/gtk.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-dialog.h>
+#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/include/adwaitamm/private/preferencesdialog_p.hpp b/include/adwaitamm/private/preferencesdialog_p.hpp
new file mode 100644
index 0000000..14f1038
--- /dev/null
+++ b/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 <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/widget.h>
+
+#include <gtk/gtk.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-preferences-dialog.h>
+#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/include/adwaitamm/private/preferencespage_p.hpp b/include/adwaitamm/private/preferencespage_p.hpp
new file mode 100644
index 0000000..0a84a99
--- /dev/null
+++ b/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 <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/widget.h>
+
+#include <gtk/gtk.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-preferences-page.h>
+#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/include/adwaitamm/private/preferencesrow_p.hpp b/include/adwaitamm/private/preferencesrow_p.hpp
new file mode 100644
index 0000000..be0b25b
--- /dev/null
+++ b/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 <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <gtk/gtk.h>
+
+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/include/adwaitamm/private/stylemanager_p.hpp b/include/adwaitamm/private/stylemanager_p.hpp
new file mode 100644
index 0000000..a37eedd
--- /dev/null
+++ b/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 <glibmm/class.h>
+#include <glibmm/objectbase.h>
+#include <glibmm/private/object_p.h>
+
+#include <glib-object.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-style-manager.h>
+#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/include/adwaitamm/private/switchrow_p.hpp b/include/adwaitamm/private/switchrow_p.hpp
new file mode 100644
index 0000000..7c2288b
--- /dev/null
+++ b/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 <sigc++/signal.h>
+
+#include <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <glib-object.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-switch-row.h>
+#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/include/adwaitamm/private/toast_p.hpp b/include/adwaitamm/private/toast_p.hpp
new file mode 100644
index 0000000..2431b32
--- /dev/null
+++ b/include/adwaitamm/private/toast_p.hpp
@@ -0,0 +1,34 @@
+#ifndef LIBADWAITAMM_PRIVATE_TOAST_P_HPP
+#define LIBADWAITAMM_PRIVATE_TOAST_P_HPP
+
+#include <sigc++/signal.h>
+
+#include <glibmm/class.h>
+#include <glibmm/objectbase.h>
+#include <glibmm/private/object_p.h>
+
+#include <glib-object.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-toast.h>
+#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/include/adwaitamm/private/toastoverlay_p.hpp b/include/adwaitamm/private/toastoverlay_p.hpp
new file mode 100644
index 0000000..3fa651b
--- /dev/null
+++ b/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 <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/widget.h>
+
+#include <gtk/gtk.h>
+
+#define _ADWAITA_INSIDE
+#include <adw-toast-overlay.h>
+#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/include/adwaitamm/stylemanager.hpp b/include/adwaitamm/stylemanager.hpp
index 3d370c3..15f0f0e 100644
--- a/include/adwaitamm/stylemanager.hpp
+++ b/include/adwaitamm/stylemanager.hpp
@@ -21,8 +21,6 @@
 #include <adw-style-manager.h>
 #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<StyleManager, AdwStyleManager>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::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/include/adwaitamm/switchrow.hpp b/include/adwaitamm/switchrow.hpp
index 622b58a..c95544e 100644
--- a/include/adwaitamm/switchrow.hpp
+++ b/include/adwaitamm/switchrow.hpp
@@ -26,23 +26,10 @@ namespace Adwaita
   struct SwitchRow final : ActionRow,
                            helpers::gobj_mixin<SwitchRow, AdwSwitchRow>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::gobj_copy;
@@ -64,6 +51,8 @@ namespace Adwaita
     auto property_active() const -> Glib::PropertyProxy_ReadOnly<bool>;
 
   protected:
+    friend SwitchRow_Class;
+
     explicit SwitchRow(Glib::ConstructParams const & params);
     explicit SwitchRow(BaseObjectType * gobj);
   };
diff --git a/include/adwaitamm/toast.hpp b/include/adwaitamm/toast.hpp
index 2c4718b..4aee04d 100644
--- a/include/adwaitamm/toast.hpp
+++ b/include/adwaitamm/toast.hpp
@@ -21,47 +21,40 @@
 #include <adw-toast.h>
 #undef _ADWAITA_INSIDE
 
-using AdwToast = struct _AdwToast;
-
 namespace Adwaita
 {
+  struct Toast_Class;
+
   enum struct ToastPriority;
 
   struct Toast final : Glib::Object,
                        helpers::gobj_mixin<Toast, AdwToast>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
-    using helpers::gobj_mixin<CppObjectType, BaseObjectType>::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<Toast>;
+#pragma mark - GObject Support
+    using helpers::gobj_mixin<CppObjectType, BaseObjectType>::gobj;
+    using helpers::gobj_mixin<CppObjectType, BaseObjectType>::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<Toast>;
+
+#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<Glib::ustring>;
     auto property_action_name() const -> Glib::PropertyProxy_ReadOnly<Glib::ustring>;
     auto property_action_target() -> Glib::PropertyProxy<Glib::VariantBase>;
@@ -97,10 +93,14 @@ namespace Adwaita
     auto property_use_markup() -> Glib::PropertyProxy<bool>;
     auto property_use_markup() const -> Glib::PropertyProxy_ReadOnly<bool>;
 
+#pragma mark - Signals
     auto signal_button_clicked() -> Glib::SignalProxy<void()>;
     auto signal_dismissed() -> Glib::SignalProxy<void()>;
 
   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/include/adwaitamm/toastoverlay.hpp b/include/adwaitamm/toastoverlay.hpp
index 5e2742d..581d14b 100644
--- a/include/adwaitamm/toastoverlay.hpp
+++ b/include/adwaitamm/toastoverlay.hpp
@@ -22,23 +22,10 @@ namespace Adwaita
   struct ToastOverlay final : Gtk::Widget,
                               helpers::gobj_mixin<ToastOverlay, AdwToastOverlay>
   {
-    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<CppObjectType, BaseObjectType>::gobj;
     using helpers::gobj_mixin<CppObjectType, BaseObjectType>::gobj_copy;
@@ -62,6 +49,8 @@ namespace Adwaita
     auto property_child() const -> Glib::PropertyProxy_ReadOnly<Gtk::Widget *>;
 
   protected:
+    friend ToastOverlay_Class;
+
     explicit ToastOverlay(Glib::ConstructParams const & params);
     explicit ToastOverlay(BaseObjectType * gobj);
   };
diff --git a/src/actionrow.cpp b/src/actionrow.cpp
index 297cefc..8242a6e 100644
--- a/src/actionrow.cpp
+++ b/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<BaseClassType *>(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/src/alertdialog.cpp b/src/alertdialog.cpp
index 585d9e8..24c5705 100644
--- a/src/alertdialog.cpp
+++ b/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<BaseClassType *>(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<AlertDialog>
   {
     return Glib::RefPtr<AlertDialog>{new AlertDialog(heading, body)};
diff --git a/src/application.cpp b/src/application.cpp
index 57a0aaa..55caff5 100644
--- a/src/application.cpp
+++ b/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<AdwApplicationClass *>(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/src/applicationwindow.cpp b/src/applicationwindow.cpp
index f4de581..50817d2 100644
--- a/src/applicationwindow.cpp
+++ b/src/applicationwindow.cpp
@@ -1,5 +1,7 @@
 #include "adwaitamm/applicationwindow.hpp"
 
+#include "adwaitamm/private/applicationwindow_p.hpp"
+
 #include <glibmm/class.h>
 #include <glibmm/object.h>
 #include <glibmm/objectbase.h>
@@ -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<BaseClassType *>(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/src/breakpoint.cpp b/src/breakpoint.cpp
index 01e68ca..e19db41 100644
--- a/src/breakpoint.cpp
+++ b/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<BaseClassType *>(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/src/dialog.cpp b/src/dialog.cpp
index e240d7f..6f34d3d 100644
--- a/src/dialog.cpp
+++ b/src/dialog.cpp
@@ -1,6 +1,7 @@
 #include "adwaitamm/dialog.hpp"
 
 #include "adwaitamm/breakpoint.hpp"
+#include "adwaitamm/private/dialog_p.hpp"
 
 #include <glibmm/class.h>
 #include <glibmm/object.h>
@@ -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<BaseClassType *>(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/src/preferencesdialog.cpp b/src/preferencesdialog.cpp
index 8c69fef..19c9e35 100644
--- a/src/preferencesdialog.cpp
+++ b/src/preferencesdialog.cpp
@@ -2,6 +2,7 @@
 
 #include "adwaitamm/dialog.hpp"
 #include "adwaitamm/preferencespage.hpp"
+#include "adwaitamm/private/preferencesdialog_p.hpp"
 
 #include <glibmm/class.h>
 #include <glibmm/object.h>
@@ -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<BaseClassType *>(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/src/preferencespage.cpp b/src/preferencespage.cpp
index e2b3e80..0c10d97 100644
--- a/src/preferencespage.cpp
+++ b/src/preferencespage.cpp
@@ -1,5 +1,7 @@
 #include "adwaitamm/preferencespage.hpp"
 
+#include "adwaitamm/private/preferencespage_p.hpp"
+
 #include <glibmm/class.h>
 #include <glibmm/object.h>
 #include <glibmm/objectbase.h>
@@ -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<BaseClassType *>(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/src/preferencesrow.cpp b/src/preferencesrow.cpp
index fe6410f..e54bebe 100644
--- a/src/preferencesrow.cpp
+++ b/src/preferencesrow.cpp
@@ -1,5 +1,7 @@
 #include "adwaitamm/preferencesrow.hpp"
 
+#include "adwaitamm/private/preferencesrow_p.hpp"
+
 #include <glibmm/class.h>
 #include <glibmm/object.h>
 #include <glibmm/objectbase.h>
@@ -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<BaseClassType *>(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/src/private/actionrow_p.cpp b/src/private/actionrow_p.cpp
new file mode 100644
index 0000000..843c330
--- /dev/null
+++ b/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 <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/object.h>
+
+#include <adwaita.h>
+
+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<BaseClassType *>(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/src/private/alertdialog_p.cpp b/src/private/alertdialog_p.cpp
new file mode 100644
index 0000000..524446f
--- /dev/null
+++ b/src/private/alertdialog_p.cpp
@@ -0,0 +1,37 @@
+#include "adwaitamm/private/alertdialog_p.hpp"
+
+#include "adwaitamm/alertdialog.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/object.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/object.h>
+#include <gtkmm/private/widget_p.h>
+#include <gtkmm/shortcutmanager.h>
+
+#include <adwaita.h>
+
+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<BaseClassType *>(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/src/private/application_p.cpp b/src/private/application_p.cpp
new file mode 100644
index 0000000..62a0b98
--- /dev/null
+++ b/src/private/application_p.cpp
@@ -0,0 +1,33 @@
+#include "adwaitamm/private/application_p.hpp"
+
+#include "adwaitamm/application.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/object.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/private/application_p.h>
+
+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<BaseClassType *>(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/src/private/applicationwindow_p.cpp b/src/private/applicationwindow_p.cpp
new file mode 100644
index 0000000..b2ba636
--- /dev/null
+++ b/src/private/applicationwindow_p.cpp
@@ -0,0 +1,33 @@
+#include "adwaitamm/private/applicationwindow_p.hpp"
+
+#include "adwaitamm/applicationwindow.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/object.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/private/applicationwindow_p.h>
+
+namespace Adwaita
+{
+  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<BaseClassType *>(gclass);
+    CppClassParent::class_init_function(klass, data);
+  }
+
+  auto ApplicationWindow_Class::wrap_new(GObject * object) -> Glib::ObjectBase *
+  {
+    return new ApplicationWindow(ADW_APPLICATION_WINDOW(object));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/private/breakpoint_p.cpp b/src/private/breakpoint_p.cpp
new file mode 100644
index 0000000..5a41a31
--- /dev/null
+++ b/src/private/breakpoint_p.cpp
@@ -0,0 +1,32 @@
+#include "adwaitamm/private/breakpoint_p.hpp"
+
+#include "adwaitamm/breakpoint.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/objectbase.h>
+#include <gtkmm/buildable.h>
+
+namespace Adwaita
+{
+  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<BaseClassType *>(gclass);
+    CppClassParent::class_init_function(klass, data);
+  }
+
+  auto Breakpoint_Class::wrap_new(GObject * object) -> Glib::ObjectBase *
+  {
+    return new Breakpoint(ADW_BREAKPOINT(object));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/private/dialog_p.cpp b/src/private/dialog_p.cpp
new file mode 100644
index 0000000..da19ddc
--- /dev/null
+++ b/src/private/dialog_p.cpp
@@ -0,0 +1,37 @@
+#include "adwaitamm/private/dialog_p.hpp"
+
+#include "adwaitamm/dialog.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/object.h>
+
+#include <gtkmm/object.h>
+#include <gtkmm/private/widget_p.h>
+#include <gtkmm/shortcutmanager.h>
+
+#include <adwaita.h>
+
+namespace Adwaita
+{
+  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<BaseClassType *>(gclass);
+    CppClassParent::class_init_function(klass, data);
+  }
+
+  auto Dialog_Class::wrap_new(GObject * object) -> Glib::ObjectBase *
+  {
+    return Gtk::manage(new Dialog(ADW_DIALOG(object)));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/private/preferencesdialog_p.cpp b/src/private/preferencesdialog_p.cpp
new file mode 100644
index 0000000..f114fa9
--- /dev/null
+++ b/src/private/preferencesdialog_p.cpp
@@ -0,0 +1,37 @@
+#include "adwaitamm/private/preferencesdialog_p.hpp"
+
+#include "adwaitamm/preferencesdialog.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/object.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/object.h>
+#include <gtkmm/private/widget_p.h>
+#include <gtkmm/shortcutmanager.h>
+
+#include <adwaita.h>
+
+namespace Adwaita
+{
+  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<BaseClassType *>(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)));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/private/preferencespage_p.cpp b/src/private/preferencespage_p.cpp
new file mode 100644
index 0000000..b9d9c59
--- /dev/null
+++ b/src/private/preferencespage_p.cpp
@@ -0,0 +1,35 @@
+#include "adwaitamm/private/preferencespage_p.hpp"
+
+#include "adwaitamm/preferencespage.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/object.h>
+
+#include <gtkmm/object.h>
+#include <gtkmm/private/widget_p.h>
+
+#include <adwaita.h>
+
+namespace Adwaita
+{
+  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<BaseClassType *>(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)));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/private/preferencesrow_p.cpp b/src/private/preferencesrow_p.cpp
new file mode 100644
index 0000000..fd5909e
--- /dev/null
+++ b/src/private/preferencesrow_p.cpp
@@ -0,0 +1,34 @@
+#include "adwaitamm/private/preferencesrow_p.hpp"
+
+#include "adwaitamm/preferencesrow.hpp"
+
+#include <glibmm/class.h>
+
+#include <gtkmm/object.h>
+#include <gtkmm/private/listboxrow_p.h>
+
+#include <adwaita.h>
+
+namespace Adwaita
+{
+  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<BaseClassType *>(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)));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/private/stylemanager_p.cpp b/src/private/stylemanager_p.cpp
new file mode 100644
index 0000000..f35c6da
--- /dev/null
+++ b/src/private/stylemanager_p.cpp
@@ -0,0 +1,30 @@
+#include "adwaitamm/private/stylemanager_p.hpp"
+
+#include "adwaitamm/stylemanager.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/objectbase.h>
+
+namespace Adwaita
+{
+  auto StyleManager_Class::init() -> Glib::Class const &
+  {
+    if (!gtype_)
+    {
+      class_init_func_ = &class_init_function;
+      gtype_ = adw_style_manager_get_type();
+    }
+    return *this;
+  }
+
+  auto StyleManager_Class::class_init_function(void * gclass, void * data) -> void
+  {
+    auto const klass = static_cast<BaseClassType *>(gclass);
+    CppClassParent::class_init_function(klass, data);
+  }
+
+  auto StyleManager_Class::wrap_new(GObject * object) -> Glib::ObjectBase *
+  {
+    return new StyleManager(ADW_STYLE_MANAGER(object));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/private/switch_row_p.cpp b/src/private/switch_row_p.cpp
new file mode 100644
index 0000000..71fdf5b
--- /dev/null
+++ b/src/private/switch_row_p.cpp
@@ -0,0 +1,32 @@
+#include "adwaitamm/private/switchrow_p.hpp"
+#include "adwaitamm/switchrow.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/object.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/object.h>
+
+namespace Adwaita
+{
+  auto SwitchRow_Class::init() -> Glib::Class const &
+  {
+    if (!gtype_)
+    {
+      class_init_func_ = &class_init_function;
+      gtype_ = adw_switch_row_get_type();
+    }
+    return *this;
+  }
+
+  auto SwitchRow_Class::class_init_function(void * gclass, void * data) -> void
+  {
+    auto const klass = static_cast<BaseClassType *>(gclass);
+    CppClassParent::class_init_function(klass, data);
+  }
+
+  auto SwitchRow_Class::wrap_new(GObject * object) -> Glib::ObjectBase *
+  {
+    return Gtk::manage(new SwitchRow(ADW_SWITCH_ROW(object)));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/private/toast_p.cpp b/src/private/toast_p.cpp
new file mode 100644
index 0000000..7138835
--- /dev/null
+++ b/src/private/toast_p.cpp
@@ -0,0 +1,29 @@
+#include "adwaitamm/private/toast_p.hpp"
+
+#include "adwaitamm/toast.hpp"
+
+#include <glibmm/class.h>
+
+namespace Adwaita
+{
+  auto Toast_Class::init() -> Glib::Class const &
+  {
+    if (!gtype_)
+    {
+      class_init_func_ = &class_init_function;
+      gtype_ = adw_toast_get_type();
+    }
+    return *this;
+  }
+
+  auto Toast_Class::class_init_function(void * gclass, void * data) -> void
+  {
+    auto const klass = static_cast<BaseClassType *>(gclass);
+    CppClassParent::class_init_function(klass, data);
+  }
+
+  auto Toast_Class::wrap_new(GObject * object) -> Glib::ObjectBase *
+  {
+    return new Toast(ADW_TOAST(object));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/private/toastoverlay_p.cpp b/src/private/toastoverlay_p.cpp
new file mode 100644
index 0000000..744f981
--- /dev/null
+++ b/src/private/toastoverlay_p.cpp
@@ -0,0 +1,37 @@
+#include "adwaitamm/private/toastoverlay_p.hpp"
+
+#include "adwaitamm/toastoverlay.hpp"
+
+#include <glibmm/class.h>
+#include <glibmm/object.h>
+#include <glibmm/objectbase.h>
+
+#include <gtkmm/object.h>
+#include <gtkmm/private/widget_p.h>
+#include <gtkmm/shortcutmanager.h>
+
+#include <adwaita.h>
+
+namespace Adwaita
+{
+  auto ToastOverlay_Class::init() -> Glib::Class const &
+  {
+    if (!gtype_)
+    {
+      class_init_func_ = &class_init_function;
+      register_derived_type(adw_toast_overlay_get_type());
+    }
+    return *this;
+  }
+
+  auto ToastOverlay_Class::class_init_function(void * gclass, void * data) -> void
+  {
+    auto const klass = static_cast<BaseClassType *>(gclass);
+    CppClassParent::class_init_function(klass, data);
+  }
+
+  auto ToastOverlay_Class::wrap_new(GObject * object) -> Glib::ObjectBase *
+  {
+    return Gtk::manage(new ToastOverlay(ADW_TOAST_OVERLAY(object)));
+  }
+}  // namespace Adwaita
\ No newline at end of file
diff --git a/src/stylemanager.cpp b/src/stylemanager.cpp
index 09a966c..f62a162 100644
--- a/src/stylemanager.cpp
+++ b/src/stylemanager.cpp
@@ -1,4 +1,5 @@
 #include "adwaitamm/stylemanager.hpp"
+#include "adwaitamm/private/stylemanager_p.hpp"
 
 #include "adwaitamm/enums.hpp"
 
@@ -25,30 +26,9 @@ namespace Adwaita
 {
   namespace
   {
-    auto constinit _class = StyleManager::Class{};
+    auto constinit _class = StyleManager_Class{};
   }  // namespace
 
-  auto StyleManager::Class::init() -> Glib::Class const &
-  {
-    if (!gtype_)
-    {
-      class_init_func_ = &StyleManager::Class::class_init_function;
-      gtype_ = adw_style_manager_get_type();
-    }
-    return *this;
-  }
-
-  auto StyleManager::Class::class_init_function(void * gclass, void * data) -> void
-  {
-    auto const klass = static_cast<AdwStyleManagerClass *>(gclass);
-    Glib::Object_Class::class_init_function(klass, data);
-  }
-
-  auto StyleManager::Class::wrap_new(GObject * object) -> Glib::ObjectBase *
-  {
-    return new StyleManager(ADW_STYLE_MANAGER(object));
-  }
-
   auto StyleManager::get_default() -> StyleManager *
   {
     return Glib::wrap(adw_style_manager_get_default());
diff --git a/src/switchrow.cpp b/src/switchrow.cpp
index 9c0245e..010c133 100644
--- a/src/switchrow.cpp
+++ b/src/switchrow.cpp
@@ -1,6 +1,7 @@
 #include "adwaitamm/switchrow.hpp"
 
 #include "adwaitamm/actionrow.hpp"
+#include "adwaitamm/private/switchrow_p.hpp"
 
 #include <glibmm/class.h>
 #include <glibmm/object.h>
@@ -19,30 +20,9 @@ namespace Adwaita
 {
   namespace
   {
-    auto constinit _class = SwitchRow::Class{};
+    auto constinit _class = SwitchRow_Class{};
   }  // namespace
 
-  auto SwitchRow::Class::init() -> Glib::Class const &
-  {
-    if (!gtype_)
-    {
-      class_init_func_ = &class_init_function;
-      register_derived_type(adw_switch_row_get_type());
-    }
-    return *this;
-  }
-
-  auto SwitchRow::Class::class_init_function(void * gclass, void * data) -> void
-  {
-    auto const klass = static_cast<BaseClassType *>(gclass);
-    CppClassParent::class_init_function(klass, data);
-  }
-
-  auto SwitchRow::Class::wrap_new(GObject * object) -> Glib::ObjectBase *
-  {
-    return Gtk::manage(new SwitchRow(ADW_SWITCH_ROW(object)));
-  }
-
   SwitchRow::SwitchRow()
       : Glib::ObjectBase{nullptr}
       , ActionRow{Glib::ConstructParams{_class.init()}}
diff --git a/src/toast.cpp b/src/toast.cpp
index 4d66c93..b5cc12c 100644
--- a/src/toast.cpp
+++ b/src/toast.cpp
@@ -1,6 +1,7 @@
 #include "adwaitamm/toast.hpp"
 
 #include "adwaitamm/enums.hpp"
+#include "adwaitamm/private/toast_p.hpp"
 
 #include <glibmm/class.h>
 #include <glibmm/object.h>
@@ -25,7 +26,7 @@ namespace Adwaita
 {
   namespace
   {
-    auto constinit _class = Toast::Class{};
+    auto constinit _class = Toast_Class{};
 
     static const Glib::SignalProxyInfo Toast_signal_button_clicked_info = {"button-clicked",
                                                                            (GCallback)&Glib::SignalProxyNormal::slot0_void_callback,
@@ -37,27 +38,6 @@ namespace Adwaita
 
   }  // namespace
 
-  auto Toast::Class::init() -> Glib::Class const &
-  {
-    if (!gtype_)
-    {
-      class_init_func_ = &class_init_function;
-      gtype_ = adw_toast_get_type();
-    }
-    return *this;
-  }
-
-  auto Toast::Class::class_init_function(void * gclass, void * data) -> void
-  {
-    auto const klass = static_cast<BaseClassType *>(gclass);
-    CppClassParent::class_init_function(klass, data);
-  }
-
-  auto Toast::Class::wrap_new(GObject * object) -> Glib::ObjectBase *
-  {
-    return new Toast(ADW_TOAST(object));
-  }
-
   Toast::Toast(Glib::ustring const & title)
       : Glib::ObjectBase{nullptr}
       , Glib::Object{Glib::ConstructParams{_class.init(), "title", Glib::c_str_or_nullptr(title), nullptr}}
diff --git a/src/toastoverlay.cpp b/src/toastoverlay.cpp
index e59ba62..c4e248f 100644
--- a/src/toastoverlay.cpp
+++ b/src/toastoverlay.cpp
@@ -1,5 +1,6 @@
 #include "adwaitamm/toastoverlay.hpp"
 
+#include "adwaitamm/private/toastoverlay_p.hpp"
 #include "adwaitamm/toast.hpp"
 
 #include <glibmm/class.h>
@@ -24,30 +25,9 @@ namespace Adwaita
 {
   namespace
   {
-    auto constinit _class = ToastOverlay::Class{};
+    auto constinit _class = ToastOverlay_Class{};
   }  // namespace
 
-  auto ToastOverlay::Class::init() -> Glib::Class const &
-  {
-    if (!gtype_)
-    {
-      class_init_func_ = &class_init_function;
-      gtype_ = adw_toast_overlay_get_type();
-    }
-    return *this;
-  }
-
-  auto ToastOverlay::Class::class_init_function(void * gclass, void * data) -> void
-  {
-    auto const klass = static_cast<BaseClassType *>(gclass);
-    CppClassParent::class_init_function(klass, data);
-  }
-
-  auto ToastOverlay::Class::wrap_new(GObject * object) -> Glib::ObjectBase *
-  {
-    return Gtk::manage(new ToastOverlay(ADW_TOAST_OVERLAY(object)));
-  }
-
   auto ToastOverlay::get_type() -> GType
   {
     return _class.init().get_type();
diff --git a/src/wrap_init.cpp b/src/wrap_init.cpp
index f048633..d00105c 100644
--- a/src/wrap_init.cpp
+++ b/src/wrap_init.cpp
@@ -9,6 +9,19 @@
 #include "adwaitamm/preferencesdialog.hpp"
 #include "adwaitamm/preferencespage.hpp"
 #include "adwaitamm/preferencesrow.hpp"
+#include "adwaitamm/private/actionrow_p.hpp"
+#include "adwaitamm/private/alertdialog_p.hpp"
+#include "adwaitamm/private/application_p.hpp"
+#include "adwaitamm/private/applicationwindow_p.hpp"
+#include "adwaitamm/private/breakpoint_p.hpp"
+#include "adwaitamm/private/dialog_p.hpp"
+#include "adwaitamm/private/preferencesdialog_p.hpp"
+#include "adwaitamm/private/preferencespage_p.hpp"
+#include "adwaitamm/private/preferencesrow_p.hpp"
+#include "adwaitamm/private/stylemanager_p.hpp"
+#include "adwaitamm/private/switchrow_p.hpp"
+#include "adwaitamm/private/toast_p.hpp"
+#include "adwaitamm/private/toastoverlay_p.hpp"
 #include "adwaitamm/stylemanager.hpp"
 #include "adwaitamm/switchrow.hpp"
 #include "adwaitamm/toast.hpp"
@@ -19,7 +32,7 @@
 #include <adwaita.h>
 #include <glib-object.h>
 
-#define WRAP_CLASS(Name, name) Glib::wrap_register(adw_##name##_get_type(), &Name::Class::wrap_new)
+#define WRAP_CLASS(Name, name) Glib::wrap_register(adw_##name##_get_type(), &Name##_Class::wrap_new)
 #define ENSURE_TYPE(Name) g_type_ensure(Name::get_type())
 
 namespace Adwaita