yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/effects/mousemark/mousemark.cpp
Martin Gräßlin 2132b1e0c8 [effects] Use arg="true" in the kcfg files 
Summary:
By changing all kcfg to have arg="true" we can pass in the same
KSharedConfigPtr into all effects. This allows to have fake config in
the tests and in the planned effect demo mode.

Also it means that we don't have to hardcode the name kwinrc into the
files. In the configs - where we cannot access the effectshandler - we
use the define KWIN_CONFIG which gets generated based on the compile
time arguments.

Reviewers: #kwin, #plasma

Subscribers: plasma-devel, kwin

Tags: #kwin

Differential Revision: https://phabricator.kde.org/D3571
2017-04-15 10:03:34 +02:00

290 lines
10 KiB
C++
Raw Blame History

/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
Copyright (C) 2007 Christian Nitschkowski <christian.nitschkowski@kdemail.net>
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/>.
*********************************************************************/
#include "mousemark.h"
// KConfigSkeleton
#include "mousemarkconfig.h"
#include <QAction>
#include <kwinconfig.h>
#include <kwinglplatform.h>
#include <kwinglutils.h>
#include <KGlobalAccel>
#include <KLocalizedString>
#include <QPainter>
#include <math.h>
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
#include <xcb/render.h>
#endif
namespace KWin
{
#define NULL_POINT (QPoint( -1, -1 )) // null point is (0,0), which is valid :-/
MouseMarkEffect::MouseMarkEffect()
{
initConfig<MouseMarkConfig>();
QAction* a = new QAction(this);
a->setObjectName(QStringLiteral("ClearMouseMarks"));
a->setText(i18n("Clear All Mouse Marks"));
KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::SHIFT + Qt::META + Qt::Key_F11);
KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::SHIFT + Qt::META + Qt::Key_F11);
effects->registerGlobalShortcut(Qt::SHIFT + Qt::META + Qt::Key_F11, a);
connect(a, SIGNAL(triggered(bool)), this, SLOT(clear()));
a = new QAction(this);
a->setObjectName(QStringLiteral("ClearLastMouseMark"));
a->setText(i18n("Clear Last Mouse Mark"));
KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::SHIFT + Qt::META + Qt::Key_F12);
KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::SHIFT + Qt::META + Qt::Key_F12);
effects->registerGlobalShortcut(Qt::SHIFT + Qt::META + Qt::Key_F12, a);
connect(a, SIGNAL(triggered(bool)), this, SLOT(clearLast()));
connect(effects, SIGNAL(mouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers)),
this, SLOT(slotMouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers)));
connect(effects, SIGNAL(screenLockingChanged(bool)), SLOT(screenLockingChanged(bool)));
reconfigure(ReconfigureAll);
arrow_start = NULL_POINT;
effects->startMousePolling(); // We require it to detect activation as well
}
MouseMarkEffect::~MouseMarkEffect()
{
effects->stopMousePolling();
}
static int width_2 = 1;
void MouseMarkEffect::reconfigure(ReconfigureFlags)
{
MouseMarkConfig::self()->read();
width = MouseMarkConfig::lineWidth();
width_2 = width / 2;
color = MouseMarkConfig::color();
color.setAlphaF(1.0);
}
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
void MouseMarkEffect::addRect(const QPoint &p1, const QPoint &p2, xcb_rectangle_t *r, xcb_render_color_t *c)
{
r->x = qMin(p1.x(), p2.x()) - width_2;
r->y = qMin(p1.y(), p2.y()) - width_2;
r->width = qAbs(p1.x()-p2.x()) + 1 + width_2;
r->height = qAbs(p1.y()-p2.y()) + 1 + width_2;
// fast move -> large rect, <strike>tess...</strike> interpolate a line
if (r->width > 3*width/2 && r->height > 3*width/2) {
const int n = sqrt(r->width*r->width + r->height*r->height) / width;
xcb_rectangle_t *rects = new xcb_rectangle_t[n-1];
const int w = p1.x() < p2.x() ? r->width : -r->width;
const int h = p1.y() < p2.y() ? r->height : -r->height;
for (int i = 1; i < n; ++i) {
rects[i-1].x = p1.x() + i*w/n;
rects[i-1].y = p1.y() + i*h/n;
rects[i-1].width = rects[i-1].height = width;
}
xcb_render_fill_rectangles(xcbConnection(), XCB_RENDER_PICT_OP_SRC, effects->xrenderBufferPicture(), *c, n - 1, rects);
delete [] rects;
r->x = p1.x();
r->y = p1.y();
r->width = r->height = width;
}
}
#endif
void MouseMarkEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
{
effects->paintScreen(mask, region, data); // paint normal screen
if (marks.isEmpty() && drawing.isEmpty())
return;
if ( effects->isOpenGLCompositing()) {
if (!GLPlatform::instance()->isGLES()) {
glEnable(GL_LINE_SMOOTH);
}
glLineWidth(width);
GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
vbo->reset();
vbo->setUseColor(true);
vbo->setColor(color);
ShaderBinder binder(ShaderTrait::UniformColor);
binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, data.projectionMatrix());
QVector<float> verts;
foreach (const Mark & mark, marks) {
verts.clear();
verts.reserve(mark.size() * 2);
foreach (const QPoint & p, mark) {
verts << p.x() << p.y();
}
vbo->setData(verts.size() / 2, 2, verts.data(), NULL);
vbo->render(GL_LINE_STRIP);
}
if (!drawing.isEmpty()) {
verts.clear();
verts.reserve(drawing.size() * 2);
foreach (const QPoint & p, drawing) {
verts << p.x() << p.y();
}
vbo->setData(verts.size() / 2, 2, verts.data(), NULL);
vbo->render(GL_LINE_STRIP);
}
glLineWidth(1.0);
if (!GLPlatform::instance()->isGLES()) {
glDisable(GL_LINE_SMOOTH);
}
}
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
if ( effects->compositingType() == XRenderCompositing) {
xcb_render_color_t c = preMultiply(color);
for (int i = 0; i < marks.count(); ++i) {
const int n = marks[i].count() - 1;
if (n > 0) {
xcb_rectangle_t *rects = new xcb_rectangle_t[n];
for (int j = 0; j < marks[i].count()-1; ++j) {
addRect(marks[i][j], marks[i][j+1], &rects[j], &c);
}
xcb_render_fill_rectangles(xcbConnection(), XCB_RENDER_PICT_OP_SRC, effects->xrenderBufferPicture(), c, n, rects);
delete [] rects;
}
}
const int n = drawing.count() - 1;
if (n > 0) {
xcb_rectangle_t *rects = new xcb_rectangle_t[n];
for (int i = 0; i < n; ++i)
addRect(drawing[i], drawing[i+1], &rects[i], &c);
xcb_render_fill_rectangles(xcbConnection(), XCB_RENDER_PICT_OP_SRC, effects->xrenderBufferPicture(), c, n, rects);
delete [] rects;
}
}
#endif
if (effects->compositingType() == QPainterCompositing) {
QPainter *painter = effects->scenePainter();
painter->save();
QPen pen(color);
pen.setWidth(width);
painter->setPen(pen);
foreach (const Mark &mark, marks) {
drawMark(painter, mark);
}
drawMark(painter, drawing);
painter->restore();
}
}
void MouseMarkEffect::drawMark(QPainter *painter, const Mark &mark)
{
if (mark.count() <= 1) {
return;
}
for (int i = 0; i < mark.count() - 1; ++i) {
painter->drawLine(mark[i], mark[i+1]);
}
}
void MouseMarkEffect::slotMouseChanged(const QPoint& pos, const QPoint&,
Qt::MouseButtons, Qt::MouseButtons,
Qt::KeyboardModifiers modifiers, Qt::KeyboardModifiers)
{
if (modifiers == (Qt::META | Qt::SHIFT | Qt::CTRL)) { // start/finish arrow
if (arrow_start != NULL_POINT) {
marks.append(createArrow(arrow_start, pos));
arrow_start = NULL_POINT;
effects->addRepaintFull();
return;
} else
arrow_start = pos;
}
if (arrow_start != NULL_POINT)
return;
// TODO the shortcuts now trigger this right before they're activated
if (modifiers == (Qt::META | Qt::SHIFT)) { // activated
if (drawing.isEmpty())
drawing.append(pos);
if (drawing.last() == pos)
return;
QPoint pos2 = drawing.last();
drawing.append(pos);
QRect repaint = QRect(qMin(pos.x(), pos2.x()), qMin(pos.y(), pos2.y()),
qMax(pos.x(), pos2.x()), qMax(pos.y(), pos2.y()));
repaint.adjust(-width, -width, width, width);
effects->addRepaint(repaint);
} else if (!drawing.isEmpty()) {
marks.append(drawing);
drawing.clear();
}
}
void MouseMarkEffect::clear()
{
drawing.clear();
marks.clear();
effects->addRepaintFull();
}
void MouseMarkEffect::clearLast()
{
if (arrow_start != NULL_POINT) {
arrow_start = NULL_POINT;
} else if (!drawing.isEmpty()) {
drawing.clear();
effects->addRepaintFull();
} else if (!marks.isEmpty()) {
marks.pop_back();
effects->addRepaintFull();
}
}
MouseMarkEffect::Mark MouseMarkEffect::createArrow(QPoint arrow_start, QPoint arrow_end)
{
Mark ret;
double angle = atan2((double)(arrow_end.y() - arrow_start.y()), (double)(arrow_end.x() - arrow_start.x()));
ret += arrow_start + QPoint(50 * cos(angle + M_PI / 6),
50 * sin(angle + M_PI / 6)); // right one
ret += arrow_start;
ret += arrow_end;
ret += arrow_start; // it's connected lines, so go back with the middle one
ret += arrow_start + QPoint(50 * cos(angle - M_PI / 6),
50 * sin(angle - M_PI / 6)); // left one
return ret;
}
void MouseMarkEffect::screenLockingChanged(bool locked)
{
if (!marks.isEmpty() || !drawing.isEmpty()) {
effects->addRepaintFull();
}
// disable mouse polling while screen is locked.
if (locked) {
effects->stopMousePolling();
} else {
effects->startMousePolling();
}
}
bool MouseMarkEffect::isActive() const
{
return (!marks.isEmpty() || !drawing.isEmpty()) && !effects->isScreenLocked();
}
} // namespace
Reference in a new issue View git blame Copy permalink