kastet/latte-dock
1
0
Fork 0
mirror of https://github.com/KDE/latte-dock.git synced 2025-01-10 21:18:19 +03:00
Code Issues Projects Releases Wiki Activity

move View::HelperWindows in their own directory

Browse Source 
--at the same time create a base SubWindow class for
all window helpers used by Views. Now ScreenEdgeGhostWindow
and FloatingGapWindow use the same window implementation
This commit is contained in:
Michail Vourlakos 2020-01-22 19:45:13 +02:00
parent a0582ac409
commit 4b1580c0bd
13 changed files with 516 additions and 597 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
app/CMakeLists.txt
View File

@ -18,6 +18,7 @@ add_subdirectory(settings/delegates)
add_subdirectory(settings/tools)
add_subdirectory(shortcuts)
add_subdirectory(view)
add_subdirectory(view/helpers)
add_subdirectory(view/indicator)
add_subdirectory(view/settings)
add_subdirectory(view/windowstracker)

4
app/view/CMakeLists.txt
View File

@ -3,13 +3,9 @@ set(lattedock-app_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/containmentinterface.cpp
${CMAKE_CURRENT_SOURCE_DIR}/contextmenu.cpp
${CMAKE_CURRENT_SOURCE_DIR}/effects.cpp
${CMAKE_CURRENT_SOURCE_DIR}/floatinggapwindow.cpp
${CMAKE_CURRENT_SOURCE_DIR}/panelshadows.cpp
${CMAKE_CURRENT_SOURCE_DIR}/positioner.cpp
${CMAKE_CURRENT_SOURCE_DIR}/screenedgeghostwindow.cpp
${CMAKE_CURRENT_SOURCE_DIR}/view.cpp
${CMAKE_CURRENT_SOURCE_DIR}/visibilitymanager.cpp
${CMAKE_CURRENT_SOURCE_DIR}/settings/primaryconfigview.cpp
${CMAKE_CURRENT_SOURCE_DIR}/settings/secondaryconfigview.cpp
PARENT_SCOPE
)

7
app/view/helpers/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
set(lattedock-app_SRCS
${lattedock-app_SRCS}
${CMAKE_CURRENT_SOURCE_DIR}/floatinggapwindow.cpp
${CMAKE_CURRENT_SOURCE_DIR}/screenedgeghostwindow.cpp
${CMAKE_CURRENT_SOURCE_DIR}/subwindow.cpp
PARENT_SCOPE
)

163
app/view/helpers/floatinggapwindow.cpp Normal file
View File

@ -0,0 +1,163 @@
/*
* Copyright 2020 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 "floatinggapwindow.h"
// local
#include "../view.h"
// Qt
#include <QDebug>
#include <QSurfaceFormat>
#include <QQuickView>
#include <QTimer>
// KDE
#include <KWayland/Client/plasmashell.h>
#include <KWayland/Client/surface.h>
#include <KWindowSystem>
// X11
#include <NETWM>
namespace Latte {
namespace ViewPart {
FloatingGapWindow::FloatingGapWindow(Latte::View *view) :
SubWindow(view, QString("Floating Gap Window"))
{
if (m_debugMode) {
m_showColor = QColor("green");
m_hideColor = QColor("red");
} else {
m_showColor = QColor(Qt::transparent);
m_hideColor = QColor(Qt::transparent);
m_showColor.setAlpha(0);
m_hideColor.setAlpha(1);
}
setColor(m_showColor);
//! this timer is used in order to identify if mouse is still present in sensitive floating
//! areas and in such case to prevent a real-floating view to hide itself
m_asyncMouseTimer.setSingleShot(true);
m_asyncMouseTimer.setInterval(200);
connect(&m_asyncMouseTimer, &QTimer::timeout, this, [this]() {
if (m_inAsyncContainsMouse && !m_containsMouse) {
emit asyncContainsMouseChanged(false);
hideWithMask();
m_inAsyncContainsMouse = false;
}
});
updateGeometry();
hideWithMask();
}
FloatingGapWindow::~FloatingGapWindow()
{
}
void FloatingGapWindow::updateGeometry()
{
if (m_latteView->positioner()->slideOffset() != 0) {
return;
}
QRect newGeometry;
m_thickness = m_latteView->screenEdgeMargin();
int length = m_latteView->formFactor() == Plasma::Types::Horizontal ? m_latteView->absoluteGeometry().width() : m_latteView->absoluteGeometry().height();
if (m_latteView->location() == Plasma::Types::BottomEdge) {
int xF = qMax(m_latteView->screenGeometry().left(), m_latteView->absoluteGeometry().left());
newGeometry.setX(xF);
newGeometry.setY(m_latteView->screenGeometry().bottom() - m_thickness);
} else if (m_latteView->location() == Plasma::Types::TopEdge) {
int xF = qMax(m_latteView->screenGeometry().left(), m_latteView->absoluteGeometry().left());
newGeometry.setX(xF);
newGeometry.setY(m_latteView->screenGeometry().top());
} else if (m_latteView->location() == Plasma::Types::LeftEdge) {
int yF = qMax(m_latteView->screenGeometry().top(), m_latteView->absoluteGeometry().top());
newGeometry.setX(m_latteView->screenGeometry().left());
newGeometry.setY(yF);
} else if (m_latteView->location() == Plasma::Types::RightEdge) {
int yF = qMax(m_latteView->screenGeometry().top(), m_latteView->absoluteGeometry().top());
newGeometry.setX(m_latteView->screenGeometry().right() - m_thickness);
newGeometry.setY(yF);
}
if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
newGeometry.setWidth(length);
newGeometry.setHeight(m_thickness + 1);
} else {
newGeometry.setWidth(m_thickness + 1);
newGeometry.setHeight(length);
}
m_calculatedGeometry = newGeometry;
emit calculatedGeometryChanged();
}
bool FloatingGapWindow::event(QEvent *e)
{
if (e->type() == QEvent::DragEnter || e->type() == QEvent::DragMove) {
m_containsMouse = true;
} else if (e->type() == QEvent::Enter) {
m_containsMouse = true;
triggerAsyncContainsMouseSignals();
} else if (e->type() == QEvent::Leave || e->type() == QEvent::DragLeave) {
m_containsMouse = false;
if (m_inAsyncContainsMouse) {
m_asyncMouseTimer.stop();
m_inAsyncContainsMouse = false;
emit asyncContainsMouseChanged(true);
}
}
return SubWindow::event(e);
}
void FloatingGapWindow::callAsyncContainsMouse()
{
m_inAsyncContainsMouse = true;
m_asyncMouseTimer.start();
showWithMask();
}
void FloatingGapWindow::triggerAsyncContainsMouseSignals()
{
if (!m_inAsyncContainsMouse) {
return;
}
//! this function is called QEvent::Enter
m_asyncMouseTimer.stop();
hideWithMask();
}
}
}

58
app/view/floatinggapwindow.h → app/view/helpers/floatinggapwindow.h
View File

@ -21,8 +21,9 @@
#define FLOATINGWINDOW_H
// local
#include "../lattecorona.h"
#include "../wm/windowinfowrap.h"
#include "subwindow.h"
#include "../../lattecorona.h"
#include "../../wm/windowinfowrap.h"
// Qt
#include <QObject>
@ -57,7 +58,7 @@ namespace ViewPart {
//! is present, an FloatingGapWindow::asyncContainsMouse(contains) signal
//! is sent.
class FloatingGapWindow : public QQuickView
class FloatingGapWindow : public SubWindow
{
Q_OBJECT
@ -65,73 +66,24 @@ public:
FloatingGapWindow(Latte::View *view);
~FloatingGapWindow() override;
int location();
int thickness() const;
void hideWithMask();
void showWithMask();
Latte::View *parentView();
KWayland::Client::PlasmaShellSurface *surface();
void callAsyncContainsMouse();
signals:
void asyncContainsMouseChanged(bool contains); //called from visibility to check if mouse is in the free sensitive floating area
void dragEntered();
void forcedShown(); //[workaround] forced shown to avoid a KWin issue that hides windows when activities are stopped
protected:
bool event(QEvent *ev) override;
private slots:
void startGeometryTimer();
void updateGeometry();
void fixGeometry();
void updateGeometry() override;
private:
bool containsMouse() const;
void setContainsMouse(bool contains);
void setupWaylandIntegration();
void triggerAsyncContainsMouseSignals();
private:
bool m_debugMode{false};
bool m_containsMouse{false};
bool m_inDelete{false};
bool m_inAsyncContainsMouse{false}; //called from visibility to check if mouse is in the free sensitive floating area
int m_thickness{2};
QRect m_calculatedGeometry;
//! [workaround] colors in order to help masking to apply immediately
//! for some reason when the window in with no content the mask is not
//! update immediately
QColor m_hideColor;
QColor m_showColor;
QTimer m_asyncMouseTimer; //called from visibility to check if mouse is in the free sensitive floating area
QTimer m_fixGeometryTimer;
//! HACK: Timers in order to handle KWin faulty
//! behavior that hides Views when closing Activities
//! with no actual reason
QTimer m_visibleHackTimer1;
QTimer m_visibleHackTimer2;
//! Connections for the KWin visibility hack
QList<QMetaObject::Connection> connectionsHack;
Latte::View *m_latteView{nullptr};
QPointer<Latte::Corona> m_corona;
Latte::WindowSystem::WindowId m_trackedWindowId;
KWayland::Client::PlasmaShellSurface *m_shellSurface{nullptr};
};
}

176
app/view/helpers/screenedgeghostwindow.cpp Normal file
View File

@ -0,0 +1,176 @@
/*
* Copyright 2018 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 "screenedgeghostwindow.h"
// local
#include "../view.h"
// Qt
#include <QDebug>
#include <QSurfaceFormat>
#include <QQuickView>
#include <QTimer>
// KDE
#include <KWayland/Client/plasmashell.h>
#include <KWayland/Client/surface.h>
#include <KWindowSystem>
// X11
#include <NETWM>
namespace Latte {
namespace ViewPart {
ScreenEdgeGhostWindow::ScreenEdgeGhostWindow(Latte::View *view) :
SubWindow(view, QString("Screen Ghost Window"))
{
if (m_debugMode) {
m_showColor = QColor("purple");
m_hideColor = QColor("blue");
} else {
m_showColor = QColor(Qt::transparent);
m_hideColor = QColor(Qt::transparent);
m_showColor.setAlpha(0);
m_hideColor.setAlpha(1);
}
setColor(m_showColor);
//! this timer is used in order to avoid fast enter/exit signals during first
//! appearing after edge activation
m_delayedMouseTimer.setSingleShot(true);
m_delayedMouseTimer.setInterval(50);
connect(&m_delayedMouseTimer, &QTimer::timeout, this, [this]() {
if (m_delayedContainsMouse) {
setContainsMouse(true);
} else {
setContainsMouse(false);
}
});
updateGeometry();
hideWithMask();
}
ScreenEdgeGhostWindow::~ScreenEdgeGhostWindow()
{
}
void ScreenEdgeGhostWindow::updateGeometry()
{
if (m_latteView->positioner()->slideOffset() != 0) {
return;
}
QRect newGeometry;
if (KWindowSystem::compositingActive()) {
m_thickness = 6;
} else {
m_thickness = 2;
}
int length{30};
int lengthDifference{0};
if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
//! set minimum length to be 25% of screen width
length = qMax(m_latteView->screenGeometry().width()/4,qMin(m_latteView->absoluteGeometry().width(), m_latteView->screenGeometry().width() - 1));
lengthDifference = qMax(0,length - m_latteView->absoluteGeometry().width());
} else {
//! set minimum length to be 25% of screen height
length = qMax(m_latteView->screenGeometry().height()/4,qMin(m_latteView->absoluteGeometry().height(), m_latteView->screenGeometry().height() - 1));
lengthDifference = qMax(0,length - m_latteView->absoluteGeometry().height());
}
if (m_latteView->location() == Plasma::Types::BottomEdge) {
int xF = qMax(m_latteView->screenGeometry().left(), m_latteView->absoluteGeometry().left() - lengthDifference);
newGeometry.setX(xF);
newGeometry.setY(m_latteView->screenGeometry().bottom() - m_thickness);
} else if (m_latteView->location() == Plasma::Types::TopEdge) {
int xF = qMax(m_latteView->screenGeometry().left(), m_latteView->absoluteGeometry().left() - lengthDifference);
newGeometry.setX(xF);
newGeometry.setY(m_latteView->screenGeometry().top());
} else if (m_latteView->location() == Plasma::Types::LeftEdge) {
int yF = qMax(m_latteView->screenGeometry().top(), m_latteView->absoluteGeometry().top() - lengthDifference);
newGeometry.setX(m_latteView->screenGeometry().left());
newGeometry.setY(yF);
} else if (m_latteView->location() == Plasma::Types::RightEdge) {
int yF = qMax(m_latteView->screenGeometry().top(), m_latteView->absoluteGeometry().top() - lengthDifference);
newGeometry.setX(m_latteView->screenGeometry().right() - m_thickness);
newGeometry.setY(yF);
}
if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
newGeometry.setWidth(length);
newGeometry.setHeight(m_thickness + 1);
} else {
newGeometry.setWidth(m_thickness + 1);
newGeometry.setHeight(length);
}
m_calculatedGeometry = newGeometry;
emit calculatedGeometryChanged();
}
bool ScreenEdgeGhostWindow::containsMouse() const
{
return m_containsMouse;
}
void ScreenEdgeGhostWindow::setContainsMouse(bool contains)
{
if (m_containsMouse == contains) {
return;
}
m_containsMouse = contains;
emit containsMouseChanged(contains);
}
bool ScreenEdgeGhostWindow::event(QEvent *e)
{
if (e->type() == QEvent::DragEnter || e->type() == QEvent::DragMove) {
if (!m_containsMouse) {
m_delayedContainsMouse = false;
m_delayedMouseTimer.stop();
setContainsMouse(true);
emit dragEntered();
}
} else if (e->type() == QEvent::Enter) {
m_delayedContainsMouse = true;
if (!m_delayedMouseTimer.isActive()) {
m_delayedMouseTimer.start();
}
} else if (e->type() == QEvent::Leave || e->type() == QEvent::DragLeave) {
m_delayedContainsMouse = false;
if (!m_delayedMouseTimer.isActive()) {
m_delayedMouseTimer.start();
}
}
return SubWindow::event(e);
}
}
}

46
app/view/screenedgeghostwindow.h → app/view/helpers/screenedgeghostwindow.h
View File

@ -21,8 +21,9 @@
#define SCREENEDGEGHOSTWINDOW_H
// local
#include "../lattecorona.h"
#include "../wm/windowinfowrap.h"
#include "subwindow.h"
#include "../../lattecorona.h"
#include "../../wm/windowinfowrap.h"
// Qt
#include <QObject>
@ -60,7 +61,7 @@ namespace ViewPart {
//! KDE BUGS: https://bugs.kde.org/show_bug.cgi?id=382219
//! https://bugs.kde.org/show_bug.cgi?id=392464
class ScreenEdgeGhostWindow : public QQuickView
class ScreenEdgeGhostWindow : public SubWindow
{
Q_OBJECT
@ -70,59 +71,22 @@ public:
bool containsMouse() const;
int location();
int thickness() const;
void hideWithMask();
void showWithMask();
Latte::View *parentView();
KWayland::Client::PlasmaShellSurface *surface();
signals:
void containsMouseChanged(bool contains);
void dragEntered();
void forcedShown(); //[workaround] forced shown to avoid a KWin issue that hides windows when activities are stopped
protected:
bool event(QEvent *ev) override;
private slots:
void startGeometryTimer();
void updateGeometry();
void fixGeometry();
void updateGeometry() override;
private:
void setContainsMouse(bool contains);
void setupWaylandIntegration();
private:
bool m_delayedContainsMouse{false};
bool m_containsMouse{false};
bool m_inDelete{false};
int m_thickness{2};
QRect m_calculatedGeometry;
QTimer m_delayedMouseTimer;
QTimer m_fixGeometryTimer;
//! HACK: Timers in order to handle KWin faulty
//! behavior that hides Views when closing Activities
//! with no actual reason
QTimer m_visibleHackTimer1;
QTimer m_visibleHackTimer2;
//! Connections for the KWin visibility hack
QList<QMetaObject::Connection> connectionsHack;
Latte::View *m_latteView{nullptr};
QPointer<Latte::Corona> m_corona;
Latte::WindowSystem::WindowId m_trackedWindowId;
KWayland::Client::PlasmaShellSurface *m_shellSurface{nullptr};
};
}

173
app/view/floatinggapwindow.cpp → app/view/helpers/subwindow.cpp
View File

@ -17,10 +17,10 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "floatinggapwindow.h"
#include "subwindow.h"
// local
#include "view.h"
#include "../view.h"
// Qt
#include <QDebug>
@ -39,23 +39,16 @@
namespace Latte {
namespace ViewPart {
FloatingGapWindow::FloatingGapWindow(Latte::View *view) :
SubWindow::SubWindow(Latte::View *view, QString debugType) :
m_latteView(view)
{
m_corona = qobject_cast<Latte::Corona *>(view->corona());
m_debugMode = (qApp->arguments().contains("-d") && qApp->arguments().contains("--kwinedges"));
m_debugType = debugType;
if (m_debugMode) {
m_showColor = QColor("green");
m_hideColor = QColor("red");
} else {
m_showColor = QColor(Qt::transparent);
m_hideColor = QColor(Qt::transparent);
m_showColor.setAlpha(0);
m_hideColor.setAlpha(1);
}
m_showColor = QColor(Qt::transparent);
m_hideColor = QColor(Qt::transparent);
setColor(m_showColor);
setDefaultAlphaBuffer(true);
@ -67,28 +60,18 @@ FloatingGapWindow::FloatingGapWindow(Latte::View *view) :
m_fixGeometryTimer.setSingleShot(true);
m_fixGeometryTimer.setInterval(500);
connect(&m_fixGeometryTimer, &QTimer::timeout, this, &FloatingGapWindow::fixGeometry);
connect(&m_fixGeometryTimer, &QTimer::timeout, this, &SubWindow::fixGeometry);
//! this timer is used in order to identify if mouse is still present in sensitive floating
//! areas and in such case to prevent a real-floating view to hide itself
m_asyncMouseTimer.setSingleShot(true);
m_asyncMouseTimer.setInterval(200);
connect(&m_asyncMouseTimer, &QTimer::timeout, this, [this]() {
if (m_inAsyncContainsMouse && !m_containsMouse) {
emit asyncContainsMouseChanged(false);
hideWithMask();
m_inAsyncContainsMouse = false;
}
});
connect(this, &QQuickView::xChanged, this, &SubWindow::startGeometryTimer);
connect(this, &QQuickView::yChanged, this, &SubWindow::startGeometryTimer);
connect(this, &QQuickView::widthChanged, this, &SubWindow::startGeometryTimer);
connect(this, &QQuickView::heightChanged, this, &SubWindow::startGeometryTimer);
connect(this, &QQuickView::xChanged, this, &FloatingGapWindow::startGeometryTimer);
connect(this, &QQuickView::yChanged, this, &FloatingGapWindow::startGeometryTimer);
connect(this, &QQuickView::widthChanged, this, &FloatingGapWindow::startGeometryTimer);
connect(this, &QQuickView::heightChanged, this, &FloatingGapWindow::startGeometryTimer);
connect(this, &SubWindow::calculatedGeometryChanged, this, &SubWindow::fixGeometry);
connect(m_latteView, &Latte::View::absoluteGeometryChanged, this, &FloatingGapWindow::updateGeometry);
connect(m_latteView, &Latte::View::screenGeometryChanged, this, &FloatingGapWindow::updateGeometry);
connect(m_latteView, &Latte::View::locationChanged, this, &FloatingGapWindow::updateGeometry);
connect(m_latteView, &Latte::View::absoluteGeometryChanged, this, &SubWindow::updateGeometry);
connect(m_latteView, &Latte::View::screenGeometryChanged, this, &SubWindow::updateGeometry);
connect(m_latteView, &Latte::View::locationChanged, this, &SubWindow::updateGeometry);
connect(m_latteView, &QQuickView::screenChanged, this, [this]() {
setScreen(m_latteView->screen());
updateGeometry();
@ -117,9 +100,9 @@ FloatingGapWindow::FloatingGapWindow(Latte::View *view) :
if (!m_inDelete && m_latteView && m_latteView->layout() && !isVisible()) {
show();
emit forcedShown();
//qDebug() << "Floating Gap:: Enforce reshow from timer 1...";
//qDebug() << m_debugType + ":: Enforce reshow from timer 1...";
} else {
//qDebug() << "Floating Gap:: No needed reshow from timer 1...";
//qDebug() << m_debugType + ":: No needed reshow from timer 1...";
}
});
@ -127,13 +110,13 @@ FloatingGapWindow::FloatingGapWindow(Latte::View *view) :
if (!m_inDelete && m_latteView && m_latteView->layout() && !isVisible()) {
show();
emit forcedShown();
//qDebug() << "Floating Gap:: Enforce reshow from timer 2...";
//qDebug() << m_debugType + ":: Enforce reshow from timer 2...";
} else {
//qDebug() << "Floating Gap:: No needed reshow from timer 2...";
//qDebug() << m_debugType + ":: No needed reshow from timer 2...";
}
});
connectionsHack << connect(this, &FloatingGapWindow::forcedShown, this, [&]() {
connectionsHack << connect(this, &SubWindow::forcedShown, this, [&]() {
m_corona->wm()->unregisterIgnoredWindow(m_trackedWindowId);
m_trackedWindowId = winId();
m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
@ -156,11 +139,10 @@ FloatingGapWindow::FloatingGapWindow(Latte::View *view) :
setScreen(m_latteView->screen());
show();
updateGeometry();
hideWithMask();
}
FloatingGapWindow::~FloatingGapWindow()
SubWindow::~SubWindow()
{
m_inDelete = true;
@ -180,70 +162,27 @@ FloatingGapWindow::~FloatingGapWindow()
}
}
int FloatingGapWindow::location()
int SubWindow::location()
{
return (int)m_latteView->location();
}
int FloatingGapWindow::thickness() const
int SubWindow::thickness() const
{
return m_thickness;
}
Latte::View *FloatingGapWindow::parentView()
Latte::View *SubWindow::parentView()
{
return m_latteView;
}
KWayland::Client::PlasmaShellSurface *FloatingGapWindow::surface()
KWayland::Client::PlasmaShellSurface *SubWindow::surface()
{
return m_shellSurface;
}
void FloatingGapWindow::updateGeometry()
{
if (m_latteView->positioner()->slideOffset() != 0) {
return;
}
QRect newGeometry;
m_thickness = m_latteView->screenEdgeMargin();
int length = m_latteView->formFactor() == Plasma::Types::Horizontal ? m_latteView->absoluteGeometry().width() : m_latteView->absoluteGeometry().height();
if (m_latteView->location() == Plasma::Types::BottomEdge) {
int xF = qMax(m_latteView->screenGeometry().left(), m_latteView->absoluteGeometry().left());
newGeometry.setX(xF);
newGeometry.setY(m_latteView->screenGeometry().bottom() - m_thickness);
} else if (m_latteView->location() == Plasma::Types::TopEdge) {
int xF = qMax(m_latteView->screenGeometry().left(), m_latteView->absoluteGeometry().left());
newGeometry.setX(xF);
newGeometry.setY(m_latteView->screenGeometry().top());
} else if (m_latteView->location() == Plasma::Types::LeftEdge) {
int yF = qMax(m_latteView->screenGeometry().top(), m_latteView->absoluteGeometry().top());
newGeometry.setX(m_latteView->screenGeometry().left());
newGeometry.setY(yF);
} else if (m_latteView->location() == Plasma::Types::RightEdge) {
int yF = qMax(m_latteView->screenGeometry().top(), m_latteView->absoluteGeometry().top());
newGeometry.setX(m_latteView->screenGeometry().right() - m_thickness);
newGeometry.setY(yF);
}
if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
newGeometry.setWidth(length);
newGeometry.setHeight(m_thickness + 1);
} else {
newGeometry.setWidth(m_thickness + 1);
newGeometry.setHeight(length);
}
m_calculatedGeometry = newGeometry;
fixGeometry();
}
void FloatingGapWindow::fixGeometry()
void SubWindow::fixGeometry()
{
if (!m_calculatedGeometry.isEmpty()
&& (m_calculatedGeometry.x() != x() || m_calculatedGeometry.y() != y()
@ -259,12 +198,12 @@ void FloatingGapWindow::fixGeometry()
}
}
void FloatingGapWindow::startGeometryTimer()
void SubWindow::startGeometryTimer()
{
m_fixGeometryTimer.start();
}
void FloatingGapWindow::setupWaylandIntegration()
void SubWindow::setupWaylandIntegration()
{
if (m_shellSurface || !KWindowSystem::isPlatformWayland() || !m_latteView || !m_latteView->containment()) {
// already setup
@ -294,64 +233,20 @@ void FloatingGapWindow::setupWaylandIntegration()
}
}
bool FloatingGapWindow::containsMouse() const
bool SubWindow::event(QEvent *e)
{
return m_containsMouse;
}
void FloatingGapWindow::setContainsMouse(bool contains)
{
if (m_containsMouse == contains) {
return;
}
m_containsMouse = contains;
}
bool FloatingGapWindow::event(QEvent *e)
{
if (e->type() == QEvent::DragEnter || e->type() == QEvent::DragMove) {
setContainsMouse(true);
emit dragEntered();
} else if (e->type() == QEvent::Enter) {
setContainsMouse(true);
triggerAsyncContainsMouseSignals();
} else if (e->type() == QEvent::Leave || e->type() == QEvent::DragLeave) {
setContainsMouse(false);
if (m_inAsyncContainsMouse) {
m_asyncMouseTimer.stop();
m_inAsyncContainsMouse = false;
emit asyncContainsMouseChanged(true);
}
} else if (e->type() == QEvent::Show) {
if (e->type() == QEvent::Show) {
m_corona->wm()->setViewExtraFlags(this);
}
return QQuickView::event(e);
}
void FloatingGapWindow::callAsyncContainsMouse()
{
m_inAsyncContainsMouse = true;
m_asyncMouseTimer.start();
showWithMask();
}
void FloatingGapWindow::triggerAsyncContainsMouseSignals()
{
if (!m_inAsyncContainsMouse) {
return;
}
//! this function is called QEvent::Enter
m_asyncMouseTimer.stop();
hideWithMask();
}
void FloatingGapWindow::hideWithMask()
void SubWindow::hideWithMask()
{
if (m_debugMode) {
qDebug() << " Floating Gap Window :: MASK HIDE...";
qDebug() << m_debugType + " :: MASK HIDE...";
}
//! old values: 0,0,1,1 were blocking the top-left corner of the window
@ -362,10 +257,10 @@ void FloatingGapWindow::hideWithMask()
setColor(m_hideColor);
}
void FloatingGapWindow::showWithMask()
void SubWindow::showWithMask()
{
if (m_debugMode) {
qDebug() << " Floating Gap Window :: MAKS SHOW...";
qDebug() << m_debugType + " :: MASK SHOW...";
}
setMask(QRegion());

121
app/view/helpers/subwindow.h Normal file
View File

@ -0,0 +1,121 @@
/*
* Copyright 2020 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 VIEWSUBWINDOW_H
#define VIEWSUBWINDOW_H
// local
#include "../../lattecorona.h"
#include "../../wm/windowinfowrap.h"
// Qt
#include <QObject>
#include <QQuickView>
#include <QTimer>
namespace KWayland {
namespace Client {
class PlasmaShellSurface;
}
}
namespace Latte {
class Corona;
class View;
}
namespace Latte {
namespace ViewPart {
//! What is the importance of this class?
//!
//! This window is responsible to provide a common window base for ViewPart::Helpers
class SubWindow : public QQuickView
{
Q_OBJECT
public:
SubWindow(Latte::View *view, QString debugType);
~SubWindow() override;
int location();
int thickness() const;
void hideWithMask();
void showWithMask();
Latte::View *parentView();
KWayland::Client::PlasmaShellSurface *surface();
signals:
void forcedShown(); //[workaround] forced shown to avoid a KWin issue that hides windows when activities are stopped
void calculatedGeometryChanged();
protected:
bool event(QEvent *ev) override;
//! it is used to update m_calculatedGeometry correctly
virtual void updateGeometry() = 0;
private slots:
void startGeometryTimer();
void fixGeometry();
private:
void setupWaylandIntegration();
protected:
bool m_debugMode{false};
bool m_inDelete{false};
int m_thickness{2};
QString m_debugType;
QRect m_calculatedGeometry;
//! [workaround] colors in order to help masking to apply immediately
//! for some reason when the window in with no content the mask is not
//! update immediately
QColor m_hideColor;
QColor m_showColor;
QTimer m_fixGeometryTimer;
//! HACK: Timers in order to handle KWin faulty
//! behavior that hides Views when closing Activities
//! with no actual reason
QTimer m_visibleHackTimer1;
QTimer m_visibleHackTimer2;
//! Connections for the KWin visibility hack
QList<QMetaObject::Connection> connectionsHack;
Latte::View *m_latteView{nullptr};
QPointer<Latte::Corona> m_corona;
Latte::WindowSystem::WindowId m_trackedWindowId;
KWayland::Client::PlasmaShellSurface *m_shellSurface{nullptr};
};
}
}
#endif

356
app/view/screenedgeghostwindow.cpp
View File

@ -1,356 +0,0 @@
/*
* Copyright 2018 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 "screenedgeghostwindow.h"
// local
#include "view.h"
// Qt
#include <QDebug>
#include <QSurfaceFormat>
#include <QQuickView>
#include <QTimer>
// KDE
#include <KWayland/Client/plasmashell.h>
#include <KWayland/Client/surface.h>
#include <KWindowSystem>
// X11
#include <NETWM>
namespace Latte {
namespace ViewPart {
ScreenEdgeGhostWindow::ScreenEdgeGhostWindow(Latte::View *view) :
m_latteView(view)
{
m_corona = qobject_cast<Latte::Corona *>(view->corona());
bool debugEdge = (qApp->arguments().contains("-d") && qApp->arguments().contains("--kwinedges"));
setColor(debugEdge ? QColor("purple") : QColor(Qt::transparent));
setDefaultAlphaBuffer(true);
setFlags(Qt::FramelessWindowHint
| Qt::WindowStaysOnTopHint
| Qt::NoDropShadowWindowHint
| Qt::WindowDoesNotAcceptFocus);
m_fixGeometryTimer.setSingleShot(true);
m_fixGeometryTimer.setInterval(500);
connect(&m_fixGeometryTimer, &QTimer::timeout, this, &ScreenEdgeGhostWindow::fixGeometry);
//! this timer is used in order to avoid fast enter/exit signals during first
//! appearing after edge activation
m_delayedMouseTimer.setSingleShot(true);
m_delayedMouseTimer.setInterval(50);
connect(&m_delayedMouseTimer, &QTimer::timeout, this, [this]() {
if (m_delayedContainsMouse) {
setContainsMouse(true);
} else {
setContainsMouse(false);
}
});
connect(this, &QQuickView::xChanged, this, &ScreenEdgeGhostWindow::startGeometryTimer);
connect(this, &QQuickView::yChanged, this, &ScreenEdgeGhostWindow::startGeometryTimer);
connect(this, &QQuickView::widthChanged, this, &ScreenEdgeGhostWindow::startGeometryTimer);
connect(this, &QQuickView::heightChanged, this, &ScreenEdgeGhostWindow::startGeometryTimer);
connect(m_latteView, &Latte::View::absoluteGeometryChanged, this, &ScreenEdgeGhostWindow::updateGeometry);
connect(m_latteView, &Latte::View::screenGeometryChanged, this, &ScreenEdgeGhostWindow::updateGeometry);
connect(m_latteView, &Latte::View::locationChanged, this, &ScreenEdgeGhostWindow::updateGeometry);
connect(m_latteView, &QQuickView::screenChanged, this, [this]() {
setScreen(m_latteView->screen());
updateGeometry();
});
if (!KWindowSystem::isPlatformWayland()) {
//! IMPORTANT!!! ::: This fixes a bug when closing an Activity all views from all Activities are
//! disappearing! With this code parts they reappear!!!
m_visibleHackTimer1.setInterval(400);
m_visibleHackTimer2.setInterval(2500);
m_visibleHackTimer1.setSingleShot(true);
m_visibleHackTimer2.setSingleShot(true);
connectionsHack << connect(this, &QWindow::visibleChanged, this, [&]() {
if (!m_inDelete && m_latteView && m_latteView->layout() && !isVisible()) {
m_visibleHackTimer1.start();
m_visibleHackTimer2.start();
} else if (!m_inDelete) {
//! For some reason when the window is hidden in the edge under X11 afterwards
//! is losing its window flags
m_corona->wm()->setViewExtraFlags(this);
}
});
connectionsHack << connect(&m_visibleHackTimer1, &QTimer::timeout, this, [&]() {
if (!m_inDelete && m_latteView && m_latteView->layout() && !isVisible()) {
show();
emit forcedShown();
//qDebug() << "Ghost Edge:: Enforce reshow from timer 1...";
} else {
//qDebug() << "Ghost Edge:: No needed reshow from timer 1...";
}
});
connectionsHack << connect(&m_visibleHackTimer2, &QTimer::timeout, this, [&]() {
if (!m_inDelete && m_latteView && m_latteView->layout() && !isVisible()) {
show();
emit forcedShown();
//qDebug() << "Ghost Edge:: Enforce reshow from timer 2...";
} else {
//qDebug() << "Ghost Edge:: No needed reshow from timer 2...";
}
});
connectionsHack << connect(this, &ScreenEdgeGhostWindow::forcedShown, this, [&]() {
m_corona->wm()->unregisterIgnoredWindow(m_trackedWindowId);
m_trackedWindowId = winId();
m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
});
}
setupWaylandIntegration();
if (KWindowSystem::isPlatformX11()) {
m_trackedWindowId = winId();
m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
} else {
connect(m_corona->wm(), &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, [&]() {
if (m_trackedWindowId.isNull()) {
m_trackedWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
}
});
}
setScreen(m_latteView->screen());
show();
updateGeometry();
hideWithMask();
}
ScreenEdgeGhostWindow::~ScreenEdgeGhostWindow()
{
m_inDelete = true;
m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_trackedWindowId);
m_latteView = nullptr;
// clear mode
m_visibleHackTimer1.stop();
m_visibleHackTimer2.stop();
for (auto &c : connectionsHack) {
disconnect(c);
}
if (m_shellSurface) {
delete m_shellSurface;
}
}
int ScreenEdgeGhostWindow::location()
{
return (int)m_latteView->location();
}
int ScreenEdgeGhostWindow::thickness() const
{
return m_thickness;
}
Latte::View *ScreenEdgeGhostWindow::parentView()
{
return m_latteView;
}
KWayland::Client::PlasmaShellSurface *ScreenEdgeGhostWindow::surface()
{
return m_shellSurface;
}
void ScreenEdgeGhostWindow::updateGeometry()
{
if (m_latteView->positioner()->slideOffset() != 0) {
return;
}
QRect newGeometry;
if (KWindowSystem::compositingActive()) {
m_thickness = 6;
} else {
m_thickness = 2;
}
int length{30};
int lengthDifference{0};
if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
//! set minimum length to be 25% of screen width
length = qMax(m_latteView->screenGeometry().width()/4,qMin(m_latteView->absoluteGeometry().width(), m_latteView->screenGeometry().width() - 1));
lengthDifference = qMax(0,length - m_latteView->absoluteGeometry().width());
} else {
//! set minimum length to be 25% of screen height
length = qMax(m_latteView->screenGeometry().height()/4,qMin(m_latteView->absoluteGeometry().height(), m_latteView->screenGeometry().height() - 1));
lengthDifference = qMax(0,length - m_latteView->absoluteGeometry().height());
}
if (m_latteView->location() == Plasma::Types::BottomEdge) {
int xF = qMax(m_latteView->screenGeometry().left(), m_latteView->absoluteGeometry().left() - lengthDifference);
newGeometry.setX(xF);
newGeometry.setY(m_latteView->screenGeometry().bottom() - m_thickness);
} else if (m_latteView->location() == Plasma::Types::TopEdge) {
int xF = qMax(m_latteView->screenGeometry().left(), m_latteView->absoluteGeometry().left() - lengthDifference);
newGeometry.setX(xF);
newGeometry.setY(m_latteView->screenGeometry().top());
} else if (m_latteView->location() == Plasma::Types::LeftEdge) {
int yF = qMax(m_latteView->screenGeometry().top(), m_latteView->absoluteGeometry().top() - lengthDifference);
newGeometry.setX(m_latteView->screenGeometry().left());
newGeometry.setY(yF);
} else if (m_latteView->location() == Plasma::Types::RightEdge) {
int yF = qMax(m_latteView->screenGeometry().top(), m_latteView->absoluteGeometry().top() - lengthDifference);
newGeometry.setX(m_latteView->screenGeometry().right() - m_thickness);
newGeometry.setY(yF);
}
if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
newGeometry.setWidth(length);
newGeometry.setHeight(m_thickness + 1);
} else {
newGeometry.setWidth(m_thickness + 1);
newGeometry.setHeight(length);
}
m_calculatedGeometry = newGeometry;
fixGeometry();
}
void ScreenEdgeGhostWindow::fixGeometry()
{
if (!m_calculatedGeometry.isEmpty()
&& (m_calculatedGeometry.x() != x() || m_calculatedGeometry.y() != y()
|| m_calculatedGeometry.width() != width() || m_calculatedGeometry.height() != height())) {
setMinimumSize(m_calculatedGeometry.size());
setMaximumSize(m_calculatedGeometry.size());
resize(m_calculatedGeometry.size());
setPosition(m_calculatedGeometry.x(), m_calculatedGeometry.y());
if (m_shellSurface) {
m_shellSurface->setPosition(m_calculatedGeometry.topLeft());
}
}
}
void ScreenEdgeGhostWindow::startGeometryTimer()
{
m_fixGeometryTimer.start();
}
void ScreenEdgeGhostWindow::setupWaylandIntegration()
{
if (m_shellSurface || !KWindowSystem::isPlatformWayland() || !m_latteView || !m_latteView->containment()) {
// already setup
return;
}
if (m_corona) {
using namespace KWayland::Client;
PlasmaShell *interface = m_corona->waylandCoronaInterface();
if (!interface) {
return;
}
Surface *s = Surface::fromWindow(this);
if (!s) {
return;
}
qDebug() << "wayland screen edge ghost window surface was created...";
m_shellSurface = interface->createSurface(s, this);
m_corona->wm()->setViewExtraFlags(m_shellSurface);
m_shellSurface->setPanelTakesFocus(false);
}
}
bool ScreenEdgeGhostWindow::containsMouse() const
{
return m_containsMouse;
}
void ScreenEdgeGhostWindow::setContainsMouse(bool contains)
{
if (m_containsMouse == contains) {
return;
}
m_containsMouse = contains;
emit containsMouseChanged(contains);
}
bool ScreenEdgeGhostWindow::event(QEvent *e)
{
if (e->type() == QEvent::DragEnter || e->type() == QEvent::DragMove) {
if (!m_containsMouse) {
m_delayedContainsMouse = false;
m_delayedMouseTimer.stop();
setContainsMouse(true);
emit dragEntered();
}
} else if (e->type() == QEvent::Enter) {
m_delayedContainsMouse = true;
if (!m_delayedMouseTimer.isActive()) {
m_delayedMouseTimer.start();
}
} else if (e->type() == QEvent::Leave || e->type() == QEvent::DragLeave) {
m_delayedContainsMouse = false;
if (!m_delayedMouseTimer.isActive()) {
m_delayedMouseTimer.start();
}
} else if (e->type() == QEvent::Show) {
m_corona->wm()->setViewExtraFlags(this);
}
return QQuickView::event(e);
}
void ScreenEdgeGhostWindow::hideWithMask()
{
//! old values: 0,0,1,1 were blocking the top-left corner of the window
QRect maskGeometry{-2, 0, 1, 1};
setMask(maskGeometry);
}
void ScreenEdgeGhostWindow::showWithMask()
{
setMask(QRect());
}
}
}

4
app/view/visibilitymanager.cpp
View File

@ -22,9 +22,9 @@
// local
#include "positioner.h"
#include "floatinggapwindow.h"
#include "screenedgeghostwindow.h"
#include "view.h"
#include "helpers/floatinggapwindow.h"
#include "helpers/screenedgeghostwindow.h"
#include "windowstracker/currentscreentracker.h"
#include "../lattecorona.h"
#include "../screenpool.h"

2
app/wm/waylandinterface.cpp
View File

@ -22,8 +22,8 @@
// local
#include "view/positioner.h"
#include "view/screenedgeghostwindow.h"
#include "view/view.h"
#include "view/helpers/screenedgeghostwindow.h"
#include "../lattecorona.h"
#include "../../liblatte2/extras.h"
#include "../../liblatte2/types.h"

2
app/wm/xwindowinterface.cpp
View File

@ -22,8 +22,8 @@
// local
#include "tasktools.h"
#include "view/screenedgeghostwindow.h"
#include "view/view.h"
#include "view/helpers/screenedgeghostwindow.h"
#include "../../liblatte2/extras.h"
#include "../../liblatte2/types.h"