2007-11-27 19:40:25 +00:00
|
|
|
/********************************************************************
|
2007-04-29 17:35:43 +00:00
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
|
|
|
|
|
|
|
Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
|
2010-01-21 14:56:24 +00:00
|
|
|
Copyright (C) 2010 Jorge Mata <matamax123@gmail.com>
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2007-11-27 19:40:25 +00:00
|
|
|
This program 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.
|
|
|
|
|
|
|
|
This program 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/>.
|
|
|
|
*********************************************************************/
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
#include "trackmouse.h"
|
|
|
|
|
2012-09-12 17:24:20 +00:00
|
|
|
// KConfigSkeleton
|
|
|
|
#include "trackmouseconfig.h"
|
|
|
|
|
2013-08-14 19:13:12 +00:00
|
|
|
#include <QAction>
|
2013-06-21 12:57:37 +00:00
|
|
|
#include <QPainter>
|
2008-04-15 12:54:17 +00:00
|
|
|
#include <QTime>
|
2012-04-19 19:06:11 +00:00
|
|
|
#include <QMatrix4x4>
|
2008-04-15 12:54:17 +00:00
|
|
|
|
2007-12-17 14:14:53 +00:00
|
|
|
#include <kwinconfig.h>
|
2010-12-08 18:35:38 +00:00
|
|
|
#include <kwinglutils.h>
|
2013-02-12 11:34:51 +00:00
|
|
|
#include <kwinxrenderutils.h>
|
2007-05-13 17:47:20 +00:00
|
|
|
|
2014-03-17 15:24:10 +00:00
|
|
|
#include <KGlobalAccel>
|
|
|
|
#include <KLocalizedString>
|
2010-01-21 14:56:24 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
#include <math.h>
|
|
|
|
|
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
|
|
|
TrackMouseEffect::TrackMouseEffect()
|
2012-04-19 19:06:11 +00:00
|
|
|
: m_active(false)
|
|
|
|
, m_angle(0)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2012-04-19 19:06:11 +00:00
|
|
|
m_texture[0] = m_texture[1] = 0;
|
|
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
2013-02-12 11:34:51 +00:00
|
|
|
m_picture[0] = m_picture[1] = 0;
|
2012-04-19 19:06:11 +00:00
|
|
|
if ( effects->compositingType() == XRenderCompositing)
|
|
|
|
m_angleBase = 1.57079632679489661923; // Pi/2
|
|
|
|
#endif
|
2013-06-21 12:57:37 +00:00
|
|
|
if ( effects->isOpenGLCompositing() || effects->compositingType() == QPainterCompositing)
|
2012-04-19 19:06:11 +00:00
|
|
|
m_angleBase = 90.0;
|
|
|
|
m_mousePolling = false;
|
2013-08-14 19:13:12 +00:00
|
|
|
|
2013-12-10 10:45:33 +00:00
|
|
|
m_action = new QAction(this);
|
|
|
|
m_action->setObjectName(QStringLiteral("TrackMouse"));
|
2012-04-19 19:06:11 +00:00
|
|
|
m_action->setText(i18n("Track mouse"));
|
2013-08-14 19:13:12 +00:00
|
|
|
KGlobalAccel::self()->setDefaultShortcut(m_action, QList<QKeySequence>());
|
|
|
|
KGlobalAccel::self()->setShortcut(m_action, QList<QKeySequence>());
|
2013-07-10 10:26:50 +00:00
|
|
|
effects->registerGlobalShortcut(QKeySequence(), m_action);
|
2010-12-08 18:35:38 +00:00
|
|
|
|
2012-04-19 19:06:11 +00:00
|
|
|
connect(m_action, SIGNAL(triggered(bool)), this, SLOT(toggle()));
|
2013-08-14 19:13:12 +00:00
|
|
|
|
2011-03-12 13:37:30 +00:00
|
|
|
connect(effects, SIGNAL(mouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers)),
|
2012-04-19 19:06:11 +00:00
|
|
|
SLOT(slotMouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers)));
|
2011-01-30 14:34:42 +00:00
|
|
|
reconfigure(ReconfigureAll);
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
TrackMouseEffect::~TrackMouseEffect()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2012-04-19 19:06:11 +00:00
|
|
|
if (m_mousePolling)
|
2010-01-21 14:56:24 +00:00
|
|
|
effects->stopMousePolling();
|
2012-04-19 19:06:11 +00:00
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
|
|
delete m_texture[i]; m_texture[i] = 0;
|
|
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
2013-02-12 11:34:51 +00:00
|
|
|
delete m_picture[i]; m_picture[i] = 0;
|
2012-04-19 19:06:11 +00:00
|
|
|
#endif
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
void TrackMouseEffect::reconfigure(ReconfigureFlags)
|
|
|
|
{
|
2012-04-19 19:06:11 +00:00
|
|
|
m_modifiers = 0;
|
2012-09-12 17:24:20 +00:00
|
|
|
TrackMouseConfig::self()->readConfig();
|
|
|
|
if (TrackMouseConfig::shift())
|
2012-04-19 19:06:11 +00:00
|
|
|
m_modifiers |= Qt::ShiftModifier;
|
2012-09-12 17:24:20 +00:00
|
|
|
if (TrackMouseConfig::alt())
|
2012-04-19 19:06:11 +00:00
|
|
|
m_modifiers |= Qt::AltModifier;
|
2012-09-12 17:24:20 +00:00
|
|
|
if (TrackMouseConfig::control())
|
2012-04-19 19:06:11 +00:00
|
|
|
m_modifiers |= Qt::ControlModifier;
|
2012-09-12 17:24:20 +00:00
|
|
|
if (TrackMouseConfig::meta())
|
2012-04-19 19:06:11 +00:00
|
|
|
m_modifiers |= Qt::MetaModifier;
|
|
|
|
|
|
|
|
if (m_modifiers) {
|
|
|
|
if (!m_mousePolling)
|
2010-01-22 05:01:05 +00:00
|
|
|
effects->startMousePolling();
|
2012-04-19 19:06:11 +00:00
|
|
|
m_mousePolling = true;
|
|
|
|
} else if (m_mousePolling) {
|
2010-01-21 14:56:24 +00:00
|
|
|
effects->stopMousePolling();
|
2012-04-19 19:06:11 +00:00
|
|
|
m_mousePolling = false;
|
2010-01-21 14:56:24 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-01-21 14:56:24 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
void TrackMouseEffect::prePaintScreen(ScreenPrePaintData& data, int time)
|
|
|
|
{
|
2012-04-19 19:06:11 +00:00
|
|
|
if (m_active) {
|
2008-04-15 12:54:17 +00:00
|
|
|
QTime t = QTime::currentTime();
|
2012-04-19 19:06:11 +00:00
|
|
|
m_angle = ((t.second() % 4) * m_angleBase) + (t.msec() / 1000.0 * m_angleBase);
|
|
|
|
m_lastRect[0].moveCenter(cursorPos());
|
|
|
|
m_lastRect[1].moveCenter(cursorPos());
|
|
|
|
data.paint |= m_lastRect[0].adjusted(-1,-1,1,1);
|
2008-04-15 12:54:17 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
effects->prePaintScreen(data, time);
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
void TrackMouseEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
|
|
|
|
{
|
|
|
|
effects->paintScreen(mask, region, data); // paint normal screen
|
2012-04-19 19:06:11 +00:00
|
|
|
if (!m_active)
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2012-04-19 19:06:11 +00:00
|
|
|
|
2012-09-20 09:33:32 +00:00
|
|
|
if ( effects->isOpenGLCompositing() && m_texture[0] && m_texture[1]) {
|
2012-09-21 09:25:08 +00:00
|
|
|
ShaderBinder binder(ShaderManager::GenericShader);
|
|
|
|
GLShader *shader(binder.shader());
|
2014-02-25 10:02:32 +00:00
|
|
|
if (!shader) {
|
|
|
|
return;
|
2010-12-08 18:35:38 +00:00
|
|
|
}
|
2014-02-25 10:02:32 +00:00
|
|
|
QMatrix4x4 modelview;
|
|
|
|
modelview = shader->getUniformMatrix4x4("modelview");
|
2011-01-30 14:34:42 +00:00
|
|
|
glEnable(GL_BLEND);
|
2012-04-19 19:06:11 +00:00
|
|
|
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
QMatrix4x4 matrix(modelview);
|
|
|
|
const QPointF p = m_lastRect[0].topLeft() + QPoint(m_lastRect[0].width()/2.0, m_lastRect[0].height()/2.0);
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
|
|
matrix.translate(p.x(), p.y(), 0.0);
|
|
|
|
matrix.rotate(i ? -2*m_angle : m_angle, 0, 0, 1.0);
|
|
|
|
matrix.translate(-p.x(), -p.y(), 0.0);
|
2014-02-25 10:02:32 +00:00
|
|
|
shader->setUniform(GLShader::ModelViewMatrix, matrix);
|
|
|
|
shader->setUniform(GLShader::Saturation, 1.0);
|
|
|
|
shader->setUniform(GLShader::ModulationConstant, QVector4D(1.0, 1.0, 1.0, 1.0));
|
2012-04-19 19:06:11 +00:00
|
|
|
m_texture[i]->bind();
|
|
|
|
m_texture[i]->render(region, m_lastRect[i]);
|
|
|
|
m_texture[i]->unbind();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-12-08 18:35:38 +00:00
|
|
|
glDisable(GL_BLEND);
|
2014-02-25 10:02:32 +00:00
|
|
|
shader->setUniform(GLShader::ModelViewMatrix, modelview);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2012-04-19 19:06:11 +00:00
|
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
2013-02-12 11:34:51 +00:00
|
|
|
if ( effects->compositingType() == XRenderCompositing && m_picture[0] && m_picture[1]) {
|
2012-04-19 19:06:11 +00:00
|
|
|
float sine = sin(m_angle);
|
|
|
|
const float cosine = cos(m_angle);
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
|
|
if (i) sine = -sine;
|
2013-02-12 11:34:51 +00:00
|
|
|
const float dx = m_size[i].width()/2.0;
|
|
|
|
const float dy = m_size[i].height()/2.0;
|
|
|
|
const xcb_render_picture_t picture = *m_picture[i];
|
|
|
|
#define DOUBLE_TO_FIXED(d) ((xcb_render_fixed_t) ((d) * 65536))
|
|
|
|
xcb_render_transform_t xform = {
|
|
|
|
DOUBLE_TO_FIXED( cosine ), DOUBLE_TO_FIXED( -sine ), DOUBLE_TO_FIXED( dx - cosine*dx + sine*dy ),
|
|
|
|
DOUBLE_TO_FIXED( sine ), DOUBLE_TO_FIXED( cosine ), DOUBLE_TO_FIXED( dy - sine*dx - cosine*dy ),
|
|
|
|
DOUBLE_TO_FIXED( 0.0 ), DOUBLE_TO_FIXED( 0.0 ), DOUBLE_TO_FIXED( 1.0 )
|
|
|
|
};
|
|
|
|
#undef DOUBLE_TO_FIXED
|
|
|
|
xcb_render_set_picture_transform(connection(), picture, xform);
|
|
|
|
xcb_render_set_picture_filter(connection(), picture, 8, "bilinear", 0, NULL);
|
|
|
|
const QRect &rect = m_lastRect[i];
|
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, picture, XCB_RENDER_PICTURE_NONE,
|
|
|
|
effects->xrenderBufferPicture(), 0, 0, 0, 0,
|
|
|
|
rect.x(), rect.y(), rect.width(), rect.height());
|
2012-04-19 19:06:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2013-06-21 12:57:37 +00:00
|
|
|
if (effects->compositingType() == QPainterCompositing && !m_image[0].isNull() && !m_image[1].isNull()) {
|
|
|
|
QPainter *painter = effects->scenePainter();
|
|
|
|
const QPointF p = m_lastRect[0].topLeft() + QPoint(m_lastRect[0].width()/2.0, m_lastRect[0].height()/2.0);
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
|
|
painter->save();
|
|
|
|
painter->translate(p.x(), p.y());
|
|
|
|
painter->rotate(i ? -2*m_angle : m_angle);
|
|
|
|
painter->translate(-p.x(), -p.y());
|
|
|
|
painter->drawImage(m_lastRect[i], m_image[i]);
|
|
|
|
painter->restore();
|
|
|
|
}
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
void TrackMouseEffect::postPaintScreen()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2012-04-19 19:06:11 +00:00
|
|
|
if (m_active) {
|
|
|
|
effects->addRepaint(m_lastRect[0].adjusted(-1,-1,1,1));
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
effects->postPaintScreen();
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2012-04-19 19:06:11 +00:00
|
|
|
bool TrackMouseEffect::init()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
Better handling for making the compositing OpenGL context current
With QtQuick2 it's possible that the scene graph rendering context either
lives in an own thread or uses the main GUI thread. In the latter case
it's the same thread as our compositing OpenGL context lives in. This
means our basic assumption that between two rendering passes the context
stays current does not hold.
The code already ensured that before we start a rendering pass the
context is made current, but there are many more possible cases. If we
use OpenGL in areas not triggered by the rendering loop but in response
to other events the context needs to be made current. This includes the
loading and unloading of effects (some effects use OpenGL in the static
effect check, in the ctor and dtor), background loading of texture data,
lazy loading after first usage invoked by shortcut, etc. etc.
To properly handle these cases new methods are added to EffectsHandler
to make the compositing OpenGL context current. These calls delegate down
into the scene. On non-OpenGL scenes they are noop, but on OpenGL they go
into the backend and make the context current. In addition they ensure
that Qt doesn't think that it's QOpenGLContext is current by calling
doneCurrent() on the QOpenGLContext::currentContext(). This unfortunately
causes an additional call to makeCurrent with a null context, but there
is no other way to tell Qt - it doesn't notice when a different context
is made current with low level API calls. In the multi-threaded
architecture this doesn't matter as ::currentContext() returns null.
A short evaluation showed that a transition to QOpenGLContext doesn't
seem feasible. Qt only supports either GLX or EGL while KWin supports
both and when entering the transition phase for Wayland, it would become
extremely tricky if our native platform is X11, but we want a Wayland
EGL context. A future solution might be to have a "KWin-QPA plugin" which
uses either xcb or Wayland and hides everything from Qt.
The API documentation is extended to describe when the effects-framework
ensures that an OpenGL context is current. The effects are changed to
make the context current in cases where it's not guaranteed. This has
been done by looking for creation or deletion of GLTextures and Shaders.
If there are other OpenGL usages outside the rendering loop, ctor/dtor
this needs to be changed, too.
2013-11-22 14:05:36 +00:00
|
|
|
effects->makeOpenGLContextCurrent();
|
2012-04-19 19:06:11 +00:00
|
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
2013-06-21 12:57:37 +00:00
|
|
|
if (!(m_texture[0] || m_picture[0] || m_image[0].isNull())) {
|
2012-04-19 19:06:11 +00:00
|
|
|
loadTexture();
|
2013-06-21 12:57:37 +00:00
|
|
|
if (!(m_texture[0] || m_picture[0] || m_image[0].isNull()))
|
2012-04-19 19:06:11 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#else
|
2013-06-21 12:57:37 +00:00
|
|
|
if (!m_texture[0] || m_image[0].isNull()) {
|
2012-04-19 19:06:11 +00:00
|
|
|
loadTexture();
|
2013-06-21 12:57:37 +00:00
|
|
|
if (!m_texture[0] || m_image[0].isNull())
|
2012-04-19 19:06:11 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
m_lastRect[0].moveCenter(cursorPos());
|
|
|
|
m_lastRect[1].moveCenter(cursorPos());
|
|
|
|
m_active = true;
|
|
|
|
m_angle = 0;
|
|
|
|
return true;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-01-21 14:56:24 +00:00
|
|
|
|
2012-04-19 19:06:11 +00:00
|
|
|
void TrackMouseEffect::toggle()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2012-04-19 19:06:11 +00:00
|
|
|
if (m_mousePolling)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (m_active) {
|
|
|
|
m_active = false;
|
|
|
|
} else if (!init()) {
|
|
|
|
return;
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2012-04-19 19:06:11 +00:00
|
|
|
effects->addRepaint(m_lastRect[0].adjusted(-1,-1,1,1));
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2012-04-19 19:06:11 +00:00
|
|
|
void TrackMouseEffect::slotMouseChanged(const QPoint&, const QPoint&,
|
|
|
|
Qt::MouseButtons, Qt::MouseButtons,
|
|
|
|
Qt::KeyboardModifiers modifiers, Qt::KeyboardModifiers)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2012-04-19 19:06:11 +00:00
|
|
|
if (!m_mousePolling) // we didn't ask for it but maybe someone else did...
|
|
|
|
return;
|
|
|
|
if (m_modifiers && modifiers == m_modifiers) {
|
|
|
|
if (!m_active && !init()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
effects->addRepaint(m_lastRect[0].adjusted(-1,-1,1,1));
|
|
|
|
} else if (m_active) {
|
|
|
|
m_active = false;
|
|
|
|
effects->addRepaint(m_lastRect[0].adjusted(-1,-1,1,1));
|
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
void TrackMouseEffect::loadTexture()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2013-08-09 12:19:09 +00:00
|
|
|
QString f[2] = {QStandardPaths::locate(QStandardPaths::DataLocation, QStringLiteral("tm_outer.png")),
|
|
|
|
QStandardPaths::locate(QStandardPaths::DataLocation, QStringLiteral("tm_inner.png"))};
|
2012-04-19 19:06:11 +00:00
|
|
|
if (f[0].isEmpty() || f[1].isEmpty())
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2012-04-19 19:06:11 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
2012-09-20 09:33:32 +00:00
|
|
|
if ( effects->isOpenGLCompositing()) {
|
2012-04-19 19:06:11 +00:00
|
|
|
QImage img(f[i]);
|
|
|
|
m_texture[i] = new GLTexture(img);
|
|
|
|
m_lastRect[i].setSize(img.size());
|
|
|
|
}
|
|
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
|
|
|
if ( effects->compositingType() == XRenderCompositing) {
|
2013-08-13 05:19:09 +00:00
|
|
|
QImage pixmap(f[i]);
|
2013-02-12 11:34:51 +00:00
|
|
|
m_picture[i] = new XRenderPicture(pixmap);
|
|
|
|
m_size[i] = pixmap.size();
|
|
|
|
m_lastRect[i].setSize(pixmap.size());
|
2012-04-19 19:06:11 +00:00
|
|
|
}
|
|
|
|
#endif
|
2013-06-21 12:57:37 +00:00
|
|
|
if (effects->compositingType() == QPainterCompositing) {
|
|
|
|
m_image[i] = QImage(f[i]);
|
|
|
|
m_lastRect[i].setSize(m_image[i].size());
|
|
|
|
}
|
2012-04-19 19:06:11 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2011-08-27 09:21:31 +00:00
|
|
|
bool TrackMouseEffect::isActive() const
|
|
|
|
{
|
2012-04-19 19:06:11 +00:00
|
|
|
return m_active;
|
2011-08-27 09:21:31 +00:00
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
} // namespace
|