#include <math.h>

// wait 200 ms before drawing shadow after move/resize

static const int SHADOW_DELAY = 200;

/* TODO: Remove this once X has real translucency.

 *

 * A list of the regions covered by all shadows and the Clients to which they

 * belong. Used to redraw shadows when a window overlapping or underlying a

 * shadow is moved, resized, or hidden.

 */

struct ShadowRegion {

    QRegion region;

    Client *client;

};

static QValueList<ShadowRegion> shadowRegions;

    QWidget *shadowWidget;

    QMemArray<double> activeOpacityCache;

    QMemArray<double> inactiveOpacityCache;

    QMemArray<double> *opacityCache;

    QRegion shapeBoundingRegion;

    QTimer *shadowDelayTimer;

    d->shadowDelayTimer = new QTimer(this);

    d->opacityCache = &d->activeOpacityCache;

    d->shadowWidget = NULL;

    connect(d->shadowDelayTimer, SIGNAL(timeout()), this, SLOT(slotDrawShadow()));

    connect(wspace, SIGNAL(reconfigured()), SLOT(slotUpdateOpacityCache()));

    slotRemoveShadow();

    slotRemoveShadow();

    if (options->shadowEnabled(active)) {

        drawIntersectingShadows();

        slotDrawDelayedShadow();

    }

    drawIntersectingShadows();

void Client::moveEvent(QMoveEvent *e)

{

    QWidget::moveEvent(e);

    slotUpdateOpacityCache();

    if (options->shadowEnabled(active))

        slotDrawDelayedShadow();

    d->shadowDelayTimer->stop();

    slotRemoveShadow();

    drawIntersectingShadows();

    slotRemoveShadow();

    if (options->shadowEnabled(active))

        slotDrawDelayedShadow();

    }

    else {

        slotRemoveShadow();

        if (options->shadowEnabled(false))

            slotDrawDelayedShadow();

    }

void Client::slotUpdateOpacityCache()

{

    if (!options->shadowEnabled(isActive()))

        return;

    if (!d->activeOpacityCache.isNull())

        d->activeOpacityCache.resize(0);

    if (!d->inactiveOpacityCache.isNull())

        d->inactiveOpacityCache.resize(0);

    if (!moveResizeMode) {

        // If the user is manually resizing, let Client::stopMoveResize()

        // decide when to redraw the shadow

        slotRemoveShadow();

        drawIntersectingShadows();

        if (options->shadowEnabled(isActive()))

            slotDrawDelayedShadow();

    }

}

/*!

   Redraw shadows that were previously occluding or occluded by this window,

   to avoid visual glitches.

 */

void Client::drawIntersectingShadows() {

    QRegion region;

    QValueList<ShadowRegion>::Iterator it;

    QPtrList<Client> reshadowClients;

    if (!options->shadowEnabled(false))

        // No point in redrawing overlapping/overpalled shadows if only the

        // active window has a shadow.

        return;

    region = d->shapeBoundingRegion;

    // Generate list of Clients whose shadows that need to be redrawn. That is,

    // those that are currently overlapping or overlapped by other windows or

    // shadows.

    for (it = shadowRegions.begin(); it != shadowRegions.end(); ++it)

        if ((*it).client->isOnDesktop(desktop()) &&

                !(*it).region.intersect(region).isEmpty())

            reshadowClients.append((*it).client);

    // Redraw shadows for each of the Clients in the list generated above

    QPtrListIterator<Client> it2(reshadowClients);

    while (it2.current() != 0) {

        it2.current()->slotRemoveShadow();

        it2.current()->slotDrawDelayedShadow();

        ++it2;

    }

}

/*!

   Draw shadow after some time has elapsed, to give recently exposed windows a

   chance to repaint before a shadow gradient is drawn over them.

 */

void Client::slotDrawDelayedShadow() {

    d->shadowDelayTimer->start(SHADOW_DELAY, true);

}

/*!

   Draw a shadow under this window and XShape the shadow accordingly.

 */

void Client::slotDrawShadow()

{

    XRectangle *shapes;

    int i, count, ordering;

    /* Store this window's ShapeBoundingRegion even if shadows aren't drawn for

     * this type of window. Otherwise, drawIntersectingShadows() won't update

     * properly when this window is moved/resized/hidden/closed.

     */

    shapes = XShapeGetRectangles(qt_xdisplay(), winId(), ShapeBounding,

            &count, &ordering);

    if (!shapes)

        // XShape extension not supported

        d->shapeBoundingRegion = QRegion(x(), y(), width(), height());

    else {

        d->shapeBoundingRegion = QRegion();

        for (i = 0; i < count; i++) {

            // Translate XShaped window into a QRegion

            QRegion shapeRectangle(shapes[i].x, shapes[i].y, shapes[i].width,

                    shapes[i].height);

            d->shapeBoundingRegion += shapeRectangle;

        }

        d->shapeBoundingRegion.translate(x(), y());

    }

    if (isHidden() || isMaximized() ||

            !options->shadowWindowType(windowType())) {

        XFree(shapes);

        return;

    }

    slotRemoveShadow();

    QMemArray<QRgb> pixelData;

    QPixmap shadowPixmap;

    QRect shadow;

    QRegion exposedRegion;

    ShadowRegion shadowRegion;

    int thickness, xOffset, yOffset;

    thickness = options->shadowThickness(isActive());

    xOffset = options->shadowXOffset(isActive());

    yOffset = options->shadowYOffset(isActive());

    d->opacityCache = active? &d->activeOpacityCache : &d->inactiveOpacityCache;

    shadow.setRect(x() - thickness + xOffset, y() - thickness + yOffset,

            width() + thickness * 2, height() + thickness * 2);

    shadowPixmap.resize(shadow.size());

    // Create a fake drop-down shadow effect via blended Xwindows

    d->shadowWidget = new QWidget(0, 0, WStyle_Customize | WX11BypassWM);

    d->shadowWidget->setGeometry(shadow);

    XSelectInput(qt_xdisplay(), d->shadowWidget->winId(),

            ButtonPressMask | ButtonReleaseMask | StructureNotifyMask);

    d->shadowWidget->installEventFilter(this);

    shapes = XShapeGetRectangles(qt_xdisplay(), winId(), ShapeBounding,

            &count, &ordering);

    if (!shapes) {

        // XShape extension not supported

        exposedRegion = getExposedRegion(d->shapeBoundingRegion, shadow.x(),

                shadow.y(), shadow.width(), shadow.height(), thickness,

                xOffset, yOffset);

        shadowRegion.region = exposedRegion;

        shadowRegion.client = this;

        shadowRegions.append(shadowRegion);

        if (d->opacityCache->isNull())

            imposeRegionShadow(shadowPixmap, d->shapeBoundingRegion,

                    exposedRegion, thickness,

                    options->shadowOpacity(isActive()));

        else

            imposeCachedShadow(shadowPixmap, exposedRegion);

    }

    else {

        QMemArray<QRect> exposedRects;

        QMemArray<QRect>::Iterator it, itEnd;

        XRectangle *shadowShapes;

        exposedRegion = getExposedRegion(d->shapeBoundingRegion, shadow.x(),

                shadow.y(), shadow.width(), shadow.height(), thickness,

                xOffset, yOffset);

        shadowRegion.region = exposedRegion;

        shadowRegion.client = this;

        shadowRegions.append(shadowRegion);

        // XShape the shadow

        exposedRects = exposedRegion.rects();

        i = 0;

        itEnd = exposedRects.end();

        shadowShapes = new XRectangle[exposedRects.count()];

        for (it = exposedRects.begin(); it != itEnd; ++it) {

            shadowShapes[i].x = (*it).x();

            shadowShapes[i].y = (*it).y();

            shadowShapes[i].width = (*it).width();

            shadowShapes[i].height = (*it).height();

            i++;

        }

        XShapeCombineRectangles(qt_xdisplay(), d->shadowWidget->winId(),

                ShapeBounding, -x() + thickness - xOffset,

                -y() + thickness - yOffset, shadowShapes, i, ShapeSet,

                Unsorted);

        delete [] shadowShapes;

        if (d->opacityCache->isNull())

            imposeRegionShadow(shadowPixmap, d->shapeBoundingRegion,

                    exposedRegion, thickness,

                    options->shadowOpacity(isActive()));

        else

            imposeCachedShadow(shadowPixmap, exposedRegion);

    }

    XFree(shapes);

    // Set the background pixmap

    //shadowPixmap.convertFromImage(shadowImage);

    d->shadowWidget->setErasePixmap(shadowPixmap);

    // Restack shadows under this window so that shadows drawn for a newly

    // focused (but not raised) window don't overlap any windows above it.

    restackShadows();

    // Don't use QWidget::show() so we don't confuse QEffects, thus causing

    // broken focus.

    XMapWindow(qt_xdisplay(), d->shadowWidget->winId());

}

/*!

   Remove shadow under this window.

 */

void Client::slotRemoveShadow()

{

    QValueList<ShadowRegion>::Iterator it;

    d->shadowDelayTimer->stop();

    if (d->shadowWidget != NULL) {

        for (it = shadowRegions.begin(); it != shadowRegions.end(); ++it)

            if ((*it).client == this) {

                shadowRegions.remove(it);

                break;

        }

        delete d->shadowWidget;

        d->shadowWidget = NULL;

    }

}

/*!

   Calculate regions in which the shadow will be visible given the window's

   origin, height and width and the shadow's thickness, and X- and Y-offsets.

 */

QRegion Client::getExposedRegion(QRegion occludedRegion, int x, int y, int w,

        int h, int thickness, int xOffset, int yOffset)

{

    QRegion exposedRegion;

    exposedRegion = QRegion(x, y, w, h);

    exposedRegion -= occludedRegion;

    if (thickness > 0) {

        // Limit exposedRegion to include only where a shadow of the specified

        // thickness will be drawn

        QMemArray<QRect> occludedRects;

        QMemArray<QRect>::Iterator it, itEnd;

        QRegion shadowRegion;

        occludedRects = occludedRegion.rects();

        itEnd = occludedRects.end();

        for (it = occludedRects.begin(); it != itEnd; ++it) {

            // Expand each of the occluded region's shape rectangles to contain

            // where a shadow of the specified thickness will be drawn. Create

            // a new QRegion that contains the expanded occluded region

            it->setTop(it->top() - thickness + yOffset);

            it->setLeft(it->left() - thickness + xOffset);

            it->setRight(it->right() + thickness + xOffset);

            it->setBottom(it->bottom() + thickness + yOffset);

            shadowRegion += QRegion(*it);

        }

        exposedRegion -= exposedRegion - shadowRegion;

    }

    return exposedRegion;

}

/*!

   Draw shadow gradient around this window using cached opacity values.

 */

void Client::imposeCachedShadow(QPixmap &pixmap, QRegion exposed)

{

    QPainter painter;

    QRgb pixel;

    double opacity;

    int red, green, blue, pixelRed, pixelGreen, pixelBlue;

    int subW, subH, w, h, x, y, zeroX, zeroY;

    QImage image;

    QMemArray<QRect>::Iterator it, itEnd;

    QMemArray<QRect> rectangles;

    QPixmap subPixmap;

    Window rootWindow;

    int thickness, windowX, windowY, xOffset, yOffset;

    rectangles = exposed.rects();

    rootWindow = qt_xrootwin();

    thickness = options->shadowThickness(isActive());

    windowX = this->x();

    windowY = this->y();

    xOffset = options->shadowXOffset(isActive());

    yOffset = options->shadowYOffset(isActive());

    options->shadowColour(isActive()).rgb(&red, &green, &blue);

    w = pixmap.width();

    h = pixmap.height();

    painter.begin(&pixmap);

    itEnd = rectangles.end();

    for (it = rectangles.begin(); it != itEnd; ++it) {

        subW = (*it).width();

        subH = (*it).height();

        subPixmap = QPixmap::grabWindow(rootWindow, (*it).x(), (*it).y(),

                subW, subH);

        zeroX = (*it).x() - windowX + thickness - xOffset;

        zeroY = (*it).y() - windowY + thickness - yOffset;

        image = subPixmap.convertToImage();

        for (x = 0; x < subW; x++) {

            for (y = 0; y < subH; y++) {

                opacity = (*(d->opacityCache))[(zeroY + y) * w + zeroX + x];

                pixel = image.pixel(x, y);

                pixelRed = qRed(pixel);

                pixelGreen = qGreen(pixel);

                pixelBlue = qBlue(pixel);

                image.setPixel(x, y,

                        qRgb((int)(pixelRed + (red - pixelRed) * opacity),

                            (int)(pixelGreen + (green - pixelGreen) * opacity),

                            (int)(pixelBlue + (blue - pixelBlue) * opacity)));

            }

        }

        subPixmap.convertFromImage(image);

        painter.drawPixmap(zeroX, zeroY, subPixmap);

    }

    painter.end();

}

/*!

   Draw shadow around this window using calculated opacity values.

 */

void Client::imposeRegionShadow(QPixmap &pixmap, QRegion occluded,

        QRegion exposed, int thickness, double maxOpacity)

{

    register int distance, intersectCount, i, j, x, y;

    QPainter painter;

    QRgb pixel;

    double decay, factor, opacity;

    int red, green, blue, pixelRed, pixelGreen, pixelBlue;

    int halfMaxIntersects, lineIntersects, maxIntersects, maxY;

    int irBottom, irLeft, irRight, irTop, yIncrement;

    int subW, subH, w, h, zeroX, zeroY;

    QImage image;

    QMemArray<QRect>::Iterator it, itEnd;

    QMemArray<QRect> rectangles;

    QPixmap subPixmap;

    Window rootWindow;

    int windowX, windowY, xOffset, yOffset;

    rectangles = exposed.rects();

    rootWindow = qt_xrootwin();

    windowX = this->x();

    windowY = this->y();

    xOffset = options->shadowXOffset(isActive());

    yOffset = options->shadowYOffset(isActive());

    options->shadowColour(isActive()).rgb(&red, &green, &blue);

    maxIntersects = thickness * thickness * 4 + (thickness * 4) + 1;

    halfMaxIntersects = maxIntersects / 2;

    lineIntersects = thickness * 2 + 1;

    factor = maxIntersects / maxOpacity;

    decay = (lineIntersects / 0.01 - factor) / pow((double)maxIntersects, 3.5);

    w = pixmap.width();

    h = pixmap.height();

    xOffset = options->shadowXOffset(isActive());

    yOffset = options->shadowYOffset(isActive());

    d->opacityCache->resize(0);

    d->opacityCache->resize(w * h);

    occluded.translate(-windowX + thickness, -windowY + thickness);

    painter.begin(&pixmap);

    itEnd = rectangles.end();

    for (it = rectangles.begin(); it != itEnd; ++it) {

        subW = (*it).width();

        subH = (*it).height();

        subPixmap = QPixmap::grabWindow(rootWindow, (*it).x(), (*it).y(),

                subW, subH);

        maxY = subH;

        zeroX = (*it).x() - windowX + thickness - xOffset;

        zeroY = (*it).y() - windowY + thickness - yOffset;

        image = subPixmap.convertToImage();

        intersectCount = 0;

        opacity = -1;

        y = 0;

        yIncrement = 1;

        for (x = 0; x < subW; x++) {

            irLeft = zeroX + x - thickness;

            irRight = zeroX + x + thickness;

            while (y != maxY) {

                // horizontal row about to leave the intersect region, not

                // necessarily the top row

                irTop = zeroY + y - thickness * yIncrement;

                // horizontal row that just came into the intersect region,

                // not necessarily the bottom row

                irBottom = zeroY + y + thickness * yIncrement;

                if (opacity == -1) {

                    // If occluded pixels caused an intersect count to be

                    // skipped, recount it

                    intersectCount = 0;

                    for (j = irTop; j != irBottom; j += yIncrement) {

                        // irTop is not necessarily larger than irBottom and

                        // yIncrement isn't necessarily positive

                        for (i = irLeft; i <= irRight; i++) {

                            if (occluded.contains(QPoint(i, j)))

                                intersectCount++;

                        }

                    }

                }

                else {

                    if (intersectCount < 0)

                        intersectCount = 0;

                    for (i = irLeft; i <= irRight; i++) {

                        if (occluded.contains(QPoint(i, irBottom)))

                            intersectCount++;

                    }

                }

                distance = maxIntersects - intersectCount;

                opacity = intersectCount / (factor + pow((double)distance, 3.5) * decay);

                (*(d->opacityCache))[(zeroY + y) * w + zeroX + x] = opacity;

                pixel = image.pixel(x, y);

                pixelRed = qRed(pixel);

                pixelGreen = qGreen(pixel);

                pixelBlue = qBlue(pixel);

                image.setPixel(x, y,

                        qRgb((int)(pixelRed + (red - pixelRed) * opacity),

                            (int)(pixelGreen + (green - pixelGreen) * opacity),

                            (int)(pixelBlue + (blue - pixelBlue) * opacity)));

                for (i = irLeft; i <= irRight; i++) {

                    if (occluded.contains(QPoint(i, irTop)))

                        intersectCount--;

                }

                y += yIncrement;

            }

            y -= yIncrement;

            irTop += yIncrement;

            for (j = irTop; j != irBottom; j += yIncrement) {

                if (occluded.contains(QPoint(irLeft, j)))

                    intersectCount--;

            }

            irRight++;

            for (j = irTop; j != irBottom; j += yIncrement) {

                if (occluded.contains(QPoint(irRight, j)))

                    intersectCount++;

            }

            yIncrement *= -1;

            if (yIncrement < 0)

                // Scan Y-axis bottom-up for next X-coordinate iteration

                maxY = -1;

            else

                // Scan Y-axis top-down for next X-coordinate iteration

                maxY = subH;

        }

        subPixmap.convertFromImage(image);

        painter.drawPixmap(zeroX, zeroY, subPixmap);

    }

    painter.end();

}

/*!

   Returns X window ID of the shadow widget.

 */

Window Client::shadowId() const

{

    return d->shadowWidget != NULL ? d->shadowWidget->winId() : None;

}

/*

 * Restack shadow windows so that they are immediately under the window they

 * belong to.

 */

void Client::restackShadows()

{

    Window shadows[2];

    if (isDock()) {

        shadows[0] = workspace()->stackingOrder().first()->winId();

        shadows[1] = d->shadowWidget->winId();

    }

    else {

        shadows[0] = winId();

        if (d->shadowWidget != NULL)

            shadows[1] = d->shadowWidget->winId();

    }

    XRestackWindows(qt_xdisplay(), shadows, 2);

}

    void restackShadows();

    Window shadowId() const;

    void drawIntersectingShadows();

    void moveEvent( QMoveEvent * );

    QRegion getExposedRegion(QRegion occludedRegion, int x, int y,

            int w, int h, int thickness, int xOffset, int yOffset);

    void imposeRegionShadow(QPixmap &pixmap, QRegion occluded,

            QRegion exposed, int thickness, double maxOpacity = 0.75);

protected slots:

    void slotDrawShadow();

    void slotDrawDelayedShadow();

    void slotRemoveShadow();

    void slotUpdateOpacityCache();

    void imposeCachedShadow(QPixmap &pixmap, QRegion exposed);

#include <netwm.h>

    QColor shadow_colour;

    QColor shadow_inactive_colour;

    bool shadow_docks;

    bool shadow_overrides;

    bool shadow_topMenus;

    bool shadow_inactive_enabled;

    bool shadow_enabled;

    double shadow_inactive_opacity;

    double shadow_opacity;

    int shadow_inactive_thickness;

    int shadow_thickness;

    int shadow_inactive_x_offset;

    int shadow_x_offset;

    int shadow_inactive_y_offset;

    int shadow_y_offset;

    // window drop shadows

    d->shadow_colour = config->readColorEntry("ShadowColour", &Qt::black);

    d->shadow_docks = config->readBoolEntry("ShadowDocks", false);

    d->shadow_overrides = config->readBoolEntry("ShadowOverrides", false);

    d->shadow_topMenus = config->readBoolEntry("ShadowTopMenus", false);

    d->shadow_inactive_colour = config->readColorEntry("InactiveShadowColour", &Qt::black);

    d->shadow_inactive_enabled = config->readBoolEntry("InactiveShadowEnabled", false);

    d->shadow_inactive_opacity = config->readDoubleNumEntry("InactiveShadowOpacity", 0.75);

    d->shadow_inactive_thickness = config->readNumEntry("InactiveShadowThickness", 5);

    d->shadow_inactive_x_offset = config->readNumEntry("InactiveShadowXOffset", 0);

    d->shadow_inactive_y_offset = config->readNumEntry("InactiveShadowYOffset", 5);

    d->shadow_enabled = config->readBoolEntry("ShadowEnabled", false);

    d->shadow_opacity = config->readDoubleNumEntry("ShadowOpacity", 0.75);

    d->shadow_thickness = config->readNumEntry("ShadowThickness", 10);

    d->shadow_x_offset = config->readNumEntry("ShadowXOffset", 0);

    d->shadow_y_offset = config->readNumEntry("ShadowYOffset", 10);

QColor &Options::shadowColour(bool active)

{

    return active ? d->shadow_colour : d->shadow_inactive_colour;

}

bool Options::shadowWindowType(NET::WindowType t)

{

    bool retval;

    switch (t) {

        case NET::Dialog:

        case NET::Normal:

            retval = true;

            break;

        case NET::Desktop:

        case NET::Menu:

        case NET::Toolbar:

            retval = false;

            break;

        case NET::Dock:

            retval = d->shadow_docks;

            break;

        case NET::Override:

            retval = d->shadow_overrides;

            break;

        case NET::TopMenu:

            retval = d->shadow_topMenus;

            break;

        default:

            retval = false;

            break;

    }

    return retval;

}

bool Options::shadowEnabled(bool active)

{

    return active ? d->shadow_enabled : d->shadow_inactive_enabled;

}

double Options::shadowOpacity(bool active)

{

    return active ? d->shadow_opacity : d->shadow_inactive_opacity;

}

int Options::shadowThickness(bool active)

{

    return active ? d->shadow_thickness : d->shadow_inactive_thickness;

}

int Options::shadowXOffset(bool active)

{

    return active ? d->shadow_x_offset : d->shadow_inactive_x_offset;

}

int Options::shadowYOffset(bool active)

{

    return active ? d->shadow_y_offset : d->shadow_inactive_y_offset;

}

#include <netwm_def.h>

    * @returns A QColor representing the colour that window drop shadows should

    *          be.

    */

    QColor &shadowColour(bool active=true);

    /**

     * @returns true if shadows should be drawn around windows of the

     *          specified type

     */

    bool shadowWindowType(NET::WindowType t);

    /**

    * @returns true if window shadows should be drawn

    */

    bool shadowEnabled(bool active=true);

    /**

    * @returns Window shadow's opacity between 0.01 and 1.00.

    */

    double shadowOpacity(bool active=true);

    /**

    * @returns How thick a shadow should be to either side of of a window.

    */

    int shadowThickness(bool active=true);

    /**

    * @returns Number of pixels along the X-axis by which to offset window

    *          shadows.

    */

    int shadowXOffset(bool active=true);

    /**

    * @returns Number of pixels along the Y-axis by which to offset window

    *          shadows.

    */

    int shadowYOffset(bool active=true);

    /**

    emit reconfigured();

    dock_shadow_stack = new Window[stacking_order.count() * 2];

    window_stack = new Window[stacking_order.count() * 2];

    i = 0;

    j = 0;

    for ( ClientList::ConstIterator it = stacking_order.fromLast();

            it != stacking_order.end(); --it) {

        window_stack[i++] = (*it)->winId();

        if ((*it)->isDock()) {

            if ((shadow = (*it)->shadowId()) != None)

                dock_shadow_stack[j++] = shadow;

            }

            else {

                if ((shadow = (*it)->shadowId()) != None)

                    // If the current window also has a shadow, place it

                    // immediately under the current window

                    window_stack[i++] = shadow;

            }

    }

    numDocks = j;

    for (j = 0; j < numDocks; j++)

        // Shadows for dock windows go at the bottom of the stack

        window_stack[i++] = dock_shadow_stack[j++];

    XRestackWindows(qt_xdisplay(), window_stack, i);

    delete [] dock_shadow_stack;

    delete [] window_stack;

signals:

    void reconfigured();

#include <qslider.h>

#include <qspinbox.h>

#include <kcolorbutton.h>

	cbWindowShadow = new QCheckBox(

			i18n("&Draw a drop shadow under windows"), checkGroup);

	QWhatsThis::add(cbWindowShadow,

			i18n("Enabling this checkbox will allow you to choose a kind of "

				 "drop shadow to draw under each window."));

	tabWidget->setTabEnabled(shadowPage, cbWindowShadow->isChecked());

	connect( cbWindowShadow, SIGNAL(clicked()), SLOT(slotSelectionChanged()) );

	connect( cbWindowShadow, SIGNAL(toggled(bool)), SLOT(slotEnableShadowTab(bool)) );

void KWinDecorationModule::slotEnableShadowTab(bool on)

{

	tabWidget->setTabEnabled(shadowPage, on);

}

	cbWindowShadow->setChecked( conf->readBoolEntry("ShadowEnabled", false) );