[Misc] Formatting in Linux platform code.

Author: LukasBanana

sources/Platform/Linux/LinuxDisplayWayland.cpp

@@ -12,11 +12,13 @@
 #include <X11/extensions/Xrandr.h>
 #include <dlfcn.h>
 
+
 namespace LLGL
 {
 
+
 LinuxDisplayWayland::LinuxDisplayWayland(const WaylandDisplayData& data) :
-    data_(data)
+    data_ { data }
 {
 }
 
@@ -25,52 +27,65 @@ bool LinuxDisplayWayland::IsPrimary() const
     return (this == LinuxWaylandState::GetDisplayList()[0]);
 }
 
-UTF8String LinuxDisplayWayland::GetDeviceName() const {
-    return data_.deviceName;
+UTF8String LinuxDisplayWayland::GetDeviceName() const
+{
+    return UTF8String{ data_.deviceName };
 }
 
-Offset2D LinuxDisplayWayland::GetOffset() const {
-    return Offset2D(data_.x, data_.y);
+Offset2D LinuxDisplayWayland::GetOffset() const
+{
+    return Offset2D{ data_.x, data_.y };
 }
 
-float LinuxDisplayWayland::GetScale() const {
+float LinuxDisplayWayland::GetScale() const
+{
     return data_.scale;
 }
 
-bool LinuxDisplayWayland::ResetDisplayMode() {
+bool LinuxDisplayWayland::ResetDisplayMode()
+{
     // TODO
     return true;
 }
 
-bool LinuxDisplayWayland::SetDisplayMode(const DisplayMode& displayMode) {
+bool LinuxDisplayWayland::SetDisplayMode(const DisplayMode& displayMode)
+{
     // TODO
     return true;
 }
 
-DisplayMode LinuxDisplayWayland::GetDisplayMode() const {
+DisplayMode LinuxDisplayWayland::GetDisplayMode() const
+{
     return data_.displayModes[data_.currentdisplayMode];
 }
 
-std::vector<DisplayMode> LinuxDisplayWayland::GetSupportedDisplayModes() const {
+std::vector<DisplayMode> LinuxDisplayWayland::GetSupportedDisplayModes() const
+{
     return data_.displayModes;
 }
 
-bool LinuxDisplayWayland::SetCursorPositionInternal(const Offset2D &position) {
+bool LinuxDisplayWayland::SetCursorPositionInternal(const Offset2D &position)
+{
     // TODO
     return true;
 }
 
-Offset2D LinuxDisplayWayland::GetCursorPositionInternal() {
+Offset2D LinuxDisplayWayland::GetCursorPositionInternal()
+{
     // TODO
     return Offset2D(0, 0);
 }
 
-struct wl_output* LinuxDisplayWayland::GetNative() const {
+struct wl_output* LinuxDisplayWayland::GetNative() const
+{
     return data_.output;
 }
 
+
 } // /namespace LLGL
 
-#endif
+#endif // /LLGL_LINUX_ENABLE_WAYLAND
+
+
 
 // ================================================================================

sources/Platform/Linux/LinuxDisplayWayland.h

@@ -8,6 +8,7 @@
 #ifndef LLGL_LINUX_DISPLAY_WAYLAND_H
 #define LLGL_LINUX_DISPLAY_WAYLAND_H
 
+
 #if LLGL_LINUX_ENABLE_WAYLAND
 
 #include <LLGL/Container/DynamicVector.h>
@@ -18,34 +19,32 @@
 
 struct wl_output;
 
+
 namespace LLGL
 {
 
 
-struct WaylandDisplayData {
-    char deviceName[128] = {};
-
-    std::vector<DisplayMode> displayModes;
-
-    wl_output* output = nullptr;
+struct WaylandDisplayData
+{
+    char                        deviceName[128]     = {};
 
-    uint32_t currentdisplayMode = 0;
+    std::vector<DisplayMode>    displayModes;
 
-    uint32_t name = 0;
+    wl_output*                  output              = nullptr;
 
-    // Physical width in millimeters
-    int widthMM = 0;
+    std::uint32_t               currentdisplayMode  = 0;
+    std::uint32_t               name                = 0;
 
-    // Physical height in millimeters
-    int heightMM = 0;
+    int                         widthMM             = 0; // Physical width in millimeters
+    int                         heightMM            = 0; // Physical height in millimeters
 
-    int x = 0;
-    int y = 0;
+    int                         x                   = 0;
+    int                         y                   = 0;
 
-    int scale = 1;
+    int                         scale               = 1;
 };
 
-class LinuxDisplayWayland : public LinuxDisplay
+class LinuxDisplayWayland final : public LinuxDisplay
 {
 
     public:
@@ -79,14 +78,17 @@ class LinuxDisplayWayland : public LinuxDisplay
         wl_output* GetNative() const;
 
     private:
+
         WaylandDisplayData data_;
 
 };
 
+
 } // /namespace LLGL
 
 #endif // LLGL_LINUX_ENABLE_WAYLAND
 
+
 #endif // LLGL_LINUX_DISPLAY_WAYLAND_H
 
 

sources/Platform/Linux/LinuxDisplayX11.h

@@ -8,11 +8,13 @@
 #ifndef LLGL_LINUX_DISPLAY_X11_H
 #define LLGL_LINUX_DISPLAY_X11_H
 
+
 #include <memory>
 #include <X11/Xlib.h>
 
 #include "LinuxDisplay.h"
 
+
 namespace LLGL
 {
 
@@ -48,7 +50,7 @@ class LinuxSharedDisplayX11
 
 };
 
-class LinuxDisplayX11 : public LinuxDisplay
+class LinuxDisplayX11 final : public LinuxDisplay
 {
 
     public:
@@ -83,6 +85,7 @@ class LinuxDisplayX11 : public LinuxDisplay
 
 };
 
+
 } // /namespace LLGL
 
 

sources/Platform/Linux/LinuxWindow.cpp

@@ -19,6 +19,7 @@
 namespace LLGL
 {
 
+
 static bool IsWaylandSupported()
 {
     const char* const session = getenv("XDG_SESSION_TYPE");
@@ -32,9 +33,11 @@ static bool IsWaylandSupported()
 
 static bool g_isWaylandSupported = IsWaylandSupported();
 
+
 /*
  * Window class
  */
+
 std::unique_ptr<Window> Window::Create(const WindowDescriptor& desc)
 {
     #if LLGL_LINUX_ENABLE_WAYLAND
@@ -43,35 +46,33 @@ std::unique_ptr<Window> Window::Create(const WindowDescriptor& desc)
         return MakeUnique<LinuxWindowWayland>(desc);
     }
     else
+    #endif // /LLGL_LINUX_ENABLE_WAYLAND
     {
-    #endif
         return MakeUnique<LinuxWindowX11>(desc);
-    #if LLGL_LINUX_ENABLE_WAYLAND
     }
-    #endif
 }
 
+
 /*
  * Surface class
  */
+
 bool Surface::ProcessEvents()
 {
-#if LLGL_LINUX_ENABLE_WAYLAND
+    #if LLGL_LINUX_ENABLE_WAYLAND
     if (g_isWaylandSupported)
     {
         double timeout = 0.0;
         LinuxWaylandState::HandleWaylandEvents(&timeout);
 
         for (LinuxWindowWayland* window : LinuxWaylandState::GetWindowList())
-        {
-            window->ProcessEvents();
-        }
+            window->ProcessEventsInternal();
 
         return true;
     }
     else
+    #endif // /LLGL_LINUX_ENABLE_WAYLAND
     {
-#endif
         ::Display* display = LinuxSharedDisplayX11::GetShared()->GetNative();
 
         XEvent event;
@@ -84,16 +85,14 @@ bool Surface::ProcessEvents()
             if (void* userData = LinuxX11Context::Find(display, event.xany.window))
             {
                 LinuxWindowX11* wnd = static_cast<LinuxWindowX11*>(userData);
-                wnd->ProcessEvent(event);
+                wnd->ProcessEventInternal(event);
             }
         }
 
         XFlush(display);
 
         return true;
-#if LLGL_LINUX_ENABLE_WAYLAND
     }
-#endif
 }
 
 } // /namespace LLGL