kiconeffect.cpp
/* vi: ts=8 sts=4 sw=4
* $Id: kiconeffect.cpp 389958 2005-02-16 15:51:35Z gunnar $
*
* This file is part of the KDE project, module kdecore.
* Copyright (C) 2000 Geert Jansen <jansen@kde.org>
* with minor additions and based on ideas from
* Torsten Rahn <torsten@kde.org>
*
* This is free software; it comes under the GNU Library General
* Public License, version 2. See the file "COPYING.LIB" for the
* exact licensing terms.
*/
#include <config.h>
#include <unistd.h>
#include <math.h>
#include <qstring.h>
#include <qstringlist.h>
#include <qbitmap.h>
#include <qpixmap.h>
#include <qimage.h>
#include <qcolor.h>
#include <qwidget.h>
#include <qpainter.h>
#include <qpen.h>
#include <kdebug.h>
#include <kglobal.h>
#include <kconfig.h>
#include <kglobalsettings.h>
#include <kicontheme.h>
#include "kiconeffect.h"
#if defined(Q_WS_WIN) || defined(Q_WS_MACX)
static bool qt_use_xrender=true;
static bool qt_has_xft=true;
#else
extern bool qt_use_xrender;
extern bool qt_has_xft;
#endif
class KIconEffectPrivate
{
public:
QString mKey[6][3];
QColor mColor2[6][3];
};
KIconEffect::KIconEffect()
{
d = new KIconEffectPrivate;
init();
}
KIconEffect::~KIconEffect()
{
delete d;
d = 0L;
}
void KIconEffect::init()
{
KConfig *config = KGlobal::config();
int i, j, effect=-1;
QStringList groups;
groups += "Desktop";
groups += "Toolbar";
groups += "MainToolbar";
groups += "Small";
groups += "Panel";
QStringList states;
states += "Default";
states += "Active";
states += "Disabled";
QStringList::ConstIterator it, it2;
QString _togray("togray");
QString _colorize("colorize");
QString _desaturate("desaturate");
QString _togamma("togamma");
QString _none("none");
QString _tomonochrome("tomonochrome");
KConfigGroupSaver cs(config, "default");
for (it=groups.begin(), i=0; it!=groups.end(); it++, i++)
{
// Default effects
mEffect[i][0] = NoEffect;
mEffect[i][1] = ((i==0)||(i==4)) ? ToGamma : NoEffect;
mEffect[i][2] = ToGray;
mTrans[i][0] = false;
mTrans[i][1] = false;
mTrans[i][2] = true;
mValue[i][0] = 1.0;
mValue[i][1] = ((i==0)||(i==4)) ? 0.7 : 1.0;
mValue[i][2] = 1.0;
mColor[i][0] = QColor(144,128,248);
mColor[i][1] = QColor(169,156,255);
mColor[i][2] = QColor(34,202,0);
d->mColor2[i][0] = QColor(0,0,0);
d->mColor2[i][1] = QColor(0,0,0);
d->mColor2[i][2] = QColor(0,0,0);
config->setGroup(*it + "Icons");
for (it2=states.begin(), j=0; it2!=states.end(); it2++, j++)
{
QString tmp = config->readEntry(*it2 + "Effect");
if (tmp == _togray)
effect = ToGray;
else if (tmp == _colorize)
effect = Colorize;
else if (tmp == _desaturate)
effect = DeSaturate;
else if (tmp == _togamma)
effect = ToGamma;
else if (tmp == _tomonochrome)
effect = ToMonochrome;
else if (tmp == _none)
effect = NoEffect;
else
continue;
if(effect != -1)
mEffect[i][j] = effect;
mValue[i][j] = config->readDoubleNumEntry(*it2 + "Value");
mColor[i][j] = config->readColorEntry(*it2 + "Color");
d->mColor2[i][j] = config->readColorEntry(*it2 + "Color2");
mTrans[i][j] = config->readBoolEntry(*it2 + "SemiTransparent");
}
}
}
bool KIconEffect::hasEffect(int group, int state) const
{
return mEffect[group][state] != NoEffect;
}
QString KIconEffect::fingerprint(int group, int state) const
{
if ( group >= KIcon::LastGroup ) return "";
QString cached = d->mKey[group][state];
if (cached.isEmpty())
{
QString tmp;
cached = tmp.setNum(mEffect[group][state]);
cached += ':';
cached += tmp.setNum(mValue[group][state]);
cached += ':';
cached += mTrans[group][state] ? QString::fromLatin1("trans")
: QString::fromLatin1("notrans");
if (mEffect[group][state] == Colorize || mEffect[group][state] == ToMonochrome)
{
cached += ':';
cached += mColor[group][state].name();
}
if (mEffect[group][state] == ToMonochrome)
{
cached += ':';
cached += d->mColor2[group][state].name();
}
d->mKey[group][state] = cached;
}
return cached;
}
QImage KIconEffect::apply(QImage image, int group, int state) const
{
if (state >= KIcon::LastState)
{
kdDebug(265) << "Illegal icon state: " << state << "\n";
return image;
}
if (group >= KIcon::LastGroup)
{
kdDebug(265) << "Illegal icon group: " << group << "\n";
return image;
}
return apply(image, mEffect[group][state], mValue[group][state],
mColor[group][state], d->mColor2[group][state], mTrans[group][state]);
}
QImage KIconEffect::apply(QImage image, int effect, float value, const QColor col, bool trans) const
{
return apply (image, effect, value, col, KGlobalSettings::baseColor(), trans);
}
QImage KIconEffect::apply(QImage image, int effect, float value, const QColor col, const QColor col2, bool trans) const
{
if (effect >= LastEffect )
{
kdDebug(265) << "Illegal icon effect: " << effect << "\n";
return image;
}
if (value > 1.0)
value = 1.0;
else if (value < 0.0)
value = 0.0;
switch (effect)
{
case ToGray:
toGray(image, value);
break;
case DeSaturate:
deSaturate(image, value);
break;
case Colorize:
colorize(image, col, value);
break;
case ToGamma:
toGamma(image, value);
break;
case ToMonochrome:
toMonochrome(image, col, col2, value);
break;
}
if (trans == true)
{
semiTransparent(image);
}
return image;
}
QPixmap KIconEffect::apply(QPixmap pixmap, int group, int state) const
{
if (state >= KIcon::LastState)
{
kdDebug(265) << "Illegal icon state: " << state << "\n";
return pixmap;
}
if (group >= KIcon::LastGroup)
{
kdDebug(265) << "Illegal icon group: " << group << "\n";
return pixmap;
}
return apply(pixmap, mEffect[group][state], mValue[group][state],
mColor[group][state], d->mColor2[group][state], mTrans[group][state]);
}
QPixmap KIconEffect::apply(QPixmap pixmap, int effect, float value,
const QColor col, bool trans) const
{
return apply (pixmap, effect, value, col, KGlobalSettings::baseColor(), trans);
}
QPixmap KIconEffect::apply(QPixmap pixmap, int effect, float value,
const QColor col, const QColor col2, bool trans) const
{
QPixmap result;
if (effect >= LastEffect )
{
kdDebug(265) << "Illegal icon effect: " << effect << "\n";
return result;
}
if ((trans == true) && (effect == NoEffect))
{
result = pixmap;
semiTransparent(result);
}
else if ( effect != NoEffect )
{
QImage tmpImg = pixmap.convertToImage();
tmpImg = apply(tmpImg, effect, value, col, col2, trans);
result.convertFromImage(tmpImg);
}
else
result = pixmap;
return result;
}
// Taken from KImageEffect. We don't want to link kdecore to kdeui! As long
// as this code is not too big, it doesn't seem much of a problem to me.
void KIconEffect::toGray(QImage &img, float value)
{
int pixels = (img.depth() > 8) ? img.width()*img.height()
: img.numColors();
unsigned int *data = img.depth() > 8 ? (unsigned int *) img.bits()
: (unsigned int *) img.colorTable();
int rval, gval, bval, val, alpha, i;
for (i=0; i<pixels; i++)
{
val = qGray(data[i]);
alpha = qAlpha(data[i]);
if (value < 1.0)
{
rval = static_cast<int>(value*val+(1.0-value)*qRed(data[i]));
gval = static_cast<int>(value*val+(1.0-value)*qGreen(data[i]));
bval = static_cast<int>(value*val+(1.0-value)*qBlue(data[i]));
data[i] = qRgba(rval, gval, bval, alpha);
} else
data[i] = qRgba(val, val, val, alpha);
}
}
void KIconEffect::colorize(QImage &img, const QColor &col, float value)
{
int pixels = (img.depth() > 8) ? img.width()*img.height()
: img.numColors();
unsigned int *data = img.depth() > 8 ? (unsigned int *) img.bits()
: (unsigned int *) img.colorTable();
int rval, gval, bval, val, alpha, i;
float rcol = col.red(), gcol = col.green(), bcol = col.blue();
for (i=0; i<pixels; i++)
{
val = qGray(data[i]);
if (val < 128)
{
rval = static_cast<int>(rcol/128*val);
gval = static_cast<int>(gcol/128*val);
bval = static_cast<int>(bcol/128*val);
}
else if (val > 128)
{
rval = static_cast<int>((val-128)*(2-rcol/128)+rcol-1);
gval = static_cast<int>((val-128)*(2-gcol/128)+gcol-1);
bval = static_cast<int>((val-128)*(2-bcol/128)+bcol-1);
}
else // val == 128
{
rval = static_cast<int>(rcol);
gval = static_cast<int>(gcol);
bval = static_cast<int>(bcol);
}
if (value < 1.0)
{
rval = static_cast<int>(value*rval+(1.0 - value)*qRed(data[i]));
gval = static_cast<int>(value*gval+(1.0 - value)*qGreen(data[i]));
bval = static_cast<int>(value*bval+(1.0 - value)*qBlue(data[i]));
}
alpha = qAlpha(data[i]);
data[i] = qRgba(rval, gval, bval, alpha);
}
}
void KIconEffect::toMonochrome(QImage &img, const QColor &black, const QColor &white, float value) {
int pixels = (img.depth() > 8) ? img.width()*img.height() : img.numColors();
unsigned int *data = img.depth() > 8 ? (unsigned int *) img.bits()
: (unsigned int *) img.colorTable();
int rval, gval, bval, alpha, i;
int rw = white.red(), gw = white.green(), bw = white.blue();
int rb = black.red(), gb = black.green(), bb = black.blue();
double values = 0, sum = 0;
bool grayscale = true;
// Step 1: determine the average brightness
for (i=0; i<pixels; i++) {
sum += qGray(data[i])*qAlpha(data[i]) + 255*(255-qAlpha(data[i]));
values += 255;
if ((qRed(data[i]) != qGreen(data[i]) ) || (qGreen(data[i]) != qBlue(data[i]) ))
grayscale = false;
}
double medium = sum/values;
// Step 2: Modify the image
if (grayscale) {
for (i=0; i<pixels; i++) {
int v = qRed(data[i]);
rval = static_cast<int>( ((255-v)*rb + v*rw)*value/255 + (1.0-value)*qRed(data[i]));
gval = static_cast<int>( ((255-v)*gb + v*gw)*value/255 + (1.0-value)*qGreen(data[i]));
bval = static_cast<int>( ((255-v)*bb + v*bw)*value/255 + (1.0-value)*qBlue(data[i]));
alpha = qAlpha(data[i]);
data[i] = qRgba(rval, gval, bval, alpha);
}
}
else {
for (i=0; i<pixels; i++) {
if (qGray(data[i]) <= medium) {
rval = static_cast<int>(value*rb+(1.0-value)*qRed(data[i]));
gval = static_cast<int>(value*gb+(1.0-value)*qGreen(data[i]));
bval = static_cast<int>(value*bb+(1.0-value)*qBlue(data[i]));
}
else {
rval = static_cast<int>(value*rw+(1.0-value)*qRed(data[i]));
gval = static_cast<int>(value*gw+(1.0-value)*qGreen(data[i]));
bval = static_cast<int>(value*bw+(1.0-value)*qBlue(data[i]));
}
alpha = qAlpha(data[i]);
data[i] = qRgba(rval, gval, bval, alpha);
}
}
}
void KIconEffect::deSaturate(QImage &img, float value)
{
int pixels = (img.depth() > 8) ? img.width()*img.height()
: img.numColors();
unsigned int *data = (img.depth() > 8) ? (unsigned int *) img.bits()
: (unsigned int *) img.colorTable();
QColor color;
int h, s, v, i;
for (i=0; i<pixels; i++)
{
color.setRgb(data[i]);
color.hsv(&h, &s, &v);
color.setHsv(h, (int) (s * (1.0 - value) + 0.5), v);
data[i] = qRgba(color.red(), color.green(), color.blue(),
qAlpha(data[i]));
}
}
void KIconEffect::toGamma(QImage &img, float value)
{
int pixels = (img.depth() > 8) ? img.width()*img.height()
: img.numColors();
unsigned int *data = (img.depth() > 8) ? (unsigned int *) img.bits()
: (unsigned int *) img.colorTable();
QColor color;
int i, rval, gval, bval;
float gamma;
gamma = 1/(2*value+0.5);
for (i=0; i<pixels; i++)
{
color.setRgb(data[i]);
color.rgb(&rval, &gval, &bval);
rval = static_cast<int>(pow(static_cast<float>(rval)/255 , gamma)*255);
gval = static_cast<int>(pow(static_cast<float>(gval)/255 , gamma)*255);
bval = static_cast<int>(pow(static_cast<float>(bval)/255 , gamma)*255);
data[i] = qRgba(rval, gval, bval, qAlpha(data[i]));
}
}
void KIconEffect::semiTransparent(QImage &img)
{
img.setAlphaBuffer(true);
int x, y;
if (img.depth() == 32)
{
int width = img.width();
int height = img.height();
if (qt_use_xrender && qt_has_xft )
for (y=0; y<height; y++)
{
#ifdef WORDS_BIGENDIAN
uchar *line = (uchar*) img.scanLine(y);
#else
uchar *line = (uchar*) img.scanLine(y) + 3;
#endif
for (x=0; x<width; x++)
{
*line >>= 1;
line += 4;
}
}
else
for (y=0; y<height; y++)
{
QRgb *line = (QRgb *) img.scanLine(y);
for (x=(y%2); x<width; x+=2)
line[x] &= 0x00ffffff;
}
} else
{
// Insert transparent pixel into the clut.
int transColor = -1;
// search for a color that is already transparent
for (x=0; x<img.numColors(); x++)
{
// try to find already transparent pixel
if (qAlpha(img.color(x)) < 127)
{
transColor = x;
break;
}
}
// FIXME: image must have transparency
if(transColor < 0 || transColor >= img.numColors())
return;
img.setColor(transColor, 0);
if(img.depth() == 8)
{
for (y=0; y<img.height(); y++)
{
unsigned char *line = img.scanLine(y);
for (x=(y%2); x<img.width(); x+=2)
line[x] = transColor;
}
}
else
{
// SLOOW, but simple, as we would have to
// deal with endianess etc on our own here
for (y=0; y<img.height(); y++)
for (x=(y%2); x<img.width(); x+=2)
img.setPixel(x, y, transColor);
}
}
}
void KIconEffect::semiTransparent(QPixmap &pix)
{
if ( qt_use_xrender && qt_has_xft )
{
QImage img=pix.convertToImage();
semiTransparent(img);
pix.convertFromImage(img);
return;
}
QImage img;
if (pix.mask() != 0L)
img = pix.mask()->convertToImage();
else
{
img.create(pix.size(), 1, 2, QImage::BigEndian);
img.fill(1);
}
for (int y=0; y<img.height(); y++)
{
QRgb *line = (QRgb *) img.scanLine(y);
QRgb pattern = (y % 2) ? 0x55555555 : 0xaaaaaaaa;
for (int x=0; x<(img.width()+31)/32; x++)
line[x] &= pattern;
}
QBitmap mask;
mask.convertFromImage(img);
pix.setMask(mask);
}
QImage KIconEffect::doublePixels(QImage src) const
{
QImage dst;
if (src.depth() == 1)
{
kdDebug(265) << "image depth 1 not supported\n";
return dst;
}
int w = src.width();
int h = src.height();
dst.create(w*2, h*2, src.depth());
dst.setAlphaBuffer(src.hasAlphaBuffer());
int x, y;
if (src.depth() == 32)
{
QRgb *l1, *l2;
for (y=0; y<h; y++)
{
l1 = (QRgb *) src.scanLine(y);
l2 = (QRgb *) dst.scanLine(y*2);
for (x=0; x<w; x++)
{
l2[x*2] = l2[x*2+1] = l1[x];
}
memcpy(dst.scanLine(y*2+1), l2, dst.bytesPerLine());
}
} else
{
for (x=0; x<src.numColors(); x++)
dst.setColor(x, src.color(x));
unsigned char *l1, *l2;
for (y=0; y<h; y++)
{
l1 = src.scanLine(y);
l2 = dst.scanLine(y*2);
for (x=0; x<w; x++)
{
l2[x*2] = l1[x];
l2[x*2+1] = l1[x];
}
memcpy(dst.scanLine(y*2+1), l2, dst.bytesPerLine());
}
}
return dst;
}
void KIconEffect::overlay(QImage &src, QImage &overlay)
{
if (src.depth() != overlay.depth())
{
kdDebug(265) << "Image depth src != overlay!\n";
return;
}
if (src.size() != overlay.size())
{
kdDebug(265) << "Image size src != overlay\n";
return;
}
if (!overlay.hasAlphaBuffer())
{
kdDebug(265) << "Overlay doesn't have alpha buffer!\n";
return;
}
int i, j;
// We don't do 1 bpp
if (src.depth() == 1)
{
kdDebug(265) << "1bpp not supported!\n";
return;
}
// Overlay at 8 bpp doesn't use alpha blending
if (src.depth() == 8)
{
if (src.numColors() + overlay.numColors() > 255)
{
kdDebug(265) << "Too many colors in src + overlay!\n";
return;
}
// Find transparent pixel in overlay
int trans;
for (trans=0; trans<overlay.numColors(); trans++)
{
if (qAlpha(overlay.color(trans)) == 0)
{
kdDebug(265) << "transparent pixel found at " << trans << "\n";
break;
}
}
if (trans == overlay.numColors())
{
kdDebug(265) << "transparent pixel not found!\n";
return;
}
// Merge color tables
int nc = src.numColors();
src.setNumColors(nc + overlay.numColors());
for (i=0; i<overlay.numColors(); i++)
{
src.setColor(nc+i, overlay.color(i));
}
// Overwrite nontransparent pixels.
unsigned char *oline, *sline;
for (i=0; i<src.height(); i++)
{
oline = overlay.scanLine(i);
sline = src.scanLine(i);
for (j=0; j<src.width(); j++)
{
if (oline[j] != trans)
sline[j] = oline[j]+nc;
}
}
}
// Overlay at 32 bpp does use alpha blending
if (src.depth() == 32)
{
QRgb *oline, *sline;
int r1, g1, b1, a1;
int r2, g2, b2, a2;
for (i=0; i<src.height(); i++)
{
oline = (QRgb *) overlay.scanLine(i);
sline = (QRgb *) src.scanLine(i);
for (j=0; j<src.width(); j++)
{
r1 = qRed(oline[j]);
g1 = qGreen(oline[j]);
b1 = qBlue(oline[j]);
a1 = qAlpha(oline[j]);
r2 = qRed(sline[j]);
g2 = qGreen(sline[j]);
b2 = qBlue(sline[j]);
a2 = qAlpha(sline[j]);
r2 = (a1 * r1 + (0xff - a1) * r2) >> 8;
g2 = (a1 * g1 + (0xff - a1) * g2) >> 8;
b2 = (a1 * b1 + (0xff - a1) * b2) >> 8;
a2 = QMAX(a1, a2);
sline[j] = qRgba(r2, g2, b2, a2);
}
}
}
return;
}
void
KIconEffect::visualActivate(QWidget * widget, QRect rect)
{
if (!KGlobalSettings::visualActivate())
return;
uint actSpeed = KGlobalSettings::visualActivateSpeed();
uint actCount = QMIN(rect.width(), rect.height()) / 2;
// Clip actCount to range 1..10.
if (actCount < 1)
actCount = 1;
else if (actCount > 10)
actCount = 10;
// Clip actSpeed to range 1..100.
if (actSpeed < 1)
actSpeed = 1;
else if (actSpeed > 100)
actSpeed = 100;
// actSpeed needs to be converted to actDelay.
// actDelay is inversely proportional to actSpeed and needs to be
// divided up into actCount portions.
// We also convert the us value to ms.
unsigned int actDelay = (1000 * (100 - actSpeed)) / actCount;
//kdDebug() << "actCount=" << actCount << " actDelay=" << actDelay << endl;
QPoint c = rect.center();
QPainter p(widget);
// Use NotROP to avoid having to repaint the pixmap each time.
p.setPen(QPen(Qt::black, 2, Qt::DotLine));
p.setRasterOp(Qt::NotROP);
// The spacing between the rects we draw.
// Use the minimum of width and height to avoid painting outside the
// pixmap area.
//unsigned int delta(QMIN(rect.width() / actCount, rect.height() / actCount));
// Support for rectangles by David
unsigned int deltaX = rect.width() / actCount;
unsigned int deltaY = rect.height() / actCount;
for (unsigned int i = 1; i < actCount; i++) {
int w = i * deltaX;
int h = i * deltaY;
rect.setRect(c.x() - w / 2, c.y() - h / 2, w, h);
p.drawRect(rect);
p.flush();
usleep(actDelay);
p.drawRect(rect);
}
}
KIconEffect::visualActivate
static void visualActivate(QWidget *widget, QRect rect)
Provides visual feedback to show activation of an icon on a widget.
Definition: kiconeffect.cpp:704
KIconEffect::semiTransparent
static void semiTransparent(QImage &image)
Renders an image semi-transparent.
Definition: kiconeffect.cpp:435
KIconEffect::apply
QImage apply(QImage src, int group, int state) const
Applies an effect to an image.
Definition: kiconeffect.cpp:172
KIcon::LastState
Last state (last constant)
Definition: kicontheme.h:132
KIconEffect::toMonochrome
static void toMonochrome(QImage &image, const QColor &black, const QColor &white, float value)
Produces a monochrome icon with a given foreground and background color.
Definition: kiconeffect.cpp:345
KGlobalSettings::baseColor
static QColor baseColor()
Returns the default base (background) color.
Definition: kglobalsettings.cpp:235
KIconEffect::overlay
static void overlay(QImage &src, QImage &overlay)
Overlays an image with an other image.
Definition: kiconeffect.cpp:589
KIconEffect::KIconEffect
KIconEffect()
Create a new KIconEffect.
Definition: kiconeffect.cpp:49
KGlobalSettings::visualActivateSpeed
static unsigned int visualActivateSpeed()
Returns the speed of the visual activation feedback.
Definition: kglobalsettings.cpp:114
KIcon::LastGroup
Last group.
Definition: kicontheme.h:103
KIconEffect::colorize
static void colorize(QImage &image, const QColor &col, float value)
Colorizes an image with a specific color.
Definition: kiconeffect.cpp:304
KIconEffect::deSaturate
static void deSaturate(QImage &image, float value)
Desaturates an image.
Definition: kiconeffect.cpp:395
KConfigBase::readDoubleNumEntry
double readDoubleNumEntry(const QString &pKey, double nDefault=0.0) const
Reads a floating point value.
Definition: kconfigbase.cpp:697
KIconEffect::init
void init()
Rereads configuration.
Definition: kiconeffect.cpp:61
KIconEffect::toGamma
static void toGamma(QImage &image, float value)
Changes the gamma value of an image.
Definition: kiconeffect.cpp:413
KConfigGroupSaver
Helper class to facilitate working with KConfig / KSimpleConfig groups.
Definition: kconfigbase.h:2057
KConfigBase::readColorEntry
QColor readColorEntry(const QString &pKey, const QColor *pDefault=0L) const
Reads a QColor entry.
Definition: kconfigbase.cpp:915
KConfig
Access KDE Configuration entries.
Definition: kconfig.h:43
KConfigBase::readEntry
QString readEntry(const QString &pKey, const QString &aDefault=QString::null) const
Reads the value of an entry specified by pKey in the current group.
Definition: kconfigbase.cpp:203
KIconEffect::fingerprint
QString fingerprint(int group, int state) const
Returns a fingerprint for the effect by encoding the given group and state into a QString...
Definition: kiconeffect.cpp:142
KIconEffect::hasEffect
bool hasEffect(int group, int state) const
Tests whether an effect has been configured for the given icon group.
Definition: kiconeffect.cpp:137
KIconEffect::toGray
static void toGray(QImage &image, float value)
Tints an image gray.
Definition: kiconeffect.cpp:282
KConfigBase::readBoolEntry
bool readBoolEntry(const QString &pKey, bool bDefault=false) const
Reads a boolean entry.
Definition: kconfigbase.cpp:716
KIconEffect::ToMonochrome
Definition: kiconeffect.h:56
KGlobalSettings::visualActivate
static bool visualActivate()
Checks whether to show feedback when in item (specifically an icon) is activated. ...
Definition: kglobalsettings.cpp:108
KConfigBase::setGroup
void setGroup(const QString &group)
Specifies the group in which keys will be read and written.
Definition: kconfigbase.cpp:79
KGlobal::config
static KConfig * config()
Returns the general config object.
Definition: kglobal.cpp:61
KIconEffect::doublePixels
QImage doublePixels(QImage src) const
Returns an image twice as large, consisting of 2x2 pixels.
Definition: kiconeffect.cpp:540

KDE Home | KDE Accessibility Home | Description of Access Keys