code formatted

app/abstractwindowinterface.cpp

@@ -19,7 +19,7 @@ AbstractWindowInterface::~AbstractWindowInterface()
 
 }
 
-AbstractWindowInterface *AbstractWindowInterface::getInstance(QQuickWindow * const view, QObject *parent)
+AbstractWindowInterface *AbstractWindowInterface::getInstance(QQuickWindow *const view, QObject *parent)
 {
     if (KWindowSystem::isPlatformWayland()) {
         //! TODO: WaylandWindowInterface

app/visibilitymanager.cpp

@@ -48,53 +48,52 @@ inline void VisibilityManagerPrivate::setMode(Dock::Visibility mode)
     this->mode = mode;
     
     switch (this->mode) {
-    case Dock::AlwaysVisible:
-    {
-        wm->setDockStruts(dockRect, view->location());
-        raiseDock(true);
-    }
-        break;
-    case Dock::AutoHide:
-    {
-        raiseDock(true);
-    }
+        case Dock::AlwaysVisible: {
+            wm->setDockStruts(dockRect, view->location());
+            raiseDock(true);
+        }
         break;
-    case Dock::DodgeActive:
-    {
-        connections[0] = connect(wm.get(), &AbstractWindowInterface::activeWindowChanged
-                                 , this, &VisibilityManagerPrivate::dodgeActive);
-        connections[1] = connect(wm.get(), &AbstractWindowInterface::windowChanged
-                                 , this, &VisibilityManagerPrivate::dodgeActive);
-        
-        dodgeActive(wm->activeWindow());
-    }
+        
+        case Dock::AutoHide: {
+            raiseDock(true);
+        }
         break;
-    case Dock::DodgeMaximized:
-    {
-        connections[0] = connect(wm.get(), &AbstractWindowInterface::windowChanged
-                                 , this, &VisibilityManagerPrivate::dodgeMaximized);
-    }
+        
+        case Dock::DodgeActive: {
+            connections[0] = connect(wm.get(), &AbstractWindowInterface::activeWindowChanged
+                                     , this, &VisibilityManagerPrivate::dodgeActive);
+            connections[1] = connect(wm.get(), &AbstractWindowInterface::windowChanged
+                                     , this, &VisibilityManagerPrivate::dodgeActive);
+                                     
+            dodgeActive(wm->activeWindow());
+        }
         break;
-    case Dock::DodgeAllWindows:
-    {
-        for(const auto & wid : wm->windows()) {
-            windows.insert({wid, wm->requestInfo(wid)}); 
+        
+        case Dock::DodgeMaximized: {
+            connections[0] = connect(wm.get(), &AbstractWindowInterface::windowChanged
+                                     , this, &VisibilityManagerPrivate::dodgeMaximized);
         }
+        break;
+        
+        case Dock::DodgeAllWindows: {
+            for (const auto &wid : wm->windows()) {
+                windows.insert({wid, wm->requestInfo(wid)});
+            }
             
-        connections[0] = connect(wm.get(), &AbstractWindowInterface::windowChanged
-                                 , this, &VisibilityManagerPrivate::dodgeWindows);
+            connections[0] = connect(wm.get(), &AbstractWindowInterface::windowChanged
+                                     , this, &VisibilityManagerPrivate::dodgeWindows);
                                      
-        connections[1] = connect(wm.get(), &AbstractWindowInterface::windowRemoved
-                                 , this, [&](WId wid) {
+            connections[1] = connect(wm.get(), &AbstractWindowInterface::windowRemoved
+            , this, [&](WId wid) {
                 windows.erase(wid);
                 timerCheckWindows.start();
-        });
-        connections[2] = connect(wm.get(), &AbstractWindowInterface::windowAdded
-                                 , this, [&](WId wid) {
+            });
+            connections[2] = connect(wm.get(), &AbstractWindowInterface::windowAdded
+            , this, [&](WId wid) {
                 windows.insert({wid, wm->requestInfo(wid)});
                 timerCheckWindows.start();
-        });
-    }
+            });
+        }
     }
     
     saveConfig();
@@ -246,13 +245,13 @@ inline void VisibilityManagerPrivate::saveConfig()
 inline void VisibilityManagerPrivate::restoreConfig()
 {
     if (!view->containment())
-           return;
+        return;
         
-       auto config = view->containment()->config();
+    auto config = view->containment()->config();
     
-       mode = static_cast<Dock::Visibility>(config.readEntry("visibility", static_cast<int>(Dock::DodgeActive)));
-       timerShow.setInterval(config.readEntry("timerShow", 0));
-       timerHide.setInterval(config.readEntry("timerHide", 0));
+    mode = static_cast<Dock::Visibility>(config.readEntry("visibility", static_cast<int>(Dock::DodgeActive)));
+    timerShow.setInterval(config.readEntry("timerShow", 0));
+    timerHide.setInterval(config.readEntry("timerHide", 0));
 }
 
 bool VisibilityManagerPrivate::event(QEvent *ev)

app/windowinfowrap.cpp

@@ -33,97 +33,97 @@ WindowInfoWrap &WindowInfoWrap::operator=(const WindowInfoWrap &rhs)
     return *this;
 }
 
- bool WindowInfoWrap::operator==(const WindowInfoWrap &rhs) const
+bool WindowInfoWrap::operator==(const WindowInfoWrap &rhs) const
 {
     return m_wid == rhs.m_wid;
 }
 
- bool WindowInfoWrap::operator<(const WindowInfoWrap &rhs) const
+bool WindowInfoWrap::operator<(const WindowInfoWrap &rhs) const
 {
     return m_wid < rhs.m_wid;
 }
 
- bool WindowInfoWrap::operator>(const WindowInfoWrap &rhs) const
+bool WindowInfoWrap::operator>(const WindowInfoWrap &rhs) const
 {
     return m_wid > rhs.m_wid;
 }
 
- bool WindowInfoWrap::isValid() const
+bool WindowInfoWrap::isValid() const
 {
     return m_isValid;
 }
 
- void WindowInfoWrap::setIsValid(bool isValid)
+void WindowInfoWrap::setIsValid(bool isValid)
 {
     m_isValid = isValid;
 }
 
- bool WindowInfoWrap::isActive() const
+bool WindowInfoWrap::isActive() const
 {
     return m_isActive;
 }
 
- void WindowInfoWrap::setIsActive(bool isActive)
+void WindowInfoWrap::setIsActive(bool isActive)
 {
     m_isActive = isActive;
 }
 
- bool WindowInfoWrap::isMinimized() const
+bool WindowInfoWrap::isMinimized() const
 {
     return m_isMinimized;
 }
 
- void WindowInfoWrap::setIsMinimized(bool isMinimized)
+void WindowInfoWrap::setIsMinimized(bool isMinimized)
 {
     m_isMinimized = isMinimized;
 }
 
- bool WindowInfoWrap::isMaximized() const
+bool WindowInfoWrap::isMaximized() const
 {
     return m_isMaximized;
 }
 
- void WindowInfoWrap::setIsMaximized(bool isMaximized)
+void WindowInfoWrap::setIsMaximized(bool isMaximized)
 {
     m_isMaximized = isMaximized;
 }
 
- bool WindowInfoWrap::isFullscreen() const
+bool WindowInfoWrap::isFullscreen() const
 {
     return m_isFullscreen;
 }
 
- void WindowInfoWrap::setIsFullscreen(bool isFullscreen)
+void WindowInfoWrap::setIsFullscreen(bool isFullscreen)
 {
     m_isFullscreen = isFullscreen;
 }
 
- bool WindowInfoWrap::isOnCurrentDesktop() const
+bool WindowInfoWrap::isOnCurrentDesktop() const
 {
     return m_isOnCurrentDesktop;
 }
 
- void WindowInfoWrap::setIsOnCurrentDesktop(bool isOnCurrentDesktop)
+void WindowInfoWrap::setIsOnCurrentDesktop(bool isOnCurrentDesktop)
 {
     m_isOnCurrentDesktop = isOnCurrentDesktop;
 }
 
- QRect WindowInfoWrap::geometry() const
+QRect WindowInfoWrap::geometry() const
 {
     return m_geometry;
 }
 
- void WindowInfoWrap::setGeometry(const QRect &geometry)
+void WindowInfoWrap::setGeometry(const QRect &geometry)
 {
     m_geometry = geometry;
 }
 
- WId WindowInfoWrap::wid() const
+WId WindowInfoWrap::wid() const
 {
     return m_wid;
 }
 
- void WindowInfoWrap::setWid(WId wid)
+void WindowInfoWrap::setWid(WId wid)
 {
     m_wid = wid;
 }