664 lines
21 KiB
C++
664 lines
21 KiB
C++
/*
|
|
* Copyright 2008 Long Huynh Huu <long.upcase@googlemail.com>
|
|
* Copyright 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
|
|
* Copyright 2007 Casper Boemann <cbr@boemann.dk>
|
|
* Copyright 2007 Fredrik Höglund <fredrik@kde.org>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License version 2 as published by the Free Software Foundation.
|
|
*
|
|
* This library 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
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public License
|
|
* along with this library; see the file COPYING.LIB. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <KGlobalSettings>
|
|
#include <KColorUtils>
|
|
#include <KColorScheme>
|
|
#include <QWidget>
|
|
#include <QPainter>
|
|
#include <math.h>
|
|
|
|
#include "helper.h"
|
|
|
|
|
|
const double NitrogenHelper::_shadowGain = 1.5;
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
NitrogenHelper::NitrogenHelper(const QByteArray &componentName):
|
|
_componentData(componentName, 0, KComponentData::SkipMainComponentRegistration)
|
|
{
|
|
_config = _componentData.config();
|
|
_contrast = KGlobalSettings::contrastF(_config);
|
|
_bgcontrast = 0.3;
|
|
|
|
m_backgroundCache.setMaxCost(64);
|
|
m_windecoButtonCache.setMaxCost(64);
|
|
m_windecoButtonGlowCache.setMaxCost(64);
|
|
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
KSharedConfigPtr NitrogenHelper::config() const
|
|
{ return _config; }
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
void NitrogenHelper::reloadConfig()
|
|
{
|
|
double old_contrast = _contrast;
|
|
|
|
_config->reparseConfiguration();
|
|
_contrast = KGlobalSettings::contrastF(_config);
|
|
|
|
// contrast changed, invalidate our caches
|
|
if (_contrast != old_contrast) invalidateCaches();
|
|
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
void NitrogenHelper::renderWindowBackground(
|
|
QPainter *p,
|
|
const QRect &clipRect,
|
|
const QWidget *widget,
|
|
const QPalette & pal,
|
|
int gradient_shift )
|
|
{
|
|
|
|
if (clipRect.isValid()) {
|
|
p->save();
|
|
p->setClipRegion(clipRect,Qt::IntersectClip);
|
|
}
|
|
|
|
QRect r = widget->window()->rect();
|
|
|
|
// use an additional pixmap for buffering
|
|
// to avoid flicker observe when painting large (wide) windows
|
|
QPixmap pixmap( r.size() );
|
|
{
|
|
|
|
QPainter p( &pixmap );
|
|
if (clipRect.isValid()) p.setClipRegion(clipRect);
|
|
|
|
// get coordinates relative to the client area
|
|
const QWidget* w = widget;
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
// get window
|
|
while (!w->isWindow())
|
|
{
|
|
x += w->geometry().x();
|
|
y += w->geometry().y();
|
|
w = w->window();
|
|
}
|
|
|
|
QColor color = pal.color( w->backgroundRole() );
|
|
int splitY = qMin(300, 3*r.height()/4);
|
|
|
|
QRect upperRect = QRect(-x, -y, r.width(), splitY);
|
|
QPixmap tile = verticalGradient(color, splitY);
|
|
p.drawTiledPixmap(upperRect, tile);
|
|
|
|
QRect lowerRect = QRect(-x, splitY-y, r.width(), r.height() - splitY);
|
|
p.fillRect(lowerRect, backgroundBottomColor(color));
|
|
int radialW = qMin(600, r.width());
|
|
|
|
// on first paint the frame may not have been done yet, so just fixate it
|
|
QRect radialRect = QRect((r.width() - radialW)/2 - x, -y, radialW, 64+gradient_shift);
|
|
if (clipRect.intersects(radialRect))
|
|
{
|
|
tile = radialGradient(color, radialW, gradient_shift );
|
|
p.drawPixmap(radialRect, tile);
|
|
}
|
|
|
|
}
|
|
|
|
p->drawPixmap( r, pixmap );
|
|
if (clipRect.isValid()) p->restore();
|
|
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
void NitrogenHelper::invalidateCaches()
|
|
{
|
|
m_backgroundCache.clear();
|
|
m_windecoButtonCache.clear();
|
|
m_windecoButtonGlowCache.clear();
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
bool NitrogenHelper::lowThreshold(const QColor &color)
|
|
{
|
|
QColor darker = KColorScheme::shade(color, KColorScheme::MidShade, 0.5);
|
|
return KColorUtils::luma(darker) > KColorUtils::luma(color);
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QColor NitrogenHelper::alphaColor(QColor color, double alpha)
|
|
{
|
|
if (alpha < 1.0) color.setAlphaF( qMax(0.0, alpha) * color.alphaF() );
|
|
return color;
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QColor NitrogenHelper::backgroundRadialColor(const QColor &color) const
|
|
{
|
|
return lowThreshold(color) ?
|
|
KColorScheme::shade(color, KColorScheme::LightShade, 0.0):
|
|
KColorScheme::shade(color, KColorScheme::LightShade, _bgcontrast);
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QColor NitrogenHelper::backgroundTopColor(const QColor &color) const
|
|
{
|
|
return lowThreshold(color) ?
|
|
KColorScheme::shade(color, KColorScheme::MidlightShade, 0.0):
|
|
KColorScheme::shade(color, KColorScheme::MidlightShade, _bgcontrast);
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QColor NitrogenHelper::backgroundBottomColor(const QColor &color) const
|
|
{
|
|
QColor midColor = KColorScheme::shade(color, KColorScheme::MidShade, 0.0);
|
|
if (lowThreshold(color)) return midColor;
|
|
|
|
double by = KColorUtils::luma(color), my = KColorUtils::luma(midColor);
|
|
return KColorUtils::shade(color, (my - by) * _bgcontrast);
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QColor NitrogenHelper::calcLightColor(const QColor &color) const
|
|
{ return KColorScheme::shade(color, KColorScheme::LightShade, _contrast); }
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QColor NitrogenHelper::calcDarkColor(const QColor &color) const
|
|
{
|
|
return lowThreshold(color) ?
|
|
KColorUtils::mix(calcLightColor(color), color, 0.2 + 0.8 * _contrast):
|
|
KColorScheme::shade(color, KColorScheme::MidShade, _contrast);
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QColor NitrogenHelper::calcShadowColor(const QColor &color) const
|
|
{
|
|
return
|
|
KColorScheme::shade(KColorUtils::mix(QColor(255,255,255),color, color.alpha()*(1/255.0)),
|
|
KColorScheme::ShadowShade, _contrast);
|
|
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QColor NitrogenHelper::backgroundColor(const QColor &color, int height, int y)
|
|
{
|
|
double h = height * 0.5;
|
|
if (y > height>>1) {
|
|
|
|
double a = double(y) / h;
|
|
return KColorUtils::mix(backgroundTopColor(color), color, a);
|
|
|
|
} else {
|
|
|
|
double a = (double(y) - h) / h;
|
|
return KColorUtils::mix(color, backgroundBottomColor(color), a);
|
|
|
|
}
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QPixmap NitrogenHelper::verticalGradient(const QColor &color, int height)
|
|
{
|
|
quint64 key = (quint64(color.rgba()) << 32) | height | 0x8000;
|
|
QPixmap *pixmap = m_backgroundCache.object(key);
|
|
|
|
if (!pixmap)
|
|
{
|
|
pixmap = new QPixmap(32, height);
|
|
|
|
QLinearGradient gradient(0, 0, 0, height);
|
|
gradient.setColorAt(0.0, backgroundTopColor(color));
|
|
gradient.setColorAt(0.5, color);
|
|
gradient.setColorAt(1.0, backgroundBottomColor(color));
|
|
|
|
QPainter p(pixmap);
|
|
p.setCompositionMode(QPainter::CompositionMode_Source);
|
|
p.fillRect(pixmap->rect(), gradient);
|
|
|
|
m_backgroundCache.insert(key, pixmap);
|
|
}
|
|
|
|
return *pixmap;
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QPixmap NitrogenHelper::radialGradient(const QColor &color, int width, int y_offset )
|
|
{
|
|
quint64 key = (quint64(color.rgba()) << 32) | width | 0xb000;
|
|
QPixmap *pixmap = m_backgroundCache.object(key);
|
|
|
|
if (!pixmap)
|
|
{
|
|
pixmap = new QPixmap(width, 64+y_offset);
|
|
pixmap->fill(Qt::transparent);
|
|
QColor radialColor = backgroundRadialColor(color);
|
|
|
|
// create gradient
|
|
QRadialGradient gradient(64, 0, 64);
|
|
radialColor.setAlpha(255); gradient.setColorAt(0, radialColor);
|
|
radialColor.setAlpha(101); gradient.setColorAt(0.5, radialColor);
|
|
radialColor.setAlpha(37); gradient.setColorAt(0.75, radialColor);
|
|
radialColor.setAlpha(0); gradient.setColorAt(1, radialColor);
|
|
|
|
// need some tr
|
|
QPainter p(pixmap);
|
|
p.translate( 0, y_offset );
|
|
p.scale(width/128.0,1);
|
|
p.fillRect(QRect(0,0,128,64+y_offset).translated(0, -y_offset ), gradient);
|
|
|
|
m_backgroundCache.insert(key, pixmap);
|
|
}
|
|
|
|
return *pixmap;
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
void NitrogenHelper::drawShadow(QPainter &p, const QColor &color, int size) const
|
|
{
|
|
double m = double(size-2)*0.5;
|
|
|
|
const double offset = 0.8;
|
|
double k0 = (m-4.0) / m;
|
|
QRadialGradient shadowGradient(m+1.0, m+offset+1.0, m);
|
|
for (int i = 0; i < 8; i++) { // sinusoidal gradient
|
|
double k1 = (k0 * double(8 - i) + double(i)) * 0.125;
|
|
double a = (cos(3.14159 * i * 0.125) + 1.0) * 0.25;
|
|
shadowGradient.setColorAt(k1, alphaColor(color, a * _shadowGain));
|
|
}
|
|
shadowGradient.setColorAt(1.0, alphaColor(color, 0.0));
|
|
p.setBrush(shadowGradient);
|
|
p.drawEllipse(QRectF(0, 0, size, size));
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QLinearGradient NitrogenHelper::decoGradient(const QRect &r, const QColor &color)
|
|
{
|
|
|
|
QColor light = KColorScheme::shade(color, KColorScheme::LightShade, _contrast * 0.7);
|
|
QColor dark = KColorScheme::shade(color, KColorScheme::DarkShade, _contrast * 0.7);
|
|
|
|
double y = KColorUtils::luma(color);
|
|
double yd = KColorUtils::luma(dark);
|
|
double yl = KColorUtils::luma(light);
|
|
|
|
QLinearGradient gradient(r.topLeft(), r.bottomLeft());
|
|
if (yd > y)
|
|
{
|
|
gradient.setColorAt(0.2, color);
|
|
gradient.setColorAt(0.8, dark);
|
|
}
|
|
else if (yl < y)
|
|
{
|
|
gradient.setColorAt(0.2, light);
|
|
gradient.setColorAt(0.8, color);
|
|
}
|
|
else
|
|
{
|
|
gradient.setColorAt(0.2, dark);
|
|
gradient.setColorAt(0.5, color);
|
|
gradient.setColorAt(0.8, light);
|
|
}
|
|
|
|
return gradient;
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QPixmap NitrogenHelper::windecoButton(const QColor &color, bool pressed, Nitrogen::NitrogenConfiguration::ButtonType type, int size)
|
|
{
|
|
|
|
quint64 key = (quint64(color.rgba()) << 32) | (size << 1) | pressed;
|
|
QPixmap *pixmap = m_windecoButtonCache.object(key);
|
|
|
|
if (!pixmap)
|
|
{
|
|
pixmap = new QPixmap(size, size);
|
|
pixmap->fill(Qt::transparent);
|
|
|
|
QPainter p(pixmap);
|
|
p.setRenderHints(QPainter::Antialiasing);
|
|
p.setPen(Qt::NoPen);
|
|
|
|
double u = double(size)/22.0;
|
|
if( type == Nitrogen::NitrogenConfiguration::ButtonKde42 )
|
|
{
|
|
QColor light = calcLightColor(color);
|
|
QColor dark = alphaColor(calcShadowColor(color), 0.6);
|
|
|
|
QRectF rect(0.0, 0.0, size, size);
|
|
QRectF buttonRect = rect.adjusted(3*u,3*u,-3*u,-3*u);
|
|
|
|
p.setBrush(color);
|
|
p.drawEllipse(buttonRect);
|
|
p.setBrush(Qt::NoBrush);
|
|
|
|
QLinearGradient darkgr(QPointF(1.0*u, 0.0), QPointF(20.0*u, 0.0));
|
|
darkgr.setColorAt(0.0, Qt::transparent);
|
|
darkgr.setColorAt(0.5, dark);
|
|
darkgr.setColorAt(1.0, Qt::transparent);
|
|
|
|
QLinearGradient lightgr(QPointF(1.0*u, 0.0), QPointF(20.0*u, 0.0));
|
|
lightgr.setColorAt(0.0, Qt::transparent);
|
|
lightgr.setColorAt(0.5, light);
|
|
lightgr.setColorAt(1.0, Qt::transparent);
|
|
|
|
p.setPen(QPen(darkgr, 1.5*u));
|
|
p.drawEllipse(buttonRect);
|
|
p.setPen(QPen(lightgr, 1.5*u));
|
|
if (!pressed) p.drawEllipse(buttonRect.adjusted(0.0, 1.0, 0.0, 1.0));
|
|
else p.drawEllipse(buttonRect.adjusted(1.0, 1.5, -1.0, 1.0));
|
|
|
|
} else {
|
|
|
|
QColor light = calcLightColor(color);
|
|
QColor dark = calcDarkColor(color);
|
|
QColor shadow = calcShadowColor(color);
|
|
|
|
QRectF rect(0.0, 0.0, size, size);
|
|
QRectF buttonRect = rect.adjusted(2*u,2*u,-2*u,-2*u);
|
|
|
|
QLinearGradient fill(QPointF(0.0, 0.0*u), QPointF(0.0, 21.0*u));
|
|
fill.setColorAt(0.0, alphaColor(light, 0.7));
|
|
fill.setColorAt(1.0, alphaColor(dark, 0.7));
|
|
|
|
p.setBrush(fill);
|
|
p.drawEllipse(buttonRect);
|
|
p.setBrush(Qt::NoBrush);
|
|
|
|
// shadow
|
|
if (pressed)
|
|
{
|
|
p.setPen(alphaColor(dark, 0.4));
|
|
p.drawEllipse(buttonRect.adjusted(0.9, 0.6, -0.7, -0.7).adjusted(1.7,1.7,-1.7,-1.7));
|
|
p.setPen(alphaColor(dark, 0.8));
|
|
p.drawEllipse(buttonRect.adjusted(0.9, 0.6, -0.7, -0.7).adjusted(1.2,1.2,-1.2,-1.2));
|
|
}
|
|
p.setPen(QPen(KColorUtils::mix(dark, shadow, 0.12), 2.0));
|
|
p.drawEllipse(buttonRect.adjusted(0.9, 0.6, -0.7, -0.7).adjusted(0,0.1,0,-0.1));
|
|
p.setPen(QPen(KColorUtils::mix(dark, shadow, 0.6), 1.2));
|
|
p.drawEllipse(buttonRect.adjusted(1.0, 1.4, -0.8, -0.8));
|
|
|
|
// reflection
|
|
QLinearGradient lightgr(QPointF(0.0, 0.0*u), QPointF(0.0, 21.0*u));
|
|
lightgr.setColorAt(0.0, Qt::transparent);
|
|
lightgr.setColorAt(1.0, light);
|
|
p.setPen(QPen(lightgr, 1.7));
|
|
p.drawEllipse(buttonRect.adjusted(0.0, -0.5, -0.1, 0.0));
|
|
|
|
}
|
|
|
|
m_windecoButtonCache.insert(key, pixmap);
|
|
|
|
}
|
|
|
|
return *pixmap;
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
QPixmap NitrogenHelper::windecoButtonGlow(const QColor &color, int size)
|
|
{
|
|
quint64 key = (quint64(color.rgba()) << 32) | size;
|
|
QPixmap *pixmap = m_windecoButtonGlowCache.object(key);
|
|
|
|
if (!pixmap)
|
|
{
|
|
pixmap = new QPixmap(size, size);
|
|
pixmap->fill(Qt::transparent);
|
|
|
|
QPainter p(pixmap);
|
|
p.setRenderHints(QPainter::Antialiasing);
|
|
p.setPen(Qt::NoPen);
|
|
|
|
double u = size/21.0;
|
|
QRectF rect(0.0, 0.0, size, size);
|
|
QRectF buttonRect = rect.adjusted(2*u,2*u,-2*u,-2*u);
|
|
|
|
//mask
|
|
p.setBrush(QColor(0,0,0,125));
|
|
p.drawEllipse(rect.adjusted(u, 0, -u, -2*u));
|
|
|
|
//glow
|
|
QColor dark = calcDarkColor(color);
|
|
QColor light = calcLightColor(color);
|
|
|
|
QRadialGradient glow(QPointF(size/2.0, size/2.0 + 0.25), size/2.0);
|
|
glow.setColorAt(12.0 / 21.0, Qt::transparent);
|
|
glow.setColorAt(16.0 / 21.0, dark);
|
|
glow.setColorAt(18.0 / 21.0, alphaColor(light, 0.25));
|
|
glow.setColorAt(20.0 / 21.0, Qt::transparent);
|
|
|
|
p.setCompositionMode(QPainter::CompositionMode_SourceIn);
|
|
p.setBrush(glow);
|
|
p.drawEllipse(rect);
|
|
|
|
m_windecoButtonGlowCache.insert(key, pixmap);
|
|
}
|
|
|
|
return *pixmap;
|
|
|
|
}
|
|
//_______________________________________________________________________________________________________________
|
|
QPixmap NitrogenHelper::glow(const QColor &color, int size, int rsize)
|
|
{
|
|
QPixmap pixmap(rsize, rsize);
|
|
pixmap.fill(QColor(0,0,0,0));
|
|
|
|
QPainter p(&pixmap);
|
|
p.setRenderHints(QPainter::Antialiasing);
|
|
p.setPen(Qt::NoPen);
|
|
p.setWindow(0,0,size,size);
|
|
|
|
QRectF r(0, 0, size, size);
|
|
double m = double(size)*0.5;
|
|
|
|
const double width = 3.0;
|
|
const double bias = _glowBias * double(size) / double(rsize);
|
|
double k0 = (m-width+bias) / m;
|
|
QRadialGradient glowGradient(m, m, m);
|
|
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
|
|
// inverse parabolic gradient
|
|
double k1 = (k0 * double(8 - i) + double(i)) * 0.125;
|
|
double a = 1.0 - sqrt(i * 0.125);
|
|
glowGradient.setColorAt(k1, alphaColor(color, a));
|
|
|
|
}
|
|
|
|
glowGradient.setColorAt(1.0, alphaColor(color, 0.0));
|
|
|
|
// glow
|
|
p.setBrush(glowGradient);
|
|
p.drawEllipse(r);
|
|
|
|
// mask
|
|
p.setCompositionMode(QPainter::CompositionMode_DestinationOut);
|
|
p.setBrush(QBrush(Qt::black));
|
|
p.drawEllipse(r.adjusted(width, width, -width, -width));
|
|
|
|
p.end();
|
|
|
|
return pixmap;
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
void NitrogenHelper::drawFloatFrame(
|
|
QPainter *p,
|
|
const QRect r,
|
|
const QColor &color,
|
|
bool drawUglyShadow,
|
|
bool isActive,
|
|
const QColor &frameColor,
|
|
int frameBorder ) const
|
|
{
|
|
|
|
p->setRenderHint(QPainter::Antialiasing);
|
|
QRect frame = r;
|
|
frame.adjust(1,1,-1,-1);
|
|
int x,y,w,h;
|
|
frame.getRect(&x, &y, &w, &h);
|
|
|
|
QColor light = calcLightColor(backgroundTopColor(color));
|
|
QColor dark = calcLightColor(backgroundBottomColor(color));
|
|
QColor glow = KColorUtils::mix(QColor(128,128,128),frameColor,0.7);
|
|
|
|
p->setBrush(Qt::NoBrush);
|
|
|
|
if (drawUglyShadow && frameBorder >= 1 )
|
|
{
|
|
|
|
if(isActive)
|
|
{
|
|
|
|
//window active - it's a glow - not a shadow
|
|
p->setPen(glow);
|
|
|
|
// top
|
|
p->drawLine(QPointF(x+4, y-0.5), QPointF(x+w-4, y-0.5));
|
|
p->drawArc(QRectF(x-0.5, y-0.5, 11, 11),90*16, 90*16);
|
|
p->drawArc(QRectF(x+w-11+0.5, y-0.5, 11, 11), 0, 90*16);
|
|
|
|
if( frameBorder >= 3 )
|
|
{
|
|
p->drawLine(QPointF(x-0.5, y+4), QPointF(x-0.5, y+h-4));
|
|
p->drawLine(QPointF(x+w+0.5, y+4), QPointF(x+w+0.5, y+h-4));
|
|
p->drawArc(QRectF(0.5, y+h-11+0.5, 11, 11),180*16, 90*16);
|
|
p->drawArc(QRectF(x+w-11+0.5, y+h-11+0.5, 11, 11),270*16, 90*16);
|
|
|
|
// bottom
|
|
p->drawLine(QPointF(x+4, y+h+0.5), QPointF(x+w-4, y+h+0.5));
|
|
|
|
} else {
|
|
|
|
p->drawLine(QPointF(x-0.5, y+4), QPointF(x-0.5, y+h+0.5));
|
|
p->drawLine(QPointF(x+w+0.5, y+4), QPointF(x+w+0.5, y+h+0.5));
|
|
p->drawLine(QPointF(x-0.5, y+h+0.5), QPointF(x+w+0.5, y+h+0.5));
|
|
|
|
}
|
|
|
|
light = KColorUtils::mix(light, frameColor);
|
|
dark = KColorUtils::mix(dark, frameColor);
|
|
|
|
} else {
|
|
|
|
//window inactive - draw something resembling shadow
|
|
QColor shadow = KColorUtils::darken(color, 0.0, 0.0); // fully desaturate
|
|
p->setPen(KColorUtils::darken(shadow, 0.2));
|
|
|
|
p->drawLine(QPointF(x+4, y-0.5), QPointF(x+w-4, y-0.5));
|
|
p->drawArc(QRectF(x-0.5, y-0.5, 11, 11),90*16, 90*16);
|
|
p->drawArc(QRectF(x+w-11+0.5, y-0.5, 11, 11), 0, 90*16);
|
|
|
|
if( frameBorder >= 3 )
|
|
{
|
|
|
|
p->setPen(KColorUtils::darken(shadow, 0.35));
|
|
p->drawLine(QPointF(x-0.5, y+4), QPointF(x-0.5, y+h-4));
|
|
p->drawLine(QPointF(x+w+0.5, y+4), QPointF(x+w+0.5, y+h-4));
|
|
p->setPen(KColorUtils::darken(shadow, 0.45));
|
|
p->drawArc(QRectF(0.5, y+h-11+0.5, 11, 11),180*16, 90*16);
|
|
p->drawArc(QRectF(x+w-11+0.5, y+h-11+0.5, 11, 11),270*16, 90*16);
|
|
p->setPen(KColorUtils::darken(shadow, 0.6));
|
|
p->drawLine(QPointF(x+4, y+h+0.5), QPointF(x+w-4, y+h+0.5));
|
|
|
|
} else {
|
|
|
|
p->setPen(KColorUtils::darken(shadow, 0.35));
|
|
p->drawLine(QPointF(x-0.5, y+4), QPointF(x-0.5, y+h-0.5));
|
|
p->drawLine(QPointF(x+w+0.5, y+4), QPointF(x+w+0.5, y+h-0.5));
|
|
p->setPen(KColorUtils::darken(shadow, 0.6));
|
|
p->drawLine(QPointF(x+0.5, y+h+0.5), QPointF(x+w-0.5, y+h+0.5));
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if( frameBorder >= 5 )
|
|
{
|
|
p->setPen(QPen(light, 0.8));
|
|
p->drawLine(QPointF(x+4, y+0.6), QPointF(x+w-4, y+0.6));
|
|
QLinearGradient lg = QLinearGradient(0.0, 1.5, 0.0, 4.5);
|
|
lg.setColorAt(0, light);
|
|
lg.setColorAt(1, dark);
|
|
p->setPen(QPen(lg, 0.8));
|
|
p->drawArc(QRectF(x+0.6, y+0.6, 9, 9),90*16, 90*16);
|
|
p->drawArc(QRectF(x+w-9-0.6, y+0.6, 9, 9), 0, 90*16);
|
|
p->drawLine(QPointF(x+0.6, y+4), QPointF(x+0.6, y+h-4));
|
|
p->drawLine(QPointF(x+w-0.6, y+4), QPointF(x+w-0.6, y+h-4));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//_______________________________________________________________________________________________________________
|
|
void NitrogenHelper::drawSeparator(QPainter *p, const QRect &rect, const QColor &color, Qt::Orientation orientation) const
|
|
{
|
|
QColor light = calcLightColor(color);
|
|
QColor dark = calcDarkColor(color);
|
|
|
|
bool antialias = p->testRenderHint(QPainter::Antialiasing);
|
|
p->setRenderHint(QPainter::Antialiasing,false);
|
|
|
|
QPoint start,end,offset;
|
|
|
|
if (orientation == Qt::Horizontal) {
|
|
|
|
start = QPoint(rect.x(),rect.y()+rect.height()/2-1);
|
|
end = QPoint(rect.right(),rect.y()+rect.height()/2-1);
|
|
offset = QPoint(0,1);
|
|
|
|
} else {
|
|
|
|
start = QPoint(rect.x()+rect.width()/2-1,rect.y());
|
|
end = QPoint(rect.x()+rect.width()/2-1,rect.bottom());
|
|
offset = QPoint(1,0);
|
|
light.setAlpha(150);
|
|
|
|
}
|
|
|
|
QLinearGradient lg(start,end);
|
|
lg.setColorAt(0.3, dark);
|
|
lg.setColorAt(0.7, dark);
|
|
dark.setAlpha(0);
|
|
lg.setColorAt(0.0, dark);
|
|
lg.setColorAt(1.0, dark);
|
|
p->setPen(QPen(lg,1));
|
|
|
|
if (orientation == Qt::Horizontal) p->drawLine(start,end);
|
|
else p->drawLine(start+offset,end+offset);
|
|
|
|
lg = QLinearGradient(start,end);
|
|
lg.setColorAt(0.3, light);
|
|
lg.setColorAt(0.7, light);
|
|
light.setAlpha(0);
|
|
lg.setColorAt(0.0, light);
|
|
lg.setColorAt(1.0, light);
|
|
p->setPen(QPen(lg,1));
|
|
|
|
|
|
if (orientation == Qt::Horizontal) p->drawLine(start+offset,end+offset);
|
|
else {
|
|
|
|
p->drawLine(start,end);
|
|
p->drawLine(start+offset*2,end+offset*2);
|
|
|
|
}
|
|
|
|
p->setRenderHint(QPainter::Antialiasing, antialias);
|
|
}
|
|
|