diff --git a/app/wm/tracker/lastactivewindow.cpp b/app/wm/tracker/lastactivewindow.cpp
index 67ce603a..5ff19741 100644
--- a/app/wm/tracker/lastactivewindow.cpp
+++ b/app/wm/tracker/lastactivewindow.cpp
@@ -1,417 +1,436 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "lastactivewindow.h"
 
 // local
 #include "trackedgeneralinfo.h"
 #include "trackerwindows.h"
 #include "../abstractwindowinterface.h"
 #include "../tasktools.h"
 #include "../../view/view.h"
 
 // Qt
 #include <QDebug>
 #include <QPoint>
 #include <QTimer>
 
 
 namespace Latte {
 namespace WindowSystem {
 namespace Tracker {
 
 const int INVALIDWID = -1;
+const int PREFHISTORY = 8;
+const int MAXHISTORY = 15;
 
 LastActiveWindow::LastActiveWindow(TrackedGeneralInfo *trackedInfo)
     : QObject(trackedInfo),
       m_trackedInfo(trackedInfo),
       m_windowsTracker(trackedInfo->wm()->windowsTracker()),
       m_wm(trackedInfo->wm())
 {
     connect(m_windowsTracker, &Windows::windowChanged, this, &LastActiveWindow::windowChanged);
     connect(m_windowsTracker, &Windows::windowRemoved, this, &LastActiveWindow::windowRemoved);
 }
 
 LastActiveWindow::~LastActiveWindow()
 {
 }
 
 bool LastActiveWindow::isActive() const
 {
     return m_isActive;
 }
 
 void LastActiveWindow::setActive(bool active)
 {
     if (m_isActive == active) {
         return;
     }
 
     m_isActive = active;
     emit isActiveChanged();
 }
 
 bool LastActiveWindow::isMinimized() const
 {
     return m_isMinimized;
 }
 
 void LastActiveWindow::setIsMinimized(bool minimized)
 {
     if (m_isMinimized == minimized) {
         return;
     }
 
     m_isMinimized = minimized;
     emit isMinimizedChanged();
 }
 
 bool LastActiveWindow::isMaximized() const
 {
     return m_isMaximized;
 }
 
 void LastActiveWindow::setIsMaximized(bool maximized)
 {
     if (m_isMaximized == maximized) {
         return;
     }
 
     m_isMaximized = maximized;
     emit isMaximizedChanged();
 }
 
 bool LastActiveWindow::isFullScreen() const
 {
     return m_isFullScreen;
 }
 
 void LastActiveWindow::setIsFullScreen(bool fullscreen)
 {
     if (m_isFullScreen == fullscreen) {
         return;
     }
 
     m_isFullScreen = fullscreen;
     emit isFullScreenChanged();
 }
 
 bool LastActiveWindow::isKeepAbove() const
 {
     return m_isKeepAbove;
 }
 
 void LastActiveWindow::setIsKeepAbove(bool above)
 {
     if (m_isKeepAbove == above) {
         return;
     }
 
     m_isKeepAbove = above;
     emit isKeepAboveChanged();
 }
 
 bool LastActiveWindow::isOnAllDesktops() const
 {
     return m_isOnAllDesktops;
 }
 
 void LastActiveWindow::setIsOnAllDesktops(bool all)
 {
     if (m_isOnAllDesktops == all) {
         return;
     }
 
     m_isOnAllDesktops = all;
     emit isOnAllDesktopsChanged();
 }
 
 bool LastActiveWindow::isShaded() const
 {
     return m_isShaded;
 }
 
 void LastActiveWindow::setIsShaded(bool shaded)
 {
     if (m_isShaded == shaded) {
         return;
     }
 
     m_isShaded = shaded;
     emit isShadedChanged();
 }
 
 bool LastActiveWindow::isValid() const
 {
     return m_isValid;
 }
 
 void LastActiveWindow::setIsValid(bool valid)
 {
     if (m_isValid == valid) {
         return;
     }
 
     m_isValid = valid;
     emit isValidChanged();
 }
 
 bool LastActiveWindow::hasSkipTaskbar() const
 {
     return m_hasSkipTaskbar;
 }
 
 void LastActiveWindow::setHasSkipTaskbar(bool skip)
 {
     if (m_hasSkipTaskbar == skip) {
         return;
     }
 
     m_hasSkipTaskbar = skip;
     emit hasSkipTaskbarChanged();
 }
 
 QRect LastActiveWindow::geometry() const
 {
     return m_geometry;
 }
 
 void LastActiveWindow::setGeometry(QRect geometry)
 {
     if (m_geometry == geometry) {
         return;
     }
 
     m_geometry = geometry;
     emit geometryChanged();
 }
 
 QString LastActiveWindow::appName() const
 {
     return m_appName;
 }
 
 void LastActiveWindow::setAppName(QString appName)
 {
     if (m_appName == appName) {
         return;
     }
 
     m_appName = appName;
     emit appNameChanged();
 }
 
 QString LastActiveWindow::display() const
 {
     return m_display;
 }
 
 void LastActiveWindow::setDisplay(QString display)
 {
     if (m_display == display) {
         return;
     }
 
     m_display = display;
     emit displayChanged();
 }
 
 QIcon LastActiveWindow::icon() const
 {
     return m_icon;
 }
 
 void LastActiveWindow::setIcon(QIcon icon)
 {
     m_icon = icon;
     emit iconChanged();
 }
 
 QVariant LastActiveWindow::winId() const
 {
     return m_winId;
 }
 
 void LastActiveWindow::setWinId(QVariant winId)
 {
     if (m_winId == winId && isValid()) {
         return;
     }
 
     if (!m_history.contains(winId)) {
         m_history.prepend(winId);
+        clearHistory();
     } else {
         int p = m_history.indexOf(winId);
         //! move to start
         m_history.move(p, 0);
     }
 
     m_winId = winId;
     emit winIdChanged();
 }
 
 void LastActiveWindow::setInformation(const WindowInfoWrap &info)
 {
     setWinId(info.wid());
 
     setIsValid(true);
     setActive(info.isActive());
     setIsMinimized(info.isMinimized());
     setIsMaximized(info.isMaxVert() || info.isMaxHoriz());
     setIsOnAllDesktops(info.isOnAllDesktops());
 
     setAppName(info.appName());
     setDisplay(info.display());
     setGeometry(info.geometry());
     setIsKeepAbove(info.isKeepAbove());
 
     if (info.appName().isEmpty()) {
         setAppName(m_windowsTracker->appNameFor(info.wid()));
     } else {
         setAppName(info.appName());
     }
 
     if (info.icon().isNull()) {
         setIcon(m_windowsTracker->iconFor(info.wid()));
     } else {
         setIcon(info.icon());
     }
 }
 
 //! PRIVATE SLOTS
 void LastActiveWindow::windowChanged(const WindowId &wid)
 {
     if (!m_trackedInfo->enabled()) {
-        qDebug() << " Window Changed : TrackedInfo is disabled...";
+        qDebug() << " Last Active Window, Window Changed : TrackedInfo is disabled...";
         return;
     }
 
     if (m_history.contains(wid)) {
         //! remove from history minimized windows or windows that changed screen
         //! and update information accordingly with the first valid window found from
         //! history after the removal
         WindowInfoWrap winfo = m_windowsTracker->infoFor(wid);
 
         bool firstItemRemoved{false};
 
         //! Remove minimized windows OR NOT-TRACKED windows from history
         if (winfo.isMinimized() || !m_trackedInfo->isTracking(winfo)) {
             if (m_history[0] == wid) {
                 firstItemRemoved = true;
             }
+
             m_history.removeAll(wid);
+            clearHistory();
         }
 
         if (m_history.count() > 0) {
             if (m_history[0] == wid || firstItemRemoved) {
                 WindowInfoWrap history1 = m_windowsTracker->infoFor(m_history[0]);
 
                 //! Check if first found History window is still valid to show its information
                 if (history1.isMinimized() || !m_trackedInfo->isTracking(history1)) {
                     windowChanged(m_history[0]);
                 } else {
                     setInformation(history1);
                 }
             }
         } else {
             //! History is empty so any demonstrated information are invalid
             setIsValid(false);
         }
 
-        qDebug() << " HISTORY ::: " << m_history;
+        //qDebug() << " HISTORY ::: " << m_history;
     } else {
-        qDebug() << " LastActiveWindow : window is not in history";
+        //qDebug() << " LastActiveWindow : window is not in history";
     }
 }
 
 void LastActiveWindow::windowRemoved(const WindowId &wid)
 {
     if (m_history.contains(wid)) {
         bool firstItemRemoved{false};
 
         if (m_history.count() > 0 && m_history[0] == wid) {
             firstItemRemoved = true;
         }
 
+        m_history.removeAll(wid);
         m_history.removeAll(wid);
 
         if (m_history.count() > 0 && firstItemRemoved) {
             windowChanged(m_history[0]);
         } else {
             setIsValid(false);
         }
     }
 }
 
+void LastActiveWindow::clearHistory()
+{
+    if (m_history.count() > MAXHISTORY) {
+        int size = m_history.count();
+        for(int i=0; i<(size-PREFHISTORY); ++i) {
+            if (!m_history.isEmpty()) {
+                m_history.removeLast();
+            }
+        }
+    }
+}
+
+
 //! FUNCTIONALITY
 void LastActiveWindow::requestActivate()
 {
     m_wm->requestActivate(m_winId);
 }
 
 void LastActiveWindow::requestClose()
 {
     m_wm->requestClose(m_winId);
 }
 
 void LastActiveWindow::requestMove(Latte::View *fromView, int localX, int localY)
 {
     QPoint globalPoint{fromView->x() + localX, fromView->y() + localY};
 
     m_wm->requestMoveWindow(m_winId, globalPoint);
 
     auto viewId = m_winId;
 
     //! This timer is needed because otherwise the mouse position
     //! in the dragged window changes to TopLeft corner
     QTimer::singleShot(250, this, [&, viewId]() {
         m_wm->releaseMouseEventFor(viewId);
     });
 
     emit draggingStarted();
 }
 
 void LastActiveWindow::requestToggleIsOnAllDesktops()
 {
     m_wm->requestToggleIsOnAllDesktops(m_winId);
 }
 
 void LastActiveWindow::requestToggleKeepAbove()
 {
     m_wm->requestToggleKeepAbove(m_winId);
 }
 
 void LastActiveWindow::requestToggleMinimized()
 {
     m_wm->requestToggleMinimized(m_winId);
 }
 
 void LastActiveWindow::requestToggleMaximized()
 {
     m_wm->requestToggleMaximized(m_winId);
 }
 
 bool LastActiveWindow::canBeDragged()
 {
     return m_wm->windowCanBeDragged(m_winId);
 }
 
 }
 }
 }
diff --git a/app/wm/tracker/lastactivewindow.h b/app/wm/tracker/lastactivewindow.h
index c96aa157..8c09df44 100644
--- a/app/wm/tracker/lastactivewindow.h
+++ b/app/wm/tracker/lastactivewindow.h
@@ -1,176 +1,178 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef WINDOWSYSTEMLASTACTIVEWINDOW_H
 #define WINDOWSYSTEMLASTACTIVEWINDOW_H
 
 // local
 #include "../windowinfowrap.h"
 #include "../abstractwindowinterface.h"
 
 // Qt
 #include <QObject>
 #include <QRect>
 
 namespace Latte {
 class View;
 namespace WindowSystem {
 class AbstractWindowInterface;
 namespace Tracker {
 class TrackedGeneralInfo;
 class Windows;
 }
 }
 }
 
 namespace Latte {
 namespace WindowSystem {
 namespace Tracker {
 
 class LastActiveWindow : public QObject {
     Q_OBJECT
     Q_PROPERTY(bool isActive READ isActive NOTIFY isActiveChanged)
     Q_PROPERTY(bool isMinimized READ isMinimized NOTIFY isMinimizedChanged)
     Q_PROPERTY(bool isMaximized READ isMaximized NOTIFY isMaximizedChanged)
     Q_PROPERTY(bool isFullScreen READ isFullScreen NOTIFY isFullScreenChanged)
     Q_PROPERTY(bool isKeepAbove READ isKeepAbove NOTIFY isKeepAboveChanged)
     Q_PROPERTY(bool isOnAllDesktops  READ isOnAllDesktops NOTIFY isOnAllDesktopsChanged)
     Q_PROPERTY(bool isShaded READ isShaded NOTIFY isShadedChanged)
     Q_PROPERTY(bool isValid READ isValid NOTIFY isValidChanged)
     Q_PROPERTY(bool hasSkipTaskbar READ hasSkipTaskbar NOTIFY hasSkipTaskbarChanged)
 
     Q_PROPERTY(QString appName READ appName NOTIFY appNameChanged)
     Q_PROPERTY(QString display READ display NOTIFY displayChanged)
     Q_PROPERTY(QRect geometry READ geometry NOTIFY geometryChanged)
 
     Q_PROPERTY(QIcon icon READ icon NOTIFY iconChanged)
 
     Q_PROPERTY(QVariant winId READ winId NOTIFY winIdChanged)
 
 public:
     LastActiveWindow(TrackedGeneralInfo *trackedInfo);
     ~LastActiveWindow() override;
 
     bool isActive() const;
     bool isMinimized() const;
     bool isMaximized() const;
     bool isFullScreen() const;
     bool isKeepAbove() const;
     bool isOnAllDesktops() const;
     bool isShaded() const;
     bool isValid() const;
     bool hasSkipTaskbar() const;
 
     QString appName() const;
     QString display() const;
 
     QRect geometry() const;
     QIcon icon() const;
 
     QVariant winId() const;
 
     void setInformation(const WindowInfoWrap &info);
 
 public slots:
     Q_INVOKABLE void requestActivate();
     Q_INVOKABLE void requestClose();
     Q_INVOKABLE void requestToggleIsOnAllDesktops();
     Q_INVOKABLE void requestToggleKeepAbove();
     Q_INVOKABLE void requestToggleMinimized();
     Q_INVOKABLE void requestToggleMaximized();
 
     Q_INVOKABLE bool canBeDragged();
 
     void requestMove(Latte::View *fromView, int localX, int localY);
 
 private slots:
     void windowChanged(const WindowId &wid);
     void windowRemoved(const WindowId &wid);
 
 
 signals:
     void draggingStarted();
 
     void iconChanged();
     void isActiveChanged();
     void isMinimizedChanged();
     void isMaximizedChanged();
     void isFullScreenChanged();
     void isKeepAboveChanged();
     void isOnAllDesktopsChanged();
     void isShadedChanged();
     void isValidChanged();
     void hasSkipTaskbarChanged();
 
     void appNameChanged();
     void displayChanged();
 
     void geometryChanged();
     void winIdChanged();
 
 private:
     void setActive(bool active);
     void setIsMinimized(bool minimized);
     void setIsMaximized(bool maximized);
     void setIsFullScreen(bool fullscreen);
     void setIsKeepAbove(bool above);
     void setIsOnAllDesktops(bool all);
     void setIsShaded(bool shaded);
     void setIsValid(bool valid);
     void setHasSkipTaskbar(bool skip);
 
     void setAppName(QString appName);
     void setDisplay(QString display);
 
     void setGeometry(QRect geometry);
     void setIcon(QIcon icon);
 
     void setWinId(QVariant winId);
 
+    void clearHistory();
+
 private:
     bool m_isActive{false};
     bool m_isMinimized{false};
     bool m_isMaximized{false};
     bool m_isFullScreen{false};
     bool m_isKeepAbove{false};
     bool m_isOnAllDesktops{false};
     bool m_isShaded{false};
     bool m_isValid{false};
     bool m_hasSkipTaskbar{false};
 
     QString m_appName;
     QString m_display;
 
     QRect m_geometry;
     QIcon m_icon;
 
     QVariant m_winId;
 
     QList<WindowId> m_history;
 
     TrackedGeneralInfo *m_trackedInfo{nullptr};
     AbstractWindowInterface *m_wm{nullptr};
     Tracker::Windows *m_windowsTracker{nullptr};
 };
 
 }
 }
 }
 
 #endif