diff -r 000000000000 -r 16d8024aca5e src/hbcore/ovgeffects/hbvghsleffect.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbcore/ovgeffects/hbvghsleffect.cpp	Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,299 @@
+/****************************************************************************
+**
+** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (developer.feedback@nokia.com)
+**
+** This file is part of the HbCore module of the UI Extensions for Mobile.
+**
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at developer.feedback@nokia.com.
+**
+****************************************************************************/
+
+#include "hbvghsleffect_p.h"
+#include "hbvghsleffect_p_p.h"
+#include <QPainter>
+#include <qmath.h>
+
+/*!
+ * \class HbVgHslEffect
+ *
+ * \brief OpenVG-based hue-saturation-lightness filter effect.
+ *
+ * \internal
+ */
+
+HbVgHslEffectPrivate::HbVgHslEffectPrivate()
+    : hue(0), saturation(1), lightness(0)
+{
+}
+
+HbVgHslEffect::HbVgHslEffect(QObject *parent)
+    : HbVgEffect(*new HbVgHslEffectPrivate, parent)
+{
+}
+
+HbVgHslEffect::HbVgHslEffect(HbVgHslEffectPrivate &dd, QObject *parent)
+    : HbVgEffect(dd, parent)
+{
+}
+
+HbVgHslEffect::~HbVgHslEffect()
+{
+}
+
+qreal HbVgHslEffect::hue() const
+{
+    Q_D(const HbVgHslEffect);
+    return d->hue;
+}
+
+void HbVgHslEffect::setHue(qreal hue)
+{
+    Q_D(HbVgHslEffect);
+    if (d->hue == hue)
+        return;
+    d->hue = hue;
+    updateEffect();
+    emit hueChanged(hue);
+}
+
+qreal HbVgHslEffect::saturation() const
+{
+    Q_D(const HbVgHslEffect);
+    return d->saturation;
+}
+
+void HbVgHslEffect::setSaturation(qreal saturation)
+{
+    Q_D(HbVgHslEffect);
+    if (d->saturation == saturation)
+        return;
+    d->saturation = saturation;
+    updateEffect();
+    emit saturationChanged(saturation);
+}
+
+qreal HbVgHslEffect::lightness() const
+{
+    Q_D(const HbVgHslEffect);
+    return d->lightness;
+}
+
+void HbVgHslEffect::setLightness(qreal lightness)
+{
+    Q_D(HbVgHslEffect);
+    if (d->lightness == lightness)
+        return;
+    d->lightness = lightness;
+    updateEffect();
+    emit lightnessChanged(lightness);
+}
+
+void HbVgHslEffect::desaturate()
+{
+    setHue(0);
+    setSaturation(0);
+    setLightness(0);
+}
+
+QRectF HbVgHslEffect::boundingRectFor(const QRectF &rect) const
+{
+    return rect;
+}
+
+#ifdef HB_EFFECTS_OPENVG
+
+inline void getSaturationRotationMatrix(VGfloat *effectMatrix, VGfloat opacity,
+                                        VGfloat saturation, VGfloat angle) 
+{
+    const VGfloat sa = saturation;            
+    const VGfloat as = 1.0f - saturation;
+    
+    const VGfloat o = opacity;
+    const VGfloat ao = 1.0f - o;
+    
+    const VGfloat c = qCos(angle);
+    const VGfloat s = qSin(angle);
+    
+    effectMatrix[0] = o * ((-0.02473f*as+0.66667f*sa)*c+ (0.30450f*as*s+(0.33333f*as+0.33333f*sa))) + ao;
+    effectMatrix[1] = o * ((-0.02473f*as-0.33333f*sa)*c+((0.30450f*as+0.57736f*sa)*s+(0.33333f*as+0.33333f*sa)));
+    effectMatrix[2] = o * ((-0.02473f*as-0.33333f*sa)*c+((0.30450f*as-0.57736f*sa)*s+(0.33333f*as+0.33333f*sa)));
+    effectMatrix[3] = 0.0f;
+    effectMatrix[4] = o * ((0.27607f*as-0.33333f*sa)*c+((-0.13083f*as-0.57736f*sa)*s+(0.33333f*as+0.33333f*sa)));
+    effectMatrix[5] = o * ((0.27607f*as+0.66667f*sa)*c+ (-0.13083f*as*s+(0.33333f*as+0.33333f*sa))) + ao;
+    effectMatrix[6] = o * ((0.27607f*as-0.33333f*sa)*c+((-0.13083f*as+0.57736f*sa)*s+(0.33333f*as+0.33333f*sa)));
+    effectMatrix[7] = 0.0f;
+    effectMatrix[8] = o * ((-0.25134f*as-0.33333f*sa)*c+((-0.17367f*as+0.57736f*sa)*s+(0.33333f*as+0.33333f*sa)));
+    effectMatrix[9] = o * ((-0.25134f*as-0.33333f*sa)*c+((-0.17367f*as-0.57736f*sa)*s+(0.33333f*as+0.33333f*sa)));
+    effectMatrix[10] = o * ((-0.25134f*as+0.66667f*sa)*c+ (-0.17367f*as*s+(0.33333f*as+0.33333f*sa))) + ao;
+    effectMatrix[11] = 0.0f;
+    effectMatrix[12] = 0.0f;
+    effectMatrix[13] = 0.0f;
+    effectMatrix[14] = 0.0f;
+    effectMatrix[15] = 1.0f;
+}
+
+const VGfloat Rw = 0.3086f;
+const VGfloat Gw = 0.6094f;
+const VGfloat Bw = 0.0820f;
+
+inline void getSaturationMatrix(VGfloat *effectMatrix, VGfloat opacity, VGfloat saturation)
+{
+    const VGfloat sa = saturation;            
+    const VGfloat as = 1.0f - saturation;
+    
+    const VGfloat o = opacity;
+    const VGfloat ao = 1.0f - o;
+
+    const VGfloat asRw = o * as * Rw;
+    const VGfloat asGw = o * as * Gw;
+    const VGfloat asBw = o * as * Bw;
+    
+    effectMatrix[0] = asRw + sa + ao;
+    effectMatrix[1] = asRw;
+    effectMatrix[2] = asRw;
+    effectMatrix[3] = 0.0f;
+    effectMatrix[4] = asGw;
+    effectMatrix[5] = asGw + sa + ao;
+    effectMatrix[6] = asGw;
+    effectMatrix[7] = 0.0f;
+    effectMatrix[8] = asBw;
+    effectMatrix[9] = asBw;
+    effectMatrix[10] = asBw + sa + ao;
+    effectMatrix[11] = 0.0f;
+    effectMatrix[12] = 0.0f;
+    effectMatrix[13] = 0.0f;
+    effectMatrix[14] = 0.0f;
+    effectMatrix[15] = 1.0f;
+}
+
+inline void getRotationMatrix(VGfloat *effectMatrix, VGfloat opacity, VGfloat angle)
+{
+    const VGfloat o = opacity;
+    const VGfloat ao = 1.0f - o;
+    
+    const VGfloat c = qCos(angle);
+    const VGfloat s = qSin(angle);
+    
+    effectMatrix[0] = o * ( 0.66667f*c+0.33333f) + ao;
+    effectMatrix[1] = o * (-0.33333f*c+(0.57736f*s+0.33333f));
+    effectMatrix[2] = o * (-0.33333f*c+(-0.57736f*s+0.33333f));
+    effectMatrix[3] =  0.0f;
+    effectMatrix[4] = o * (-0.33333f*c+(-0.57736f*s+0.33333f));
+    effectMatrix[5] = o * ( 0.66667f*c+0.33333f) + ao;
+    effectMatrix[6] = o * (-0.33333f*c+(0.57736f*s+0.33333f));
+    effectMatrix[7] =  0.0f;
+    effectMatrix[8] = o * (-0.33333f*c+(0.57736f*s+0.33333f));
+    effectMatrix[9] = o * (-0.33333f*c+(-0.57736f*s+0.33333f));
+    effectMatrix[10] = o * (0.66667f*c+0.33333f) + ao;
+    effectMatrix[11] = 0.0f;
+    effectMatrix[12] = 0.0f;
+    effectMatrix[13] = 0.0f;
+    effectMatrix[14] = 0.0f;
+    effectMatrix[15] = 1.0f;
+}
+
+inline void getIdentityMatrix(VGfloat *effectMatrix)
+{
+    effectMatrix[0] = 1.0f;
+    effectMatrix[1] = 0.0f;
+    effectMatrix[2] = 0.0f;
+    effectMatrix[3] = 0.0f;
+    effectMatrix[4] = 0.0f;
+    effectMatrix[5] = 1.0f;
+    effectMatrix[6] = 0.0f;
+    effectMatrix[7] = 0.0f;
+    effectMatrix[8] = 0.0f;
+    effectMatrix[9] = 0.0f;
+    effectMatrix[10] = 1.0f;
+    effectMatrix[11] = 0.0f;
+    effectMatrix[12] = 0.0f;
+    effectMatrix[13] = 0.0f;
+    effectMatrix[14] = 0.0f;
+    effectMatrix[15] = 1.0f;
+}
+
+#endif // HB_EFFECTS_OPENVG
+
+void HbVgHslEffect::performEffect(QPainter *painter,
+                                   const QPointF &offset,
+                                   const QVariant &vgImage,
+                                   const QSize &vgImageSize)
+{
+#ifdef HB_EFFECTS_OPENVG
+    QPixmap cachedPm = cached(vgImageSize);
+    if (!cachedPm.isNull()) {
+        painter->drawPixmap(offset, cachedPm);
+        return;
+    }
+
+    Q_D(HbVgHslEffect);
+    VGImage srcImage = vgImage.value<VGImage>();
+    VGImage dstImage = d->ensurePixmap(&d->dstPixmap, vgImageSize);
+    qreal opacity = clamp(d->opacity, 0.0f, 1.0f);
+    if (opacity > HBVG_EPSILON) {
+        if (d->paramsChanged) {
+            // a helpful constant
+            const qreal radsPerDeg = 2.0f * (qreal) M_PI / 360.0f;
+
+            // make sure parametres are in range
+            const VGfloat o = (VGfloat) opacity;
+            const VGfloat angle = (VGfloat) clamp(d->hue * radsPerDeg, 0.0f, 2.0f * (qreal) M_PI); // angle [0, 2*pi]
+            const VGfloat saturation = (VGfloat) clamp(d->saturation, 0.0f, 100.0f); // saturation [0, N]
+            const VGfloat lightness = (VGfloat) clamp(d->lightness, -1.0f, 1.0f); // lightness [-1, 1]
+    
+            // check parametres which precalculated matrix we have to use.
+            // Note: lightness affects offset and not matrix so we don't bother optimising that.
+            const bool enableSaturation  = (saturation < 1.0f - HBVG_EPSILON || saturation > 1.0f + HBVG_EPSILON);
+            const bool enableHueRotation = (HBVG_EPSILON < angle && angle < (2.0f * (qreal) M_PI - HBVG_EPSILON));
+
+            if (enableSaturation && enableHueRotation) {
+                // contains SaturateT*PrerotationT*HuerotationT*PostrotationT*I*opacity+I*(1-opacity) matrices
+                // --- ugly, but saves lot of operations in FPU.
+                // note: there are plenty of redundancy in these calculations
+                // --- let compiler optimise them.
+                getSaturationRotationMatrix(&d->colorMatrix[0], o, saturation, angle);
+            } else if (enableSaturation && !enableHueRotation) {
+                // saturationT*I*opacity+I*(1 - opacity) matrix without hue rotation
+                getSaturationMatrix(&d->colorMatrix[0], o, saturation);
+            } else if(!enableSaturation && enableHueRotation) {
+                // PrerotationT*HuerotationT*PostrotationT*I*opacity+I*(1-opacity) matrices without saturation matrix
+                getRotationMatrix(&d->colorMatrix[0], o, angle);
+            } else {
+                // identity matrix
+                getIdentityMatrix(&d->colorMatrix[0]);
+            }
+
+            // colour component offsets
+            d->colorMatrix[16] = lightness * o;
+            d->colorMatrix[17] = lightness * o;
+            d->colorMatrix[18] = lightness * o;
+            d->colorMatrix[19] = 0.0f;
+        }
+        vgColorMatrix(dstImage, srcImage, d->colorMatrix);
+        painter->drawPixmap(offset, d->dstPixmap);
+        tryCache(d->dstPixmap);
+    } else {
+        painter->drawPixmap(offset, d->srcPixmap);
+    }
+#else
+    Q_UNUSED(painter);
+    Q_UNUSED(offset);
+    Q_UNUSED(vgImage);
+    Q_UNUSED(vgImageSize);
+#endif
+}