Run clang-format on glib .h files.

1 files changed, 45 insertions, 34 deletions

diff --git a/glib/glibmm/wrap.h b/glib/glibmm/wrap.h
index 9b7d141b..36dff859 100644
--- a/glib/glibmm/wrap.h
+++ b/glib/glibmm/wrap.h
@@ -31,7 +31,7 @@ class ObjectBase;
 class Object;
 
 // Type of the per-class wrap_new() functions.
-typedef Glib::ObjectBase* (*WrapNewFunction) (GObject*);
+typedef Glib::ObjectBase* (*WrapNewFunction)(GObject*);
 
 // Setup and free the structures used by wrap_register().
 // Both functions might be called more than once.
@@ -45,41 +45,48 @@ void wrap_register(GType type, WrapNewFunction func);
 // or automatically generate a new wrapper if there's none.
 Glib::ObjectBase* wrap_auto(GObject* object, bool take_copy = false);
 
-/** Create a C++ instance of a known C++ type that is mostly closely associated with the GType of the C object.
+/** Create a C++ instance of a known C++ type that is mostly closely associated with the GType of
+ * the C object.
  * @param object The C object which should be placed in a new C++ instance.
- * @param interface_gtype The returned instance will implement this interface. Otherwise it will be NULL.
+ * @param interface_gtype The returned instance will implement this interface. Otherwise it will be
+ * NULL.
  */
 Glib::ObjectBase* wrap_create_new_wrapper_for_interface(GObject* object, GType interface_gtype);
 
 // Return the current C++ wrapper instance of the GObject,
 // or automatically generate a new wrapper if there's none.
-template<class TInterface>
-TInterface* wrap_auto_interface(GObject* object, bool take_copy = false)
+template <class TInterface>
+TInterface*
+wrap_auto_interface(GObject* object, bool take_copy = false)
 {
-  if(!object)
+  if (!object)
     return nullptr;
 
   // Look up current C++ wrapper instance:
   ObjectBase* pCppObject = ObjectBase::_get_current_wrapper(object);
 
-  if(!pCppObject)
+  if (!pCppObject)
   {
     // There's not already a wrapper: generate a new C++ instance.
-    // We use exact_type_only=true avoid creating Glib::Object for interfaces of unknown implementation,
-    // because we do not want a C++ object that does not dynamic_cast to the expected interface type.
+    // We use exact_type_only=true avoid creating Glib::Object for interfaces of unknown
+    // implementation,
+    // because we do not want a C++ object that does not dynamic_cast to the expected interface
+    // type.
     pCppObject = wrap_create_new_wrapper_for_interface(object, TInterface::get_base_type());
   }
 
-  //If no exact wrapper was created,
-  //create an instance of the interface,
-  //so we at least get the expected type:
+  // If no exact wrapper was created,
+  // create an instance of the interface,
+  // so we at least get the expected type:
   TInterface* result = nullptr;
-  if(pCppObject)
+  if (pCppObject)
   {
     result = dynamic_cast<TInterface*>(pCppObject);
-    if(!result)
+    if (!result)
     {
-      g_warning("Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the interface.\n", typeid(*pCppObject).name());
+      g_warning("Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the "
+                "interface.\n",
+        typeid(*pCppObject).name());
     }
   }
   else
@@ -87,13 +94,13 @@ TInterface* wrap_auto_interface(GObject* object, bool take_copy = false)
 
   // take_copy=true is used where the GTK+ function doesn't do
   // an extra ref for us, and always for plain struct members.
-  if(take_copy && result)
+  if (take_copy && result)
     result->reference();
 
   return result;
 }
 
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif // DOXYGEN_SHOULD_SKIP_THIS
 
 // Get a C++ instance that wraps the C instance.
 // This always returns the same C++ instance for the same C instance.
@@ -103,12 +110,12 @@ TInterface* wrap_auto_interface(GObject* object, bool take_copy = false)
 /** @relates Glib::Object */
 Glib::RefPtr<Glib::Object> wrap(GObject* object, bool take_copy = false);
 
-
 /** Get the underlying C instance from the C++ instance.  This is just
  * like calling gobj(), but it does its own check for a NULL pointer.
  */
-template <class T> inline
-typename T::BaseObjectType* unwrap(T* ptr)
+template <class T>
+inline typename T::BaseObjectType*
+unwrap(T* ptr)
 {
   return (ptr) ? ptr->gobj() : nullptr;
 }
@@ -116,8 +123,9 @@ typename T::BaseObjectType* unwrap(T* ptr)
 /** Get the underlying C instance from the C++ instance.  This is just
  * like calling gobj(), but it does its own check for a NULL pointer.
  */
-template <class T> inline
-const typename T::BaseObjectType* unwrap(const T* ptr)
+template <class T>
+inline const typename T::BaseObjectType*
+unwrap(const T* ptr)
 {
   return (ptr) ? ptr->gobj() : nullptr;
 }
@@ -125,8 +133,9 @@ const typename T::BaseObjectType* unwrap(const T* ptr)
 /** Get the underlying C instance from the C++ instance.  This is just
  * like calling gobj(), but it does its own check for a NULL pointer.
  */
-template <class T> inline
-typename T::BaseObjectType* unwrap(const Glib::RefPtr<T>& ptr)
+template <class T>
+inline typename T::BaseObjectType*
+unwrap(const Glib::RefPtr<T>& ptr)
 {
   return (ptr) ? ptr->gobj() : nullptr;
 }
@@ -134,8 +143,9 @@ typename T::BaseObjectType* unwrap(const Glib::RefPtr<T>& ptr)
 /** Get the underlying C instance from the C++ instance.  This is just
  * like calling gobj(), but it does its own check for a NULL pointer.
  */
-template <class T> inline
-const typename T::BaseObjectType* unwrap(const Glib::RefPtr<const T>& ptr)
+template <class T>
+inline const typename T::BaseObjectType*
+unwrap(const Glib::RefPtr<const T>& ptr)
 {
   return (ptr) ? ptr->gobj() : nullptr;
 }
@@ -148,8 +158,9 @@ const typename T::BaseObjectType* unwrap(const Glib::RefPtr<const T>& ptr)
  * reference or copy. This is just like calling gobj_copy(), but it does its own
  * check for a NULL pointer to the underlying C instance.
  */
-template <class T> inline
-typename T::BaseObjectType* unwrap_copy(const T& obj)
+template <class T>
+inline typename T::BaseObjectType*
+unwrap_copy(const T& obj)
 {
   return obj.gobj() ? obj.gobj_copy() : nullptr;
 }
@@ -158,8 +169,9 @@ typename T::BaseObjectType* unwrap_copy(const T& obj)
  * reference.  This is just like calling gobj_copy(), but it does its own
  * check for a NULL pointer.
  */
-template <class T> inline
-typename T::BaseObjectType* unwrap_copy(const Glib::RefPtr<T>& ptr)
+template <class T>
+inline typename T::BaseObjectType*
+unwrap_copy(const Glib::RefPtr<T>& ptr)
 {
   return (ptr) ? ptr->gobj_copy() : nullptr;
 }
@@ -168,14 +180,13 @@ typename T::BaseObjectType* unwrap_copy(const Glib::RefPtr<T>& ptr)
  * reference.  This is just like calling gobj_copy(), but it does its own
  * check for a NULL pointer.
  */
-template <class T> inline
-const typename T::BaseObjectType* unwrap_copy(const Glib::RefPtr<const T>& ptr)
+template <class T>
+inline const typename T::BaseObjectType*
+unwrap_copy(const Glib::RefPtr<const T>& ptr)
 {
   return (ptr) ? ptr->gobj_copy() : nullptr;
 }
 
 } // namespace Glib
 
-
 #endif /* _GLIBMM_WRAP_H */
-