yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/effects/startupfeedback/startupfeedback.cpp
Martin Gräßlin b265537962 Drop dependency to libplasma from kwineffects library 
Since the EffectFrames have been moved into KWin core nothing in the
Effects lib actually used Plasma. The only remaining method is moved
to core as it's not used in the Effects. The Effects itself still
link against Plasma, so nothing changes for them.

The Plasma includes in the kwineffects header seemed to pull in
quite some additional headers, so the includes in some effects have
to be adjusted (most often KConfigGroup). This should speed up the
compilation of the library and the effects.
2011-02-17 19:38:42 +01:00

415 lines
14 KiB
C++
Raw Blame History

/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2010 Martin Gräßlin <kde@martin-graesslin.com>
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 "startupfeedback.h"
// Qt
#include <QtCore/QSize>
#include <QtGui/QPainter>
// KDE
#include <KDE/KConfigGroup>
#include <KDE/KDebug>
#include <KDE/KGlobal>
#include <KDE/KIconLoader>
#include <KDE/KStandardDirs>
#include <KDE/KStartupInfo>
#include <KDE/KSelectionOwner>
// KWin
#include <kwinglutils.h>
// X11
#include <X11/Xcursor/Xcursor.h>
// based on StartupId in KRunner by Lubos Lunak
// Copyright (C) 2001 Lubos Lunak <l.lunak@kde.org>
namespace KWin
{
KWIN_EFFECT(startupfeedback, StartupFeedbackEffect)
KWIN_EFFECT_SUPPORTED(startupfeedback, StartupFeedbackEffect::supported())
// number of key frames for bouncing animation
static const int BOUNCE_FRAMES = 20;
// duration between two key frames in msec
static const int BOUNCE_FRAME_DURATION = 30;
// duration of one bounce animation
static const int BOUNCE_DURATION = BOUNCE_FRAME_DURATION * BOUNCE_FRAMES;
// number of key frames for blinking animation
static const int BLINKING_FRAMES = 5;
// duration between two key frames in msec
static const int BLINKING_FRAME_DURATION = 100;
// duration of one blinking animation
static const int BLINKING_DURATION = BLINKING_FRAME_DURATION * BLINKING_FRAMES;
//const int color_to_pixmap[] = { 0, 1, 2, 3, 2, 1 };
static const int FRAME_TO_BOUNCE_YOFFSET[] = {
-5, -1, 2, 5, 8, 10, 12, 13, 15, 15, 15, 15, 14, 12, 10, 8, 5, 2, -1, -5
};
static const QSize BOUNCE_SIZES[] = {
QSize(16, 16), QSize(14, 18), QSize(12, 20), QSize(18, 14), QSize(20, 12)
};
static const int FRAME_TO_BOUNCE_TEXTURE[] = {
0, 0, 0, 1, 2, 2, 1, 0, 3, 4, 4, 3, 0, 1, 2, 2, 1, 0, 0, 0
};
static const int FRAME_TO_BLINKING_COLOR[] = {
0, 1, 2, 3, 2, 1
};
static const QColor BLINKING_COLORS[] = {
Qt::black, Qt::darkGray, Qt::lightGray, Qt::white, Qt::white
};
StartupFeedbackEffect::StartupFeedbackEffect()
: m_startupInfo(new KStartupInfo(KStartupInfo::CleanOnCantDetect, this))
, m_selection(new KSelectionOwner("_KDE_STARTUP_FEEDBACK", -1, this))
, m_active(false)
, m_frame(0)
, m_progress(0)
, m_texture(0)
, m_type(BouncingFeedback)
, m_blinkingShader(0)
{
for (int i = 0; i < 5; ++i) {
m_bouncingTextures[i] = 0;
}
m_selection->claim(true);
connect(m_startupInfo, SIGNAL(gotNewStartup(KStartupInfoId, KStartupInfoData)), SLOT(gotNewStartup(KStartupInfoId, KStartupInfoData)));
connect(m_startupInfo, SIGNAL(gotRemoveStartup(KStartupInfoId, KStartupInfoData)), SLOT(gotRemoveStartup(KStartupInfoId, KStartupInfoData)));
connect(m_startupInfo, SIGNAL(gotStartupChange(KStartupInfoId, KStartupInfoData)), SLOT(gotStartupChange(KStartupInfoId, KStartupInfoData)));
reconfigure(ReconfigureAll);
}
StartupFeedbackEffect::~StartupFeedbackEffect()
{
if (m_active) {
effects->stopMousePolling();
}
for (int i = 0; i < 5; ++i) {
delete m_bouncingTextures[i];
}
delete m_texture;
delete m_blinkingShader;
}
bool StartupFeedbackEffect::supported()
{
return effects->compositingType() == OpenGLCompositing;
}
void StartupFeedbackEffect::reconfigure(Effect::ReconfigureFlags flags)
{
Q_UNUSED(flags)
KConfig conf("klaunchrc", KConfig::NoGlobals);
KConfigGroup c = conf.group("FeedbackStyle");
const bool busyCursor = c.readEntry("BusyCursor", true);
c = conf.group("BusyCursorSettings");
m_startupInfo->setTimeout(c.readEntry("Timeout", 30));
const bool busyBlinking = c.readEntry("Blinking", false);
const bool busyBouncing = c.readEntry("Bouncing", true);
if (!busyCursor)
m_type = NoFeedback;
else if (busyBouncing)
m_type = BouncingFeedback;
else if (busyBlinking) {
m_type = BlinkingFeedback;
if (ShaderManager::instance()->isValid()) {
delete m_blinkingShader;
m_blinkingShader = 0;
const QString shader = KGlobal::dirs()->findResource("data", "kwin/blinking-startup-fragment.glsl");
m_blinkingShader = ShaderManager::instance()->loadFragmentShader(ShaderManager::SimpleShader, shader);
if (m_blinkingShader->isValid()) {
kDebug(1212) << "Blinking Shader is valid";
} else {
kDebug(1212) << "Blinking Shader is not valid";
}
}
} else
m_type = PassiveFeedback;
if (m_active) {
stop();
start(m_startups[ m_currentStartup ]);
}
}
void StartupFeedbackEffect::prePaintScreen(ScreenPrePaintData& data, int time)
{
if (m_active) {
// need the unclipped version
switch(m_type) {
case BouncingFeedback:
m_progress = (m_progress + time) % BOUNCE_DURATION;
m_frame = qRound((qreal)m_progress / (qreal)BOUNCE_FRAME_DURATION) % BOUNCE_FRAMES;;
break;
case BlinkingFeedback:
m_progress = (m_progress + time) % BLINKING_DURATION;
m_frame = qRound((qreal)m_progress / (qreal)BLINKING_FRAME_DURATION) % BLINKING_FRAMES;
break;
default:
break; // nothing
}
m_currentGeometry = feedbackRect();
data.paint.unite(m_currentGeometry);
}
effects->prePaintScreen(data, time);
}
void StartupFeedbackEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
{
effects->paintScreen(mask, region, data);
if (m_active) {
GLTexture* texture;
switch(m_type) {
case BouncingFeedback:
texture = m_bouncingTextures[ FRAME_TO_BOUNCE_TEXTURE[ m_frame ]];
break;
case BlinkingFeedback: // fall through
case PassiveFeedback:
texture = m_texture;
break;
default:
return; // safety
}
#ifndef KWIN_HAVE_OPENGLES
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT);
#endif
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
texture->bind();
bool useShader = false;
if (m_type == BlinkingFeedback) {
const QColor& blinkingColor = BLINKING_COLORS[ FRAME_TO_BLINKING_COLOR[ m_frame ]];
if (m_blinkingShader && m_blinkingShader->isValid()) {
useShader = true;
ShaderManager::instance()->pushShader(m_blinkingShader);
m_blinkingShader->setUniform("u_color", blinkingColor);
} else {
#ifndef KWIN_HAVE_OPENGLES
// texture transformation
float color[4] = { blinkingColor.redF(), blinkingColor.greenF(), blinkingColor.blueF(), 1.0f };
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glColor4fv(color);
glActiveTexture(GL_TEXTURE1);
texture->bind();
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_CONSTANT);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
glActiveTexture(GL_TEXTURE0);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, color);
#endif
}
} else if (ShaderManager::instance()->isValid()) {
useShader = true;
ShaderManager::instance()->pushShader(ShaderManager::SimpleShader);
}
texture->render(m_currentGeometry, m_currentGeometry);
if (useShader) {
ShaderManager::instance()->popShader();
}
if (m_type == BlinkingFeedback && !useShader) {
#ifndef KWIN_HAVE_OPENGLES
// resture states
glActiveTexture(GL_TEXTURE1);
texture->unbind();
glActiveTexture(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glColor4f(0.0f, 0.0f, 0.0f, 0.0f);
#endif
}
texture->unbind();
glDisable(GL_BLEND);
#ifndef KWIN_HAVE_OPENGLES
glPopAttrib();
#endif
}
}
void StartupFeedbackEffect::postPaintScreen()
{
if (m_active) {
switch(m_type) {
case BouncingFeedback: // fall through
case BlinkingFeedback:
// repaint the icon
effects->addRepaint(m_currentGeometry);
break;
case PassiveFeedback: // fall through
default:
// no need to repaint - no change
break;
}
}
effects->postPaintScreen();
}
void StartupFeedbackEffect::mouseChanged(const QPoint& pos, const QPoint& oldpos, Qt::MouseButtons buttons,
Qt::MouseButtons oldbuttons, Qt::KeyboardModifiers modifiers, Qt::KeyboardModifiers oldmodifiers)
{
Q_UNUSED(pos)
Q_UNUSED(oldpos)
Q_UNUSED(buttons)
Q_UNUSED(oldbuttons)
Q_UNUSED(modifiers)
Q_UNUSED(oldmodifiers)
if (m_active) {
effects->addRepaint(m_currentGeometry);
effects->addRepaint(feedbackRect());
}
}
void StartupFeedbackEffect::gotNewStartup(const KStartupInfoId& id, const KStartupInfoData& data)
{
const QString& icon = data.findIcon();
m_currentStartup = id;
m_startups[ id ] = icon;
start(icon);
}
void StartupFeedbackEffect::gotRemoveStartup(const KStartupInfoId& id, const KStartupInfoData& data)
{
m_startups.remove(id);
if (m_startups.count() == 0) {
m_currentStartup = KStartupInfoId(); // null
stop();
return;
}
m_currentStartup = m_startups.begin().key();
start(m_startups[ m_currentStartup ]);
}
void StartupFeedbackEffect::gotStartupChange(const KStartupInfoId& id, const KStartupInfoData& data)
{
if (m_currentStartup == id) {
const QString& icon = data.findIcon();
if (!icon.isEmpty() && icon != m_startups[ m_currentStartup ]) {
m_startups[ id ] = icon;
start(icon);
}
}
}
void StartupFeedbackEffect::start(const QString& icon)
{
if (m_type == NoFeedback)
return;
if (!m_active)
effects->startMousePolling();
m_active = true;
QPixmap iconPixmap = KIconLoader::global()->loadIcon(icon, KIconLoader::Small, 0,
KIconLoader::DefaultState, QStringList(), 0, true); // return null pixmap if not found
if (iconPixmap.isNull())
iconPixmap = SmallIcon("system-run");
prepareTextures(iconPixmap);
effects->addRepaintFull();
}
void StartupFeedbackEffect::stop()
{
if (m_active)
effects->stopMousePolling();
m_active = false;
switch(m_type) {
case BouncingFeedback:
for (int i = 0; i < 5; ++i) {
delete m_bouncingTextures[i];
m_bouncingTextures[i] = 0;
}
break;
case BlinkingFeedback:
case PassiveFeedback:
delete m_texture;
m_texture = 0;
break;
case NoFeedback:
return; // don't want the full repaint
default:
break; // impossible
}
effects->addRepaintFull();
}
void StartupFeedbackEffect::prepareTextures(const QPixmap& pix)
{
switch(m_type) {
case BouncingFeedback:
for (int i = 0; i < 5; ++i) {
delete m_bouncingTextures[i];
m_bouncingTextures[i] = new GLTexture(scalePixmap(pix, BOUNCE_SIZES[i]));
}
break;
case BlinkingFeedback:
case PassiveFeedback:
m_texture = new GLTexture(pix);
break;
default:
// for safety
m_active = false;
break;
}
}
QImage StartupFeedbackEffect::scalePixmap(const QPixmap& pm, const QSize& size) const
{
QImage scaled = pm.toImage().scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
if (scaled.format() != QImage::Format_ARGB32_Premultiplied && scaled.format() != QImage::Format_ARGB32)
scaled = scaled.convertToFormat(QImage::Format_ARGB32);
QImage result(20, 20, QImage::Format_ARGB32);
QPainter p(&result);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.fillRect(result.rect(), Qt::transparent);
p.drawImage((20 - size.width()) / 2, (20 - size.height()) / 2, scaled, 0, 0, size.width(), size.height());
return result;
}
QRect StartupFeedbackEffect::feedbackRect() const
{
int cursorSize = 0;
cursorSize = XcursorGetDefaultSize(QX11Info::display());
int xDiff;
if (cursorSize <= 16)
xDiff = 8 + 7;
else if (cursorSize <= 32)
xDiff = 16 + 7;
else if (cursorSize <= 48)
xDiff = 24 + 7;
else
xDiff = 32 + 7;
int yDiff = xDiff;
GLTexture* texture;
int yOffset = 0;
switch(m_type) {
case BouncingFeedback:
texture = m_bouncingTextures[ FRAME_TO_BOUNCE_TEXTURE[ m_frame ]];
yOffset = FRAME_TO_BOUNCE_YOFFSET[ m_frame ];
break;
case BlinkingFeedback: // fall through
case PassiveFeedback:
texture = m_texture;
break;
default:
// nothing
break;
}
const QPoint cursorPos = effects->cursorPos() + QPoint(xDiff, yDiff + yOffset);
const QRect rect(cursorPos, texture->size());
return rect;
}
} // namespace
Reference in a new issue View git blame Copy permalink