twin-style-dekorator/client/deKoratorclient.cpp

///////////////////////////////////////////////////////////////////////
// -------------------
// DeKorator window decoration for KDE
// -------------------
// Copyright (C) 2005  moty rahamim <moty.rahamim@gmail.com>
//
// Based on Example-0.8, some ideas and code have been taken from plastik and KCMicons
//
// Example window decoration for KDE
// Copyright (c) 2003, 2004 David Johnson <david@usermode.org>
//
// Plastik KWin window decoration
// Copyright (C) 2003-2005 Sandro Giessl <sandro@giessl.com>
//
// KCMicons for KDE
// Copyright (c) 2000 Antonio Larrosa <larrosa@kde.org>
//
// 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; see the file COPYING.  If not, write to
// the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
// Boston, MA 02110-1301, USA.
///////////////////////////////////////////////////////////////////////

#if defined(HAVE_CONFIG_H)
# include "config.h"
#endif

#include "deKoratorclient.h"

#include <tqsettings.h>

using namespace DeKorator;

// global constants

static int MARGIN = 4;
//static int GRUBMARGIN = 5;

static TQColor STYLEBGCOL;

// frames
static int TITLESIZE = 0;
static int LEFTFRAMESIZE = 0;
static int BUTTOMFRAMESIZE = 0;
static int RIGHTFRAMESIZE = 0;

// deco
static int TOPLEFTCORNERWIDTH;
static int TOPRIGHTCORNERWIDTH;
static int LEFTTITLEWIDTH;
static int RIGHTTITLEWIDTH;
static int TOPLEFTFRAMEHEIGHT;
static int BOTTOMLEFTFRAMEHEIGHT;
static int TOPRIGHTFRAMEHEIGHT;
static int BOTTOMRIGHTFRAMEHEIGHT;
static int LEFTBOTTOMFRAMEWIDTH;
static int RIGHTBOTTOMFRAMEWIDTH;

// buttons
//static const int DECOSIZE = 24;

static int BUTTONSHEIGHT = 0;

static int BTNHELPEWIDTH = 0;
static int BTNMAXWIDTH = 0;
static int BTNCLOSEWIDTH = 0;
static int BTNMINWIDTH = 0;
static int BTNSTICKYWIDTH = 0;
static int BTNABOVEWIDTH = 0;
static int BTNBELOWWIDTH = 0;
static int BTNSHADEWIDTH = 0;
static int BTNMENUWIDTH = 0;

static int BTNHELPEHEIGHT = 0;
static int BTNMAXHEIGHT = 0;
static int BTNCLOSEHEIGHT = 0;
static int BTNMINHEIGHT = 0;
static int BTNSTICKYHEIGHT = 0;
static int BTNABOVEHEIGHT = 0;
static int BTNBELOWHEIGHT = 0;
static int BTNSHADEHEIGHT = 0;
static int BTNMENUHEIGHT = 0;

// masks
static int TOPLEFTMASKWIDTH = 0;
static int TOPMIDMASKWIDTH = 0;
static int TOPRIGHTMASKWIDTH = 0;
static int BOTTOMLEFTMASKWIDTH = 0;
static int BOTTOMMIDMASKWIDTH = 0;
static int BOTTOMRIGHTMASKWIDTH = 0;

static int BOTTOMLEFTMASKHEIGHT = 0;
static int BOTTOMMIDMASKHEIGHT = 0;
static int BOTTOMRIGHTMASKHEIGHT = 0;

// config
// misc
static TQt::AlignmentFlags TITLEALIGN = TQt::AlignHCenter;
static bool USEMENUEIMAGE = FALSE;
static bool IGNOREAPPICNCOL = FALSE;
static bool DBLCLKCLOSE = FALSE;
static bool SHOWBTMBORDER = FALSE;
static bool USESHDTEXT = FALSE;
static int ACTIVESHDTEXTX = FALSE;
static int ACTIVESHDTEXTY = FALSE;
static TQColor ACTIVESHADECOLOR = TQColor( 150, 150, 150 );
static int INACTIVESHDTEXTX = FALSE;
static int INACTIVESHDTEXTY = FALSE;
static TQColor INACTIVESHADECOLOR = TQColor( 150, 150, 150 );
static int BTNSHIFTX = 0;
static int BTNSHIFTY = 0;


// colors

static bool USEANIMATION = TRUE;
static TQString ANIMATIONTYPE = "Intensity";

static int STEPS = 5;
static int INTERVAL = 5;
static int KEEPANIMATING = FALSE;

static TQString BUTTONHOVERTYPE = "To Gray";
static float EFFECTAMOUNT = 5;
static TQColor ACTIVEHIGHLIGHTCOLOR = TQColor( 150, 150, 150 );
static TQColor INACTIVEHIGHLIGHTCOLOR = TQColor( 150, 150, 150 );
static TQString DECOCOLORIZE = "Liquid Method";
static TQString BUTTONSCOLORIZE = "Liquid Method";
//static TQString BUTTONSHOVERCOLORIZE = "Liquid Method";
static const uint TIMERINTERVAL = 30; // msec
static const uint ANIMATIONSTEPS = 100;

//

// paths
static bool USEMASKS = FALSE;

// pix arrays
static TQPixmap *DECOARR[ decoCount ][ pixTypeCount ];
static TQPixmap *DECOPIXACTARR[ decoCount ];
static TQPixmap *DECOPIXINACTARR[ decoCount ];

static TQPixmap *BUTTONSARR[ buttonTypeAllCount ][ buttonStateCount ][ pixTypeCount ];
static TQPixmap *BUTTONPIXACTARR[ buttonTypeAllCount ][ buttonStateCount ];
static TQPixmap *BUTTONPIXINACTARR[ buttonTypeAllCount ][ buttonStateCount ];

//////////////////////////////////////////////////////////////////////////////
// DeKoratorFactory Class                                                     //
//////////////////////////////////////////////////////////////////////////////

bool DeKoratorFactory::initialized_ = FALSE;
bool DeKoratorFactory::colorizeActFrames_ = FALSE;
bool DeKoratorFactory::colorizeActButtons_ = FALSE;
bool DeKoratorFactory::colorizeInActFrames_ = FALSE;
bool DeKoratorFactory::colorizeInActButtons_ = FALSE;

bool DeKoratorFactory::useCustomButtonsColors_ = FALSE;
bool DeKoratorFactory::customColorsActiveButtons_ = FALSE;
bool DeKoratorFactory::customColorsInActiveButtons_ = FALSE;
TQColor DeKoratorFactory::cusBtnCol_[ buttonTypeAllCount ];

bool DeKoratorFactory::needInit_ = FALSE;
bool DeKoratorFactory::needReload_ = FALSE;
TQString DeKoratorFactory::framesPath_ = "";
TQString DeKoratorFactory::buttonsPath_ = "";
TQString DeKoratorFactory::masksPath_ = "";


extern "C"
{
    KDE_EXPORT KDecorationFactory* create_factory()
    {
        return new DeKorator::DeKoratorFactory();
    }
}

//////////////////////////////////////////////////////////////////////////////
// DeKoratorFactory()
// ----------------
// Constructor
DeKoratorFactory::DeKoratorFactory()
{
    TDEGlobal::locale()->insertCatalogue("twin_clients");
    TDEGlobal::locale()->insertCatalogue("twin-style-dekorator");

    readConfig();
    initialized_ = TRUE;

    initPixmaps();

    loadPixmaps();

    bool isActive = false;
    if ( colorizeInActFrames_ )
        colorizeDecoPixmaps( isActive );
    if ( colorizeInActButtons_ )
        colorizeButtonsPixmaps( isActive );

    isActive = true;
    if ( colorizeActFrames_ )
        colorizeDecoPixmaps( isActive );
    if ( colorizeActButtons_ )
        colorizeButtonsPixmaps( isActive );

    prepareDecoWithBgCol();

    chooseRightPixmaps();
}

//////////////////////////////////////////////////////////////////////////////
// ~DeKoratorFactory()
// -----------------
// Destructor
DeKoratorFactory::~DeKoratorFactory()
{
    initialized_ = FALSE;
    int i, j, k;

    for ( i = 0; i < decoCount; i++ )
    {
        for ( j = 0; j < pixTypeCount; j++ )
        {
            if ( DECOARR[ i ][ j ] )
                delete DECOARR[ i ][ j ];
        }
    }

    for ( i = 0; i < buttonTypeAllCount; i++ )
    {
        for ( j = 0; j < buttonStateCount; j++ )
        {
            for ( k = 0; k < pixTypeCount; k++ )
            {
                if ( BUTTONSARR[ i ][ j ][ k ] )
                    delete BUTTONSARR[ i ][ j ][ k ];
            }
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
// createDecoration()
// -----------------
// Create the decoration
KDecoration* DeKoratorFactory::createDecoration( KDecorationBridge* b )
{
    return new DeKoratorClient( b, this );
}

//////////////////////////////////////////////////////////////////////////////
// reset()
// -------
// Reset the handler. Returns TRUE if decorations need to be remade, FALSE if
// only a repaint is necessary
bool DeKoratorFactory::reset( unsigned long changed )
{
    //    captionBufferDirty_ = true;
    // read in the configuration
    initialized_ = FALSE;
    bool confchange = readConfig();
    initialized_ = TRUE;


    if ( confchange || ( changed & ( SettingDecoration | SettingButtons | SettingBorder | SettingColors ) ) )
    {
        //tqWarning( "aaaaaaaaaaaaa" );
        if ( DeKoratorFactory::needReload_ )
        {
            loadPixmaps();

            //             bool isActive = false;
            //             if ( colorizeInActFrames_ )
            //                 colorizeDecoPixmaps( isActive );
            //             if ( colorizeInActButtons_ )
            //                 colorizeButtonsPixmaps( isActive );
            //
            //             isActive = true;
            //             if ( colorizeActFrames_ )
            //                 colorizeDecoPixmaps( isActive );
            //             if ( colorizeActButtons_ )
            //                 colorizeButtonsPixmaps( isActive );
            //
            //             prepareDecoWithBgCol();
            //
            //             chooseRightPixmaps();
            //
            //             return TRUE;
        }

        //if ( DeKoratorFactory::needInit_ )
        {
            bool isActive = false;
            if ( colorizeInActFrames_ )
                colorizeDecoPixmaps( isActive );
            if ( colorizeInActButtons_ )
                colorizeButtonsPixmaps( isActive );

            isActive = true;
            if ( colorizeActFrames_ )
                colorizeDecoPixmaps( isActive );
            if ( colorizeActButtons_ )
                colorizeButtonsPixmaps( isActive );

            prepareDecoWithBgCol();

            chooseRightPixmaps();

            //return TRUE;
        }
        return TRUE;
    }
    else
    {
        resetDecorations( changed );
        return FALSE;
    }
}

//////////////////////////////////////////////////////////////////////////////
// readConfig()
// ------------
// Read in the configuration file
bool DeKoratorFactory::readConfig()
{
    // create a config object
    TDEConfig config( "twindeKoratorrc" );
    TQColor col = TQColor( 150, 150, 150 );

    // grab settings

    // misc settings
    config.setGroup( "MISC" );

    TQt::AlignmentFlags oldalign = TITLEALIGN;
    TQString value = config.readEntry( "TitleAlignment", "AlignHCenter" );
    if ( value == "AlignLeft" )
        TITLEALIGN = TQt::AlignLeft;
    else if ( value == "AlignHCenter" )
        TITLEALIGN = TQt::AlignHCenter;
    else if ( value == "AlignRight" )
        TITLEALIGN = TQt::AlignRight;

    bool oldUseMenuImage = USEMENUEIMAGE;
    USEMENUEIMAGE = config.readBoolEntry( "UseMenuImage", "false" );

    bool oldIgnoreAppIcnCol = IGNOREAPPICNCOL;
    IGNOREAPPICNCOL = config.readBoolEntry( "IgnoreAppIconCol", "false" );

//    bool oldDblClkClose = DBLCLKCLOSE;
    DBLCLKCLOSE = config.readBoolEntry( "DblClkClose", "false" );

    bool oldShowBtmBorder = SHOWBTMBORDER;
    SHOWBTMBORDER = config.readBoolEntry( "ShowBtmBorder", "false" );

    bool oldUseShdtext = USESHDTEXT;
    USESHDTEXT = config.readBoolEntry( "UseShdtext", "false" );

    int oldActiveShdtextX = ACTIVESHDTEXTX;
    ACTIVESHDTEXTX = config.readNumEntry( "ActiveShdtextX", 0 );

    int oldActiveShdtextY = ACTIVESHDTEXTY;
    ACTIVESHDTEXTY = config.readNumEntry( "ActiveShdtextY", 0 );

    TQColor oldActiveShadeColor = ACTIVESHADECOLOR;
    ACTIVESHADECOLOR = config.readColorEntry( "ActiveShadowColor", &col );

    int oldInActiveShdtextX = INACTIVESHDTEXTX;
    INACTIVESHDTEXTX = config.readNumEntry( "InActiveShdtextX", 0 );

    int oldInActiveShdtextY = INACTIVESHDTEXTY;
    INACTIVESHDTEXTY = config.readNumEntry( "InActiveShdtextY", 0 );

    TQColor oldInActiveShadeColor = INACTIVESHADECOLOR;
    INACTIVESHADECOLOR = config.readColorEntry( "InActiveShadowColor", &col );


    //int oldBtnShiftX = BTNSHIFTX;
    BTNSHIFTX = config.readNumEntry( "BtnShiftX", 0 );

    //int oldBtnShiftY = BTNSHIFTY;
    BTNSHIFTY = config.readNumEntry( "BtnShiftY", 0 );


    // color's settings
    config.setGroup( "COLORS" );

    bool oldColorizeActFrames = DeKoratorFactory::colorizeActFrames_;
    DeKoratorFactory::colorizeActFrames_ = config.readBoolEntry( "ColorizeActFrames", "false" );

    bool oldColorizeActButtons = DeKoratorFactory::colorizeActButtons_;
    DeKoratorFactory::colorizeActButtons_ = config.readBoolEntry( "ColorizeActButtons", "false" );

    bool oldColorizeInActFrames = DeKoratorFactory::colorizeInActFrames_;
    DeKoratorFactory::colorizeInActFrames_ = config.readBoolEntry( "ColorizeInActFrames", "false" );

    bool oldColorizeInActButtons = DeKoratorFactory::colorizeInActButtons_;
    DeKoratorFactory::colorizeInActButtons_ = config.readBoolEntry( "ColorizeInActButtons", "false" );

    USEANIMATION = config.readBoolEntry( "UseAnimation", "false" );

    ANIMATIONTYPE = config.readEntry( "AnimationType", "Liquid Method" );

    STEPS = config.readNumEntry( "AnimSteps", 5 );
    INTERVAL = config.readNumEntry( "AnimInterval", 30 );
    KEEPANIMATING = config.readBoolEntry( "KeepAnimating", "false" );

    BUTTONHOVERTYPE = config.readEntry( "ButtonsHoverType", "To Gray" );

    EFFECTAMOUNT = ( ( float ) config.readNumEntry( "EffectAmount", 5 ) / 10 );

    ACTIVEHIGHLIGHTCOLOR = config.readColorEntry( "ActiveHighlightColor", &col );

    INACTIVEHIGHLIGHTCOLOR = config.readColorEntry( "InActiveHighlightColor", &col );

    TQString oldDecoColorize = DECOCOLORIZE;
    DECOCOLORIZE = config.readEntry( "DecoColorize", "Liquid Method" );

    TQString oldButtonsColorize = BUTTONSCOLORIZE;
    BUTTONSCOLORIZE = config.readEntry( "ButtonsColorize", "Liquid Method" );
    /*
        TQString oldButtonsHoverColorize = BUTTONSHOVERCOLORIZE;
        BUTTONSHOVERCOLORIZE = config.readEntry( "ButtonsHoverColorize", "Liquid Method" );*/

    // buttons settings
    config.setGroup( "BUTTONS" );

    bool oldUseCustomButtonsColors = DeKoratorFactory::useCustomButtonsColors_;
    DeKoratorFactory::useCustomButtonsColors_ = config.readBoolEntry( "UseCustomButtonsColors", "false" );

    bool oldCustomColorsActiveButtons = DeKoratorFactory::customColorsActiveButtons_;
    DeKoratorFactory::customColorsActiveButtons_ = config.readBoolEntry( "customColorsActiveButtons", "false" );

    bool oldCustomColorsInActiveButtons = DeKoratorFactory::customColorsInActiveButtons_;
    DeKoratorFactory::customColorsInActiveButtons_ = config.readBoolEntry( "customColorsInActiveButtons", "false" );

    // load buttons colors
    TQColor colArr[ buttonTypeAllCount ];
    for ( int i = 0 ; i < buttonTypeAllCount ; i++ )
    {
        colArr[ i ] = DeKoratorFactory::cusBtnCol_[ i ];
    }
    DeKoratorFactory::cusBtnCol_[ restore ] = config.readColorEntry( "RestoreButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ help ] = config.readColorEntry( "HelpButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ max ] = config.readColorEntry( "MaxButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ min ] = config.readColorEntry( "MinButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ close ] = config.readColorEntry( "CloseButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ sticky ] = config.readColorEntry( "StickyButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ stickydown ] = config.readColorEntry( "StickyDownButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ above ] = config.readColorEntry( "AboveButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ abovedown ] = config.readColorEntry( "AboveDownButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ below ] = config.readColorEntry( "BelowButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ belowdown ] = config.readColorEntry( "BelowDownButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ shade ] = config.readColorEntry( "ShadeButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ shadedown ] = config.readColorEntry( "ShadeDownButtonColor", &col );
    DeKoratorFactory::cusBtnCol_[ menu ] = config.readColorEntry( "MenuButtonColor", &col );

    bool cusColChanged = false;
    for ( int i = 0 ; i < buttonTypeAllCount ; i++ )
    {
        if ( colArr[ i ] != DeKoratorFactory::cusBtnCol_[ i ] )
        {
            cusColChanged = true;
            i = buttonTypeAllCount;
            tqWarning( "true" );
        }

    }

    // path's settings
    config.setGroup( "PATHS" );

    TQString oldFramesPath = DeKoratorFactory::framesPath_;
    DeKoratorFactory::framesPath_ = config.readEntry( "FramesPath", "" );

    TQString oldButtonsPath = DeKoratorFactory::buttonsPath_;
    DeKoratorFactory::buttonsPath_ = config.readEntry( "ButtonsPath", "" );

    bool oldUseMasks = USEMASKS;
    USEMASKS = config.readBoolEntry( "UseMasks", "false" );

    TQString oldMasksPath = DeKoratorFactory::masksPath_;
    DeKoratorFactory::masksPath_ = config.readEntry( "MasksPath", "" );


    //style backgrond
    TQColor oldStyleBgCol = STYLEBGCOL;

    TQString colStr = TQSettings().readEntry( "/TQt/Palette/active", "aaaa" );
    colStr = colStr.section( "#", 3, 3 ) ;
    colStr.insert( 0, '#' );
    colStr.truncate( 7 );

    TQColor c;
    c.setNamedColor( colStr );
    STYLEBGCOL = c;



    if ( oldalign == TITLEALIGN &&
            oldUseMenuImage == USEMENUEIMAGE &&
            oldIgnoreAppIcnCol == IGNOREAPPICNCOL &&
            oldShowBtmBorder == SHOWBTMBORDER &&
            oldUseShdtext == USESHDTEXT &&
            oldActiveShdtextX == ACTIVESHDTEXTX &&
            oldActiveShdtextY == ACTIVESHDTEXTY &&
            oldActiveShadeColor == ACTIVESHADECOLOR &&
            oldInActiveShdtextX == INACTIVESHDTEXTX &&
            oldInActiveShdtextY == INACTIVESHDTEXTY &&
            oldInActiveShadeColor == INACTIVESHADECOLOR &&
            oldColorizeActFrames == DeKoratorFactory::colorizeActFrames_ &&
            oldColorizeActButtons == DeKoratorFactory::colorizeActButtons_ &&
            oldColorizeInActFrames == DeKoratorFactory::colorizeInActFrames_ &&
            oldColorizeInActButtons == DeKoratorFactory::colorizeInActButtons_ &&
            oldDecoColorize == DECOCOLORIZE &&
            oldButtonsColorize == BUTTONSCOLORIZE &&
            oldUseCustomButtonsColors == DeKoratorFactory::useCustomButtonsColors_ &&
            oldCustomColorsActiveButtons == DeKoratorFactory::customColorsActiveButtons_ &&
            oldCustomColorsInActiveButtons == DeKoratorFactory::customColorsInActiveButtons_ &&
            cusColChanged == false &&
            oldFramesPath == DeKoratorFactory::framesPath_ &&
            oldButtonsPath == DeKoratorFactory::buttonsPath_ &&
            oldMasksPath == DeKoratorFactory::masksPath_ &&
            oldUseMasks == USEMASKS &&
            oldStyleBgCol == STYLEBGCOL
       )
        return FALSE;
    else
    {
        //         if ( oldColorizeActFrames != DeKoratorFactory::colorizeActFrames_ ||
        //                 oldColorizeActButtons != DeKoratorFactory::colorizeActButtons_ ||
        //                 oldColorizeInActFrames != DeKoratorFactory::colorizeInActFrames_ ||
        //                 oldColorizeInActButtons != DeKoratorFactory::colorizeInActButtons_ ||
        //                 oldDecoColorize != DECOCOLORIZE ||
        //                 oldButtonsColorize != BUTTONSCOLORIZE ||
        //                 cusColChanged == true ||
        //                 oldStyleBgCol != STYLEBGCOL
        //            )
        //             DeKoratorFactory::needInit_ = TRUE;
        //         else
        //             DeKoratorFactory::needInit_ = FALSE;

        if ( oldFramesPath != DeKoratorFactory::framesPath_ ||
                oldButtonsPath != DeKoratorFactory::buttonsPath_ ||
                oldMasksPath != DeKoratorFactory::masksPath_
           )
            DeKoratorFactory::needReload_ = TRUE;
        else
            DeKoratorFactory::needReload_ = FALSE;

        return TRUE;
    }
}

//////////////////////////////////////////////////////////////////////////////
// loadPixmaps()
// ------------
// Read in the configuration file
void DeKoratorFactory::loadPixmaps()
{
    TQString decoPixDir = DeKoratorFactory::framesPath_;
    TQString btnPixDir = DeKoratorFactory::buttonsPath_;
    TQString masksPixDir = DeKoratorFactory::masksPath_;


    // deco
    // top bar from left to right
    DECOARR[ topLeftCorner ][ orig ] ->load( decoPixDir + "/topLeftCornerBg.png" );
    DECOARR[ leftButtons ][ orig ] ->load( decoPixDir + "/leftButtonsBg.png" );
    DECOARR[ leftTitle ][ orig ] ->load( decoPixDir + "/leftTitleBg.png" );
    DECOARR[ midTitle ][ orig ] ->load( decoPixDir + "/midTitleBg.png" );
    DECOARR[ rightTitle ][ orig ] ->load( decoPixDir + "/rightTitleBg.png" );
    DECOARR[ rightButtons ][ orig ] ->load( decoPixDir + "/rightButtonsBg.png" );
    DECOARR[ topRightCorner ][ orig ] ->load( decoPixDir + "/topRightCornerBg.png" );
    // left frame from top to buttom
    DECOARR[ topLeftFrame ][ orig ] ->load( decoPixDir + "/topLeftFrameBg.png" );
    DECOARR[ midLeftFrame ][ orig ] ->load( decoPixDir + "/midLeftFrameBg.png" );
    DECOARR[ buttomLeftFrame ][ orig ] ->load( decoPixDir + "/bottomLeftFrameBg.png" );
    // buttom frame from left to right
    DECOARR[ leftButtomFrame ][ orig ] ->load( decoPixDir + "/leftBottomFrameBg.png" );
    DECOARR[ midButtomFrame ][ orig ] ->load( decoPixDir + "/midBottomFrameBg.png" );
    DECOARR[ rightButtomFrame ][ orig ] ->load( decoPixDir + "/rightBottomFrameBg.png" );
    // right frame from top to buttom
    DECOARR[ topRightFrame ][ orig ] ->load( decoPixDir + "/topRightFrameBg.png" );
    DECOARR[ midRightFrame ][ orig ] ->load( decoPixDir + "/midRightFrameBg.png" );
    DECOARR[ buttomRightFrame ][ orig ] ->load( decoPixDir + "/bottomRightFrameBg.png" );


    // buttons
    BUTTONSARR[ restore ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonRestore.png" );
    BUTTONSARR[ restore ][ press ][ normal ] ->load( btnPixDir + "/press/buttonRestorePress.png" );
    BUTTONSARR[ restore ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonRestoreHover.png" );

    BUTTONSARR[ help ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonHelp.png" );
    BUTTONSARR[ help ][ press ][ normal ] ->load( btnPixDir + "/press/buttonHelpPress.png" );
    BUTTONSARR[ help ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonHelpHover.png" );

    BUTTONSARR[ max ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonMax.png" );
    BUTTONSARR[ max ][ press ][ normal ] ->load( btnPixDir + "/press/buttonMaxPress.png" );
    BUTTONSARR[ max ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonMaxHover.png" );

    BUTTONSARR[ min ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonMin.png" );
    BUTTONSARR[ min ][ press ][ normal ] ->load( btnPixDir + "/press/buttonMinPress.png" );
    BUTTONSARR[ min ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonMinHover.png" );

    BUTTONSARR[ close ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonClose.png" );
    BUTTONSARR[ close ][ press ][ normal ] ->load( btnPixDir + "/press/buttonClosePress.png" );
    BUTTONSARR[ close ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonCloseHover.png" );

    BUTTONSARR[ sticky ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonSticky.png" );
    BUTTONSARR[ sticky ][ press ][ normal ] ->load( btnPixDir + "/press/buttonStickyDownPress.png" );
    BUTTONSARR[ sticky ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonStickyHover.png" );

    BUTTONSARR[ stickydown ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonStickyDown.png" );
    BUTTONSARR[ stickydown ][ press ][ normal ] ->load( btnPixDir + "/press/buttonStickyDownPress.png" );
    BUTTONSARR[ stickydown ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonStickyDownHover.png" );

    BUTTONSARR[ above ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonAbove.png" );
    BUTTONSARR[ above ][ press ][ normal ] ->load( btnPixDir + "/press/buttonAbovePress.png" );
    BUTTONSARR[ above ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonAboveHover.png" );

    BUTTONSARR[ abovedown ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonAboveDown.png" );
    BUTTONSARR[ abovedown ][ press ][ normal ] ->load( btnPixDir + "/press/buttonAboveDownPress.png" );
    BUTTONSARR[ abovedown ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonAboveDownHover.png" );

    BUTTONSARR[ below ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonBelow.png" );
    BUTTONSARR[ below ][ press ][ normal ] ->load( btnPixDir + "/press/buttonBelowPress.png" );
    BUTTONSARR[ below ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonBelowHover.png" );

    BUTTONSARR[ belowdown ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonBelowDown.png" );
    BUTTONSARR[ belowdown ][ press ][ normal ] ->load( btnPixDir + "/press/buttonBelowDownPress.png" );
    BUTTONSARR[ belowdown ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonBelowDownHover.png" );

    BUTTONSARR[ shade ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonShade.png" );
    BUTTONSARR[ shade ][ press ][ normal ] ->load( btnPixDir + "/press/buttonShadePress.png" );
    BUTTONSARR[ shade ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonShadeHover.png" );

    BUTTONSARR[ shadedown ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonShadeDown.png" );
    BUTTONSARR[ shadedown ][ press ][ normal ] ->load( btnPixDir + "/press/buttonShadeDownPress.png" );
    BUTTONSARR[ shadedown ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonShadeDownHover.png" );

    BUTTONSARR[ menu ][ regular ][ normal ] ->load( btnPixDir + "/normal/buttonMenu.png" );
    BUTTONSARR[ menu ][ press ][ normal ] ->load( btnPixDir + "/press/buttonMenuPress.png" );
    BUTTONSARR[ menu ][ hover ][ normal ] ->load( btnPixDir + "/hover/buttonMenuHover.png" );


    //masks
    topLeftCornerBitmap_ = TQBitmap( masksPixDir + "/topLeftCornerBitmap.png" );
    topMidBitmap_ = TQBitmap( masksPixDir + "/topMidBitmap.png" );
    topRightCornerBitmap_ = TQBitmap( masksPixDir + "/topRightCornerBitmap.png" );
    buttomLeftCornerBitmap_ = TQBitmap( masksPixDir + "/buttomLeftCornerBitmap.png" );
    buttomMidBitmap_ = TQBitmap( masksPixDir + "/buttomMidBitmap.png" );
    buttomRightCornerBitmap_ = TQBitmap( masksPixDir + "/buttomRightCornerBitmap.png" );

    determineSizes();

    //prepareDecoWithBgCol();

}

//////////////////////////////////////////////////////////////////////////////
// determineSizes()
// ------------
//
void DeKoratorFactory::determineSizes()
{
    //MARGIN = midButtomFrameBg_.height();

    // frames
    TITLESIZE = DECOARR[ midTitle ][ orig ] ->height();
    LEFTFRAMESIZE = DECOARR[ midLeftFrame ][ orig ] ->width();
    BUTTOMFRAMESIZE = DECOARR[ midButtomFrame ][ orig ] ->height();
    RIGHTFRAMESIZE = DECOARR[ midRightFrame ][ orig ] ->width();

    TOPLEFTCORNERWIDTH = DECOARR[ topLeftCorner ][ orig ] ->width();
    TOPRIGHTCORNERWIDTH = DECOARR[ topRightCorner ][ orig ] ->width();
    LEFTTITLEWIDTH = DECOARR[ leftTitle ][ orig ] ->width();
    RIGHTTITLEWIDTH = DECOARR[ rightTitle ][ orig ] ->width();
    TOPLEFTFRAMEHEIGHT = DECOARR[ topLeftFrame ][ orig ] ->height();
    BOTTOMLEFTFRAMEHEIGHT = DECOARR[ buttomLeftFrame ][ orig ] ->height();
    TOPRIGHTFRAMEHEIGHT = DECOARR[ topRightFrame ][ orig ] ->height();
    BOTTOMRIGHTFRAMEHEIGHT = DECOARR[ buttomRightFrame ][ orig ] ->height();
    LEFTBOTTOMFRAMEWIDTH = DECOARR[ leftButtomFrame ][ orig ] ->width();
    RIGHTBOTTOMFRAMEWIDTH = DECOARR[ rightButtomFrame ][ orig ] ->width();


    // buttons
    BUTTONSHEIGHT = TITLESIZE;

    BTNHELPEWIDTH = BUTTONSARR[ help ][ regular ][ normal ] ->width();
    BTNMAXWIDTH = BUTTONSARR[ max ][ regular ][ normal ] ->width();
    BTNCLOSEWIDTH = BUTTONSARR[ close ][ regular ][ normal ] ->width();
    BTNMINWIDTH = BUTTONSARR[ min ][ regular ][ normal ] ->width();
    BTNSTICKYWIDTH = BUTTONSARR[ sticky ][ regular ][ normal ] ->width();
    BTNABOVEWIDTH = BUTTONSARR[ above ][ regular ][ normal ] ->width();
    BTNBELOWWIDTH = BUTTONSARR[ below ][ regular ][ normal ] ->width();
    BTNSHADEWIDTH = BUTTONSARR[ shade ][ regular ][ normal ] ->width();
    BTNMENUWIDTH = BUTTONSARR[ menu ][ regular ][ normal ] ->width();

    BTNHELPEHEIGHT = BUTTONSARR[ help ][ regular ][ normal ] ->height();
    BTNMAXHEIGHT = BUTTONSARR[ max ][ regular ][ normal ] ->height();
    BTNCLOSEHEIGHT = BUTTONSARR[ close ][ regular ][ normal ] ->height();
    BTNMINHEIGHT = BUTTONSARR[ min ][ regular ][ normal ] ->height();
    BTNSTICKYHEIGHT = BUTTONSARR[ sticky ][ regular ][ normal ] ->height();
    BTNABOVEHEIGHT = BUTTONSARR[ above ][ regular ][ normal ] ->height();
    BTNBELOWHEIGHT = BUTTONSARR[ below ][ regular ][ normal ] ->height();
    BTNSHADEHEIGHT = BUTTONSARR[ shade ][ regular ][ normal ] ->height();
    BTNMENUHEIGHT = BUTTONSARR[ menu ][ regular ][ normal ] ->height();

    // masks
    TOPLEFTMASKWIDTH = topLeftCornerBitmap_.width();
    TOPMIDMASKWIDTH = topMidBitmap_.width();
    TOPRIGHTMASKWIDTH = topRightCornerBitmap_.width();
    BOTTOMLEFTMASKWIDTH = buttomLeftCornerBitmap_.width();
    BOTTOMMIDMASKWIDTH = buttomMidBitmap_.width();
    BOTTOMRIGHTMASKWIDTH = buttomRightCornerBitmap_.width();

    BOTTOMLEFTMASKHEIGHT = buttomLeftCornerBitmap_.height();
    BOTTOMMIDMASKHEIGHT = buttomMidBitmap_.height();
    BOTTOMRIGHTMASKHEIGHT = buttomRightCornerBitmap_.height();

}


//////////////////////////////////////////////////////////////////////////////
// colorizeDecoPixmaps()
// ------------
//
void DeKoratorFactory::colorizeDecoPixmaps( bool isActive )
{
    int i;
    TQColor col = options() ->colorGroup( KDecoration::ColorTitleBar, isActive ).background();

    if ( isActive )
    {
        for ( i = 0; i < decoCount; i++ )
        {
            *( DECOARR[ i ][ actCol ] ) = *( DECOARR[ i ][ orig ] );
            colorizePixmap( DECOARR[ i ][ actCol ], col, DECOCOLORIZE );
        }
    }
    else
    {
        for ( i = 0; i < decoCount; i++ )
        {
            *( DECOARR[ i ][ inActCol ] ) = *( DECOARR[ i ][ orig ] );
            colorizePixmap( DECOARR[ i ][ inActCol ], col, DECOCOLORIZE );
        }

    }

    prepareDecoWithBgCol();
}

//////////////////////////////////////////////////////////////////////////////
// colorizeButtonsPixmaps()
// ------------
//
void DeKoratorFactory::colorizeButtonsPixmaps( bool isActive )
{
    int i, j;
    TQColor col = options() ->colorGroup( KDecoration::ColorButtonBg, isActive ).background();

    if ( isActive )
    {
        if ( useCustomButtonsColors_ && customColorsActiveButtons_ )
        {
            for ( i = 0; i < buttonTypeAllCount; i++ )
            {
                for ( j = 0; j < buttonStateCount; j++ )
                {
                    *( BUTTONSARR[ i ][ j ][ actCol ] ) = *( BUTTONSARR[ i ][ j ][ normal ] );
                    colorizePixmap( BUTTONSARR[ i ][ j ][ actCol ], cusBtnCol_[ i ], BUTTONSCOLORIZE );
                }
            }
        }
        else
        {
            for ( i = 0; i < buttonTypeAllCount; i++ )
            {
                for ( j = 0; j < buttonStateCount; j++ )
                {
                    *( BUTTONSARR[ i ][ j ][ actCol ] ) = *( BUTTONSARR[ i ][ j ][ normal ] );
                    colorizePixmap( BUTTONSARR[ i ][ j ][ actCol ], col, BUTTONSCOLORIZE );
                }
            }
        }
    }
    else
    {
        if ( ( useCustomButtonsColors_ && customColorsInActiveButtons_ ) )
        {
            for ( i = 0; i < buttonTypeAllCount; i++ )
            {
                for ( j = 0; j < buttonStateCount; j++ )
                {
                    *( BUTTONSARR[ i ][ j ][ inActCol ] ) = *( BUTTONSARR[ i ][ j ][ normal ] );
                    colorizePixmap( BUTTONSARR[ i ][ j ][ inActCol ], cusBtnCol_[ i ], BUTTONSCOLORIZE );
                }
            }
        }
        else
        {
            for ( i = 0; i < buttonTypeAllCount; i++ )
            {
                for ( j = 0; j < buttonStateCount; j++ )
                {
                    *( BUTTONSARR[ i ][ j ][ inActCol ] ) = *( BUTTONSARR[ i ][ j ][ normal ] );
                    colorizePixmap( BUTTONSARR[ i ][ j ][ inActCol ], col, BUTTONSCOLORIZE );
                }
            }
        }
    }
}


//////////////////////////////////////////////////////////////////////////////
// colorizePixmap()
// ------------
//
void DeKoratorFactory::colorizePixmap( TQPixmap *pix, TQColor c, TQString colorizeMethod )
{
    TQImage img;
    if ( colorizeMethod == "Liquid Method" )
    {
        img = pix->convertToImage();
        //TDEIconEffect::toGray( img, 1.0 );

        if ( img.depth() != 32 )
            img = img.convertDepth( 32 );
        TQImage *dest = new TQImage( img.width(), img.height(), 32 );
        dest->setAlphaBuffer( TRUE );
        unsigned int *data = ( unsigned int * ) img.bits();
        unsigned int *destData = ( unsigned int* ) dest->bits();
        int total = img.width() * img.height();
        int current;
        int delta;
        int destR, destG, destB, alpha;
        int srcR = c.red() + 100;
        int srcG = c.green() + 100;
        int srcB = c.blue() + 100;

        for ( current = 0; current < total; ++current )
        {
            alpha = tqAlpha( data[ current ] );

            //         tqWarning( "--------------------------" );
            //         tqWarning( "red - %d", tqRed( data[ current ] ) );
            //         tqWarning( "green - %d", tqRed( data[ current ] ) );
            //         tqWarning( "blue - %d", tqRed( data[ current ] ) );

            delta = 255 - tqGray( data[ current ] );

            destR = srcR - delta;
            destG = srcG - delta;
            destB = srcB - delta;

            if ( destR < 0 )
                destR = 0;
            if ( destG < 0 )
                destG = 0;
            if ( destB < 0 )
                destB = 0;
            if ( destR > 255 )
                destR = 255;
            if ( destG > 255 )
                destG = 255;
            if ( destB > 255 )
                destB = 255;
            destData[ current ] = tqRgba( destR, destG, destB, alpha );
        }
        pix->convertFromImage( *dest );
    }
    else if ( colorizeMethod == "Kde Method" )
    {
        img = pix->convertToImage();
        TDEIconEffect::colorize( img, c, 1.0 );
        pix->convertFromImage( img, 0 );
    }
    else if ( colorizeMethod == "Hue Adgustment" )
    {
        img = pix->convertToImage();
        //TDEIconEffect::toGray( img, 1.0 );

        if ( img.depth() != 32 )
            img = img.convertDepth( 32 );

        //         TQImage *dest;
        //         *dest = img;
        TQImage *dest = new TQImage( img.width(), img.height(), 32 );
        dest->setAlphaBuffer( TRUE );
        unsigned int *data = ( unsigned int * ) img.bits();
        unsigned int *destData = ( unsigned int* ) dest->bits();
        int total = img.width() * img.height();
        int current;
//        int delta;
        int destR, destG, destB, alpha;
//        int srcR = c.red();
//        int srcG = c.green();
//        int srcB = c.blue();
        int h, s, v, ch;
//        int *r, *g, *b, *a;
        TQColor col ;
//        float srcPercent, destPercent;

        for ( current = 0; current < total; ++current )
        {
            //             int tqRed ( data[ current ] );
            //             int tqGreen ( data[ current ] );
            //             int tqBlue ( data[ current ] );
            //             alpha = tqAlpha( destData[ current ] );
            //
            //             //destData[ current ] = data[ current ];
            //
            //             TQColor col = destData[ current ];
            //             col.getHsv( h, s, v );
            //             //*h += 50;
            //
            //             col.setHsv( 50, *s, *v );
            //
            //             col.getRgb( r, g, b );

            col.setRgb( data[ current ] );
            //col = TQt::red;
            c.hsv( &h, &s, &v );
            ch = h;
            col.hsv( &h, &s, &v );
            //             s = 0;
            //v += 100;
            col.setHsv( ch, s, v );
            destR = col.red();
            destG = col.green();
            destB = col.blue();
            alpha = tqAlpha( data[ current ] );


            //             if ( destR < 0 )
            //                 destR = 0;
            //             if ( destG < 0 )
            //                 destG = 0;
            //             if ( destB < 0 )
            //                 destB = 0;
            //             if ( destR > 255 )
            //                 destR = 255;
            //             if ( destG > 255 )
            //                 destG = 255;
            //             if ( destB > 255 )
            //                 destB = 255;

            destData[ current ] = tqRgba( destR, destG, destB, alpha );
            //destData[ current ] = data[ current ];
        }
        pix->convertFromImage( *dest,                                                             /*TQt::ColorOnly | TQt::DiffuseDither | TQt::DiffuseAlphaDither |*/ TQt::AvoidDither );
    }
}


//////////////////////////////////////////////////////////////////////////////
// colorizePixmap()
//
void DeKoratorFactory::initPixmaps()
{
    int i, j, k;

    for ( i = 0; i < decoCount; i++ )
    {
        for ( j = 0; j < pixTypeCount; j++ )
        {
            DECOARR[ i ][ j ] = new TQPixmap();
        }
    }

    for ( i = 0; i < buttonTypeAllCount; i++ )
    {
        for ( j = 0; j < buttonStateCount; j++ )
        {
            for ( k = 0; k < pixTypeCount; k++ )
            {
                BUTTONSARR[ i ][ j ][ k ] = new TQPixmap();
            }
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
// colorizePixmap()
//
void DeKoratorFactory::chooseRightPixmaps()
{
    int i, j;

    if ( DeKoratorFactory::colorizeActFrames_ )
    {
        for ( i = 0; i < decoCount; i++ )
        {
            DECOPIXACTARR[ i ] = DECOARR[ i ][ actCol ];
        }
    }
    else
    {
        for ( i = 0; i < decoCount; i++ )
        {
            DECOPIXACTARR[ i ] = DECOARR[ i ][ normal ];
        }
    }

    if ( DeKoratorFactory::colorizeInActFrames_ )
    {
        for ( i = 0; i < decoCount; i++ )
        {
            DECOPIXINACTARR[ i ] = DECOARR[ i ][ inActCol ];
        }
    }
    else
    {
        for ( i = 0; i < decoCount; i++ )
        {
            DECOPIXINACTARR[ i ] = DECOARR[ i ][ normal ];
        }
    }



    if ( DeKoratorFactory::colorizeActButtons_ )
    {

        for ( i = 0; i < buttonTypeAllCount; i++ )
        {
            for ( j = 0; j < buttonStateCount; j++ )
            {
                BUTTONPIXACTARR[ i ][ j ] = BUTTONSARR[ i ][ j ][ actCol ];
            }
        }
    }
    else
    {
        for ( i = 0; i < buttonTypeAllCount; i++ )
        {
            for ( j = 0; j < buttonStateCount; j++ )
            {
                BUTTONPIXACTARR[ i ][ j ] = BUTTONSARR[ i ][ j ][ normal ];
            }
        }
    }


    if ( DeKoratorFactory::colorizeInActButtons_ )
    {
        for ( i = 0; i < buttonTypeAllCount; i++ )
        {
            for ( j = 0; j < buttonStateCount; j++ )
            {
                BUTTONPIXINACTARR[ i ][ j ] = BUTTONSARR[ i ][ j ][ inActCol ];
            }
        }
    }
    else
    {
        for ( i = 0; i < buttonTypeAllCount; i++ )
        {
            for ( j = 0; j < buttonStateCount; j++ )
            {
                BUTTONPIXINACTARR[ i ][ j ] = BUTTONSARR[ i ][ j ][ normal ];
            }
        }
    }

}

//////////////////////////////////////////////////////////////////////////////
// prepareDecoWithBbCol()
//
void DeKoratorFactory::prepareDecoWithBgCol()
{
    int i;
    TQPainter painter;
    TQPixmap tempPix;
    TQWidget widget;
    TQColor col = widget.colorGroup().background();


    if ( DeKoratorFactory::colorizeActFrames_ )
    {
        for ( i = 0 ; i < decoCount ; i++ )
        {
            tempPix.resize( DECOARR[ i ][ orig ] ->width(), DECOARR[ i ][ orig ] ->height() );

            tempPix.fill( col );

            painter.begin( &tempPix );
            {
                painter.drawPixmap( 0, 0, *( DECOARR[ i ][ actCol ] ) );
            }
            painter.end();

            *( DECOARR[ i ][ actCol ] ) = tempPix;
        }
    }
    else
    {
        for ( i = 0 ; i < decoCount ; i++ )
        {
            tempPix.resize( DECOARR[ i ][ orig ] ->width(), DECOARR[ i ][ orig ] ->height() );

            tempPix.fill( col );

            painter.begin( &tempPix );
            {
                painter.drawPixmap( 0, 0, *( DECOARR[ i ][ orig ] ) );
            }
            painter.end();

            *( DECOARR[ i ][ normal ] ) = tempPix;
        }
    }

    if ( DeKoratorFactory::colorizeInActFrames_ )
    {
        for ( i = 0 ; i < decoCount ; i++ )
        {
            tempPix.resize( DECOARR[ i ][ orig ] ->width(), DECOARR[ i ][ orig ] ->height() );

            tempPix.fill( col );

            painter.begin( &tempPix );
            {
                painter.drawPixmap( 0, 0, *( DECOARR[ i ][ inActCol ] ) );
            }
            painter.end();

            *( DECOARR[ i ][ inActCol ] ) = tempPix;
        }
    }
    else
    {
        for ( i = 0 ; i < decoCount ; i++ )
        {
            tempPix.resize( DECOARR[ i ][ orig ] ->width(), DECOARR[ i ][ orig ] ->height() );

            tempPix.fill( col );

            painter.begin( &tempPix );
            {
                painter.drawPixmap( 0, 0, *( DECOARR[ i ][ orig ] ) );
            }
            painter.end();

            *( DECOARR[ i ][ normal ] ) = tempPix;
        }
    }


    //     if ( !DeKoratorFactory::colorizeActFrames_ || !DeKoratorFactory::colorizeInActFrames_ )
    //     {
    //         for ( i = 0 ; i < decoCount ; i++ )
    //         {
    //             tempPix.resize( DECOARR[ i ][ orig ] ->width(), DECOARR[ i ][ orig ] ->height() );
    //
    //             tempPix.fill( col );
    //
    //             painter.begin( &tempPix );
    //             {
    //                 painter.drawPixmap( 0, 0, *( DECOARR[ i ][ orig ] ) );
    //             }
    //             painter.end();
    //
    //             *( DECOARR[ i ][ normal ] ) = tempPix;
    //         }
    //     }
}






//////////////////////////////////////////////////////////////////////////////
// DeKoratorButton Class                                                      //
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// DeKoratorButton()
// ---------------
// Constructor
DeKoratorButton::DeKoratorButton( bool isLeft, int buttonWidth, int buttonHeight, DeKoratorClient * parent, const char * name,
                                  const TQString & tip, ButtonType type, buttonTypeAll btnType )
        : TQButton( parent->widget(), name ), isLeft_( isLeft ), buttonWidth_( buttonWidth ), client_( parent ), type_( type ), lastmouse_( NoButton ), decoPixHeight_( buttonHeight )
{
    //decoPixInAct_ = buttonPixInAct;
    animProgress = 0;
    hover_ = FALSE;
    setBackgroundMode( NoBackground );
    setFixedSize( buttonWidth_, BUTTONSHEIGHT );
    setCursor( arrowCursor );



    //if ( buttonPix )
    setPixmap( btnType );
    TQToolTip::add
        ( this, tip );
    animTmr = new TQTimer( this );
    connect( animTmr, TQ_SIGNAL( timeout() ), this, TQ_SLOT( animate() ) );
}

//////////////////////////////////////////////////////////////////////////////
// DeKoratorButton()
// ---------------
// destructor
DeKoratorButton::~DeKoratorButton()
{
    //if ( deco_ ) delete deco_;
}

//////////////////////////////////////////////////////////////////////////////
// setPixmap()

// -----------
// Set the button decoration
void DeKoratorButton::setPixmap( buttonTypeAll btnType )
{
    //   decoPix_ = buttonPix;
    //   decoPixPress_ = buttonPixPress;
    //   decoPixHover_ = buttonPixHover;
    //   decoPixInAct_ = buttonPixInAct;

    //   btnPixAct_ = btnPixAct;
    //   btnPixInAct_ = btnPixInAct;
    btnType_ = btnType;


    //     btnPixAct_ = btnPixAct;
    //     btnPixInAct_ = btnPixInAct;

    //decoPix_->setMask(*deco_);
    //   }
    //   else
    //   {
    //     deco_ = new TQBitmap(DECOSIZE, DECOSIZE, bitmap, TRUE);
    //     deco_->setMask(*deco_);
    //   }
    repaint( FALSE );
}

//////////////////////////////////////////////////////////////////////////////
// sizeHint()
// ----------
// Return size hint
TQSize DeKoratorButton::sizeHint() const
{
    return TQSize( buttonWidth_, BUTTONSHEIGHT );
}

//////////////////////////////////////////////////////////////////////////////
// enterEvent()
// ------------
// Mouse has entered the button
void DeKoratorButton::enterEvent( TQEvent * e )
{
    // if we wanted to do mouseovers, we would keep track of it here
    TQButton::enterEvent( e );
    s = STEPS;
    hover_ = TRUE;
    setCursor( TQt::PointingHandCursor );

    if ( USEANIMATION )
        animate();
    else
        repaint( FALSE );
}

//////////////////////////////////////////////////////////////////////////////
// leaveEvent()
// ------------
// Mouse has left the button
void DeKoratorButton::leaveEvent( TQEvent * e )
{
    // if we wanted to do mouseovers, we would keep track of it here

    TQButton::leaveEvent( e );
    //STEPS = s;
    hover_ = FALSE;
    unsetCursor ();

    if ( USEANIMATION )
        animate();
    else
        repaint( FALSE );
}

//////////////////////////////////////////////////////////////////////////////
// mousePressEvent()
// -----------------
// Button has been pressed
void DeKoratorButton::mousePressEvent( TQMouseEvent * e )
{
    lastmouse_ = e->button();

    // translate and pass on mouse event
    int button = LeftButton;
    if ( ( type_ != ButtonMax ) && ( e->button() != LeftButton ) )
    {
        button = NoButton; // middle & right buttons inappropriate
    }
    TQMouseEvent me( e->type(), e->pos(), e->globalPos(),
                    button, e->state() );
    TQButton::mousePressEvent( &me );
}

//////////////////////////////////////////////////////////////////////////////
// mouseReleaseEvent()
// -----------------
// Button has been released
void DeKoratorButton::mouseReleaseEvent( TQMouseEvent * e )
{
    lastmouse_ = e->button();

    // translate and pass on mouse event
    int button = LeftButton;
    if ( ( type_ != ButtonMax ) && ( e->button() != LeftButton ) )
    {
        button = NoButton; // middle & right buttons inappropriate
    }
    TQMouseEvent me( e->type(), e->pos(), e->globalPos(), button, e->state() );
    TQButton::mouseReleaseEvent( &me );
}

//////////////////////////////////////////////////////////////////////////////
// drawButton()
// ------------
// Draw the button
void DeKoratorButton::drawButton( TQPainter * painter )
{
    if ( !DeKoratorFactory::initialized() )
        return ;

    TQColorGroup group;
    int dx = 0, dy = 0;
    bool act = client_->isActive();
    TQImage buttonImgBak;

    // fill background
    if ( isLeft_ )
        painter->drawTiledPixmap( rect(), act ? *( DECOPIXACTARR[ leftButtons ] ) : *( DECOPIXINACTARR[ leftButtons ] ) );
    else
        painter->drawTiledPixmap( rect(), act ? *( DECOPIXACTARR[ rightButtons ] ) : *( DECOPIXINACTARR[ rightButtons ] ) );

    // apply app icon effects
    if ( type_ == ButtonMenu && !USEMENUEIMAGE )
    {
        dy = ( height() - 16 ) / 2;

        TQPixmap appIconPix = client_->icon().pixmap( TQIconSet::Small, TQIconSet::Normal );

        if ( !IGNOREAPPICNCOL )
        {
            if ( act )
            {
                if ( client_->decoFactory_->useCustomButtonsColors_ && client_->decoFactory_->customColorsActiveButtons_ )
                {
                    DeKoratorFactory::colorizePixmap( &appIconPix, client_->decoFactory_->cusBtnCol_[ menu ], BUTTONSCOLORIZE );
                }
                else if ( client_->decoFactory_->colorizeActButtons_ )
                {
                    TQColor col = client_->decoFactory_->options() ->colorGroup( KDecoration::ColorButtonBg, act ).background();

                    DeKoratorFactory::colorizePixmap( &appIconPix, col, BUTTONSCOLORIZE );
                }
            }
            else
            {
                if ( client_->decoFactory_->useCustomButtonsColors_ && client_->decoFactory_->customColorsInActiveButtons_ )
                {
                    DeKoratorFactory::colorizePixmap( &appIconPix, client_->decoFactory_->cusBtnCol_[ menu ], BUTTONSCOLORIZE );
                }
                else if ( client_->decoFactory_->colorizeInActButtons_ )
                {
                    TQColor col = client_->decoFactory_->options() ->colorGroup( KDecoration::ColorButtonBg, act ).background();

                    DeKoratorFactory::colorizePixmap( &appIconPix, col, BUTTONSCOLORIZE );
                }
            }
        }
        buttonImgBak = appIconPix;

    }
    else
    {
        dy = ( BUTTONSHEIGHT - decoPixHeight_ ) / 2;
    }


    // down
    if ( isDown() )
    {
        if ( !( type_ == ButtonMenu && !USEMENUEIMAGE ) )
        {
            buttonImgBak = act ? *( BUTTONPIXACTARR[ btnType_ ][ press ] ) : *( BUTTONPIXINACTARR[ btnType_ ][ press ] );
        }
        dx += BTNSHIFTX;
        dy += BTNSHIFTY;

        chooseRightHoverEffect( &buttonImgBak, BUTTONHOVERTYPE );
    }
    // hover
    else if ( hover_ )
    {
        if ( !( type_ == ButtonMenu && !USEMENUEIMAGE ) )
        {
            buttonImgBak = act ? *( BUTTONPIXACTARR[ btnType_ ][ hover ] ) : *( BUTTONPIXINACTARR[ btnType_ ][ hover ] );
        }
        chooseRightHoverEffect( &buttonImgBak, USEANIMATION ? ANIMATIONTYPE : BUTTONHOVERTYPE );
    }
    // regular
    else
    {
        if ( !( type_ == ButtonMenu && !USEMENUEIMAGE ) )
        {
            buttonImgBak = act ? *( BUTTONPIXACTARR[ btnType_ ][ regular ] ) : *( BUTTONPIXINACTARR[ btnType_ ][ regular ] );
        }

        if ( USEANIMATION && animProgress > 0 )
            chooseRightHoverEffect( &buttonImgBak, ANIMATIONTYPE );
    }

    painter->drawPixmap( dx, dy, buttonImgBak );


    if ( client_->isShade() && !SHOWBTMBORDER )
    {
        painter->setPen( TQColor( 70, 70, 70 ) );
        painter->drawLine( 0, BUTTONSHEIGHT - 1, buttonWidth_ - 1, BUTTONSHEIGHT - 1 );
    }
}

//////////////////////////////////////////////////////////////////////////////
// chooseRightHoverEffect()
// ------------
//
TQImage* DeKoratorButton::chooseRightHoverEffect( TQImage * img, TQString res )
{

    if ( USEANIMATION && !isDown() )
    {
        float f = ( ( float ) animProgress / 100 );

        if ( res == "Intensity" )
        {
            f /= 1.5;

            * img = KImageEffect::intensity ( *img, f );
        }
        else if ( res == "Blend" )
        {
            f /= 1.7;
            TQColor col = client_->isActive() ? ACTIVEHIGHLIGHTCOLOR : INACTIVEHIGHLIGHTCOLOR;

            * img = KImageEffect::blend ( col, *img, f );
        }
        else if ( res == "Solarize" )
        {
            KImageEffect::solarize ( *img, 100 - animProgress );
        }
        else if ( res == "Fade" )
        {
            f /= 3;
            TQColor col = client_->isActive() ? ACTIVEHIGHLIGHTCOLOR : INACTIVEHIGHLIGHTCOLOR;

            * img = KImageEffect::fade ( *img, f, col );
        }
        else if ( res == "Trashed" )
        {
            * img = KImageEffect::fade ( *img, animProgress, TQt::black );
        }
        else if ( res == "Hue Shift" )
        {
            int h, s, v;
            TQColor col ;
            int shift = ( int ) ( animProgress * 3.5 );
            col.setRgb( 255, 0, 0 );
            col.hsv( &h, &s, &v );
            col.setHsv( shift, s, v );

            TQPixmap pix;
            pix.convertFromImage( *img, TQt::AvoidDither );
            DeKoratorFactory::colorizePixmap( &pix, col, "Hue Adgustment" );
            *img = pix.convertToImage();
        }
    }
    else
    {
        if ( BUTTONHOVERTYPE == "To Gray" )
            TDEIconEffect::toGray( *img, EFFECTAMOUNT );
        else if ( BUTTONHOVERTYPE == "Colorize" )
        {
            TQColor col = client_->isActive() ? ACTIVEHIGHLIGHTCOLOR : INACTIVEHIGHLIGHTCOLOR;

            TQPixmap pix;
            pix.convertFromImage( *img, TQt::AvoidDither );
            DeKoratorFactory::colorizePixmap( &pix, col, BUTTONSCOLORIZE );
            *img = pix.convertToImage();
        }
        else if ( BUTTONHOVERTYPE == "DeSaturate" )
            TDEIconEffect::deSaturate( *img, EFFECTAMOUNT );
        else if ( BUTTONHOVERTYPE == "To Gamma" )
            TDEIconEffect::toGamma( *img, EFFECTAMOUNT );
    }
    return img;
}


//////////////////////////////////////////////////////////////////////////////
// animate()
// ------------
//
void DeKoratorButton::animate()
{
    animTmr->stop();

    if ( hover_ )
    {
        if ( KEEPANIMATING )
        {
            animProgress += s;

            if ( animProgress >= ANIMATIONSTEPS || animProgress <= 0 )
            {
                s *= -1;
            }
            animTmr->start( INTERVAL, true ); // single-shot
        }
        else
        {
            if ( !KEEPANIMATING )
            {
                if ( animProgress < ANIMATIONSTEPS )
                    animProgress += STEPS;
                else
                {
                    animProgress = ANIMATIONSTEPS;
                }
            }
            if ( animProgress < ANIMATIONSTEPS )
                animTmr->start( INTERVAL, true ); // single-shot
        }
    }
    else
    {
        if ( animProgress > 0 )
            animProgress -= STEPS;
        else
        {
            animProgress = 0;
        }
        if ( animProgress > 0 )
            animTmr->start( INTERVAL, true ); // single-shot
    }
    //tqWarning( "STEPS: %d", STEPS );
    //tqWarning( "animProgress: %d", animProgress );
    //tqWarning( "INTERVAL: %d", INTERVAL );
    repaint( false );
}










//////////////////////////////////////////////////////////////////////////////
// DeKoratorClient Class                                                      //
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// DeKoratorClient()
// ---------------
// Constructor
DeKoratorClient::DeKoratorClient( KDecorationBridge * b, KDecorationFactory * f )
        : KDecoration( b, f ), mainLayout_( NULL ), titleLayout_( NULL ), midLayout_( NULL ) , leftTitleBarSpacer_( NULL ), titleBarSpacer_( NULL ), rightTitleBarSpacer_( NULL ), leftSpacer_( NULL ), rightSpacer_( NULL ), bottomSpacer_( NULL ), captionBufferDirty_( true )
{
    //captionBufferDirty_ = true;
    //maskDirty_ = true;
    decoFactory_ = ( DeKoratorFactory* ) f;
}

DeKoratorClient::~DeKoratorClient()
{
    for ( int n = 0; n < ButtonTypeCount; n++ )
    {
        if ( button[ n ] )
            delete button[ n ];
    }
}

//////////////////////////////////////////////////////////////////////////////
// init()
// ------
// Actual initializer for class


// basic layout:

//  __________________________________________________________________________
// | leftTitleBarSpacer | btns | titleBarSpacer_ | bts | rightTitleBarSpacer |
// |____________________|______|_________________|_____|_____________________|
// | |                                                                     | |
// | |                         contentsFake                                | |
// | |                                                                     | |
// |leftSpacer                                                    rightSpacer|
// |_|_____________________________________________________________________|_|
// |                                 bottomSpacer                            |
// |_________________________________________________________________________|
//

void DeKoratorClient::init()
{
    createMainWidget( WNoAutoErase );
    widget() ->installEventFilter( this );

    // for flicker-free redraws
    widget() ->setBackgroundMode( NoBackground );

    // layouts
    delete mainLayout_;
    delete titleLayout_;
    delete midLayout_;
    // spacers
    delete leftTitleBarSpacer_;
    delete titleBarSpacer_;
    delete rightTitleBarSpacer_;
    delete leftSpacer_;
    delete rightSpacer_;
    delete bottomSpacer_;
    /*  topLeftCornerBg[ normal ] ->load( decoPixDir + "/topLeftCornerBg.png" );
            leftButtonsBg[ normal ] ->load( decoPixDir + "/leftButtonsBg.png" );
            leftTitleBg[ normal ] ->load( decoPixDir + "/leftTitleBg.png" );
            midTitleBg[ normal ] ->load( decoPixDir + "/midTitleBg.png" );
            rightTitleBg[ normal ] ->load( decoPixDir + "/rightTitleBg.png" );
            rightButtonsBg[ normal ] ->load( decoPixDir + "/rightButtonsBg.png" );
            topRightCornerBg[ normal ] ->load( decoPixDir + "/topRightCornerBg.png" );
            // left frame from top to buttom
            topLeftFrameBg[ normal ] ->load( decoPixDir + "/topLeftFrameBg.png" );
            midLeftFrameBg[ normal ] ->load( decoPixDir + "/midLeftFrameBg.png" );
            buttomLeftFrameBg[ normal ] ->load( decoPixDir + "/bottomLeftFrameBg.png" );
            // buttom frame from left to right
            leftButtomFrameBg[ normal ] ->load( decoPixDir + "/leftBottomFrameBg.png" );
            midButtomFrameBg[ normal ] ->load( decoPixDir + "/midBottomFrameBg.png" );
            rightButtomFrameBg[ normal ] ->load( decoPixDir + "/rightBottomFrameBg.png" );
            // right frame from top to buttom
            topRightFrameBg[ normal ] ->load( decoPixDir + "/topRightFrameBg.png" );
            midRightFrameBg[ normal ] ->load( decoPixDir + "/midRightFrameBg.png" );
            buttomRightFrameBg[ normal ] ->load( decoPixDir + "/bottomRightFrameBg.png" );*/

    // layouts
    mainLayout_ = new TQVBoxLayout( widget(), 0, 0 );
    titleLayout_ = new TQHBoxLayout( mainLayout_, 0, 0 );
    midLayout_ = new TQHBoxLayout( mainLayout_, 0, 0 );

    // spacers
    leftTitleBarSpacer_ = new TQSpacerItem( TOPLEFTCORNERWIDTH, TITLESIZE,
                                           TQSizePolicy::Fixed, TQSizePolicy::Fixed );
    titleBarSpacer_ = new TQSpacerItem( 1, TITLESIZE, TQSizePolicy::Expanding,
                                       TQSizePolicy::Fixed );
    rightTitleBarSpacer_ = new TQSpacerItem( TOPRIGHTCORNERWIDTH, TITLESIZE,
                                            TQSizePolicy::Fixed, TQSizePolicy::Fixed );
    leftSpacer_ = new TQSpacerItem( LEFTFRAMESIZE, 1,
                                   TQSizePolicy::Fixed, TQSizePolicy::Expanding );
    rightSpacer_ = new TQSpacerItem( RIGHTFRAMESIZE, 1,
                                    TQSizePolicy::Fixed, TQSizePolicy::Expanding );
    bottomSpacer_ = new TQSpacerItem( 1, ( !isSetShade() || SHOWBTMBORDER ) ? BUTTOMFRAMESIZE : 0,
                                     TQSizePolicy::Expanding, TQSizePolicy::Fixed );


    // setup layout

    //left spacer
    titleLayout_->addItem( leftTitleBarSpacer_ );
    // setup titlebar buttons
    for ( int n = 0; n < ButtonTypeCount; n++ )
        button[ n ] = 0;
    addButtons( titleLayout_, options() ->titleButtonsLeft(), TRUE );
    titleLayout_->addItem( titleBarSpacer_ );
    addButtons( titleLayout_, options() ->titleButtonsRight(), FALSE );
    //right spacer
    titleLayout_->addItem( rightTitleBarSpacer_ );

    // mid layout
    midLayout_->addItem( leftSpacer_ );
    if ( isPreview() )
    {
        midLayout_->addWidget( new TQLabel( "<center><b>" + i18n( "Dekorator preview (Version 0.3)" ) + "</b></center>", widget() ) );
    }
    else
    {
        midLayout_->addItem( new TQSpacerItem( 0, 0 ) );
    }
    midLayout_->addItem( rightSpacer_ );


    //Bottom
    //if(!isSetShade() || SHOWBTMBORDER)
    mainLayout_->addItem( bottomSpacer_ );

    // connections
    connect( this, TQ_SIGNAL( keepAboveChanged( bool ) ), TQ_SLOT( keepAboveChange( bool ) ) );
    connect( this, TQ_SIGNAL( keepBelowChanged( bool ) ), TQ_SLOT( keepBelowChange( bool ) ) );

    captionBufferDirty_ = true;
    //maskDirty_ = true;
    widget() ->update( titleBarSpacer_->geometry() );
}

//////////////////////////////////////////////////////////////////////////////
// addButtons()
// ------------
// Add buttons to title layout
void DeKoratorClient::addButtons( TQBoxLayout * layout, const TQString & s, bool isLeft )
{
    //const unsigned char * bitmap;
//    TQPixmap * pix1, *pix2, *pix3, *pix4;
    TQString tip;
    buttonTypeAll btnType;

    if ( s.length() > 0 )
    {
        for ( unsigned n = 0; n < s.length(); n++ )
        {
            switch ( s[ n ] )
            {
            case 'M':
                // Menu button
                if ( !button[ ButtonMenu ] )
                {
                    button[ ButtonMenu ] =
                        new DeKoratorButton( isLeft, ( BTNMENUWIDTH < 16 ) ? 16 : BTNMENUWIDTH, BTNMENUHEIGHT, this, "menu", i18n( "Menu" ), ButtonMenu, menu );
                    connect( button[ ButtonMenu ], TQ_SIGNAL( pressed() ),
                             this, TQ_SLOT( menuButtonPressed() ) );
                    connect( button[ ButtonMenu ], TQ_SIGNAL( released() ), this, TQ_SLOT( menuButtonReleased() ) );

                    layout->addWidget( button[ ButtonMenu ] );
                }
                break;

            case 'S':
                // Sticky button
                if ( !button[ ButtonSticky ] )
                {
                    bool d = isOnAllDesktops();
                    if ( d )
                    {
                        btnType = stickydown;
                    }
                    else
                    {
                        //             pix1 = &( decoFactory_->buttonStickyPix_ );
                        //             pix2 = &( decoFactory_->buttonStickyPressPix_ );
                        //             pix3 = &( decoFactory_->buttonStickyHoverPix_ );
                        //             pix4 = &( decoFactory_->buttonStickyDownPixInAct_ );


                        btnType = sticky;
                    }
                    button[ ButtonSticky ] =
                        new DeKoratorButton( isLeft, BTNSTICKYWIDTH, BTNSTICKYHEIGHT, this, "sticky", d ? i18n( "Sticky" ) : i18n( "Un-Sticky" ), ButtonSticky, btnType );
                    connect( button[ ButtonSticky ], TQ_SIGNAL( clicked() ),
                             this, TQ_SLOT( toggleOnAllDesktops() ) );
                    layout->addWidget( button[ ButtonSticky ] );
                }
                break;

            case 'H':
                // Help button
                if ( ( !button[ ButtonHelp ] ) && providesContextHelp() )
                {
                    button[ ButtonHelp ] =
                        new DeKoratorButton( isLeft, BTNHELPEWIDTH, BTNHELPEHEIGHT, this, "help", i18n( "Help" ),
                                             ButtonHelp, help );
                    connect( button[ ButtonHelp ], TQ_SIGNAL( clicked() ),
                             this, TQ_SLOT( showContextHelp() ) );
                    layout->addWidget( button[ ButtonHelp ] );
                }
                break;

            case 'I':
                // Minimize button
                if ( ( !button[ ButtonMin ] ) && isMinimizable() )
                {
                    button[ ButtonMin ] =
                        new DeKoratorButton( isLeft, BTNMINWIDTH, BTNMINHEIGHT, this, "iconify", i18n( "Minimize" ), ButtonMin, min );
                    connect( button[ ButtonMin ], TQ_SIGNAL( clicked() ),
                             this, TQ_SLOT( minimize() ) );
                    layout->addWidget( button[ ButtonMin ] );
                }
                break;

            case 'A':
                // Maximize button
                if ( ( !button[ ButtonMax ] ) && isMaximizable() )
                {
                    bool m = ( maximizeMode() == MaximizeFull );
                    if ( m )
                    {
                        //            pix1 = &( decoFactory_->buttonRestorePix_ );
                        //             pix2 = &( decoFactory_->buttonRestorePressPix_ );
                        //             pix3 = &( decoFactory_->buttonRestoreHoverPix_ );
                        //             pix4 = &( decoFactory_->buttonRestorePixInAct_ );


                        btnType = restore;
                    }
                    else
                    {
                        //             pix1 = &( decoFactory_->buttonMaxPix_ );
                        //             pix2 = &( decoFactory_->buttonMaxPressPix_ );
                        //             pix3 = &( decoFactory_->buttonMaxHoverPix_ );
                        //             pix4 = &( decoFactory_->buttonMaxPixInAct_ );


                        btnType = max;
                    }
                    button[ ButtonMax ] =
                        new DeKoratorButton( isLeft, BTNMAXWIDTH, BTNMAXHEIGHT, this, "maximize", m ? i18n( "Restore" ) : i18n( "Maximize" ),
                                             ButtonMax, btnType );
                    connect( button[ ButtonMax ], TQ_SIGNAL( clicked() ),
                             this, TQ_SLOT( maxButtonPressed() ) );
                    layout->addWidget( button[ ButtonMax ] );
                }
                break;

            case 'X':
                // Close button
                if ( ( !button[ ButtonClose ] ) && isCloseable() )
                {
                    button[ ButtonClose ] =
                        new DeKoratorButton( isLeft, BTNCLOSEWIDTH, BTNCLOSEHEIGHT, this, "close", i18n( "Close" ),
                                             ButtonClose, close );
                    connect( button[ ButtonClose ], TQ_SIGNAL( clicked() ),
                             this, TQ_SLOT( closeWindow() ) );
                    layout->addWidget( button[ ButtonClose ] );
                }
                break;

            case 'F':
                // Above button
                if ( ( !button[ ButtonAbove ] ) )
                {
                    bool a = keepAbove();
                    if ( a )
                    {
                        btnType = abovedown;
                    }
                    else
                    {
                        btnType = above;
                    }
                    //           pix1 = &( decoFactory_->buttonAbovePix_ );
                    button[ ButtonAbove ] =
                        new DeKoratorButton( isLeft, BTNABOVEWIDTH, BTNABOVEHEIGHT, this, "above",
                                             i18n( "Keep Above Others" ), ButtonAbove, btnType );
                    connect( button[ ButtonAbove ], TQ_SIGNAL( clicked() ),
                             this, TQ_SLOT( aboveButtonPressed() ) );
                    layout->addWidget( button[ ButtonAbove ] );
                }
                break;

            case 'B':
                // Below button
                if ( ( !button[ ButtonBelow ] ) )
                {
                    bool b = keepBelow();
                    if ( b )
                    {
                        btnType = belowdown;
                    }
                    else
                    {
                        btnType = below;
                    }
                    //          pix1 = &( decoFactory_->buttonBelowPix_ );
                    button[ ButtonBelow ] =
                        new DeKoratorButton( isLeft, BTNBELOWWIDTH, BTNBELOWHEIGHT, this, "below",
                                             i18n( "Keep Below Others" ), ButtonBelow, btnType );
                    connect( button[ ButtonBelow ], TQ_SIGNAL( clicked() ),
                             this, TQ_SLOT( belowButtonPressed() ) );
                    layout->addWidget( button[ ButtonBelow ] );
                }
                break;

            case 'L':
                // Shade button
                if ( ( !button[ ButtonShade && isShadeable() ] ) )
                {
                    bool s = isSetShade();
                    if ( s )
                    {
                        btnType = shadedown;
                    }
                    else
                    {
                        btnType = shade;
                    }
                    button[ ButtonShade ] =
                        new DeKoratorButton( isLeft, BTNSHADEWIDTH, BTNSHADEHEIGHT, this, "shade", s ? i18n( "Unshade" ) : i18n( "Shade" ),
                                             ButtonShade, btnType );
                    connect( button[ ButtonShade ], TQ_SIGNAL( clicked() ),
                             this, TQ_SLOT( shadeButtonPressed() ) );
                    layout->addWidget( button[ ButtonShade ] );
                }
                break;

            case '_':
                // Spacer item
                layout->addSpacing( 3 );
            }
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
// activeChange()
// --------------
// window active state has changed
void DeKoratorClient::activeChange()
{
    for ( int n = 0; n < ButtonTypeCount; n++ )
        if ( button[ n ] )
            button[ n ] ->reset();
    widget() ->repaint( FALSE );
}

//////////////////////////////////////////////////////////////////////////////
// captionChange()
// ---------------
// The title has changed
void DeKoratorClient::captionChange()
{
    captionBufferDirty_ = true;
    widget() ->repaint( titleBarSpacer_->geometry() );
}

//////////////////////////////////////////////////////////////////////////////
// desktopChange()
// ---------------
// Called when desktop/sticky changes
void DeKoratorClient::desktopChange()
{
    bool d = isOnAllDesktops();
    buttonTypeAll btnType;

    if ( d )
    {
        btnType = stickydown;
    }
    else
    {
        btnType = sticky;
    }
    if ( button[ ButtonSticky ] )
    {
        button[ ButtonSticky ] ->setPixmap( btnType );
        TQToolTip::remove
            ( button[ ButtonSticky ] );
        TQToolTip::add
            ( button[ ButtonSticky ], d ? i18n( "Sticky" ) : i18n( "Un-Sticky" ) );
    }
}

//////////////////////////////////////////////////////////////////////////////
// iconChange()
// ------------
// The title has changed
void DeKoratorClient::iconChange()
{
    if ( !USEMENUEIMAGE && button[ ButtonMenu ] )
    {
        //button[ ButtonMenu ] ->setPixmap( 0 );
        button[ ButtonMenu ] ->repaint( FALSE );
    }
}

//////////////////////////////////////////////////////////////////////////////
// maximizeChange()
// ----------------
// Maximized state has changed
void DeKoratorClient::maximizeChange()
{
    bool m = ( maximizeMode() == MaximizeFull );
    buttonTypeAll btnType;

    if ( m )
    {
        btnType = restore;
    }
    else
    {
        btnType = max;
    }
    if ( button[ ButtonMax ] )
    {
        button[ ButtonMax ] ->setPixmap( btnType );
        TQToolTip::remove
            ( button[ ButtonMax ] );
        TQToolTip::add
            ( button[ ButtonMax ], m ? i18n( "Restore" ) : i18n( "Maximize" ) );
    }
}

//////////////////////////////////////////////////////////////////////////////
// shadeChange()
// -------------
// Called when window shading changes
void DeKoratorClient::shadeChange()
{
    bool s = isSetShade();
    buttonTypeAll btnType;

    if ( s )
    {
        btnType = shadedown;
    }
    else
    {
        btnType = shade;
    }
    if ( button[ ButtonShade ] )
    {
        button[ ButtonShade ] ->setPixmap( btnType );
        TQToolTip::remove
            ( button[ ButtonShade ] );
        TQToolTip::add
            ( button[ ButtonShade ], s ? i18n( "Unshade" ) : i18n( "Shade" ) );
    }

    //mainlayout_->setRowSpacing( 3, isSetShade() ? 0 : MARGIN );
    for ( int n = 0; n < ButtonTypeCount; n++ )
        if ( button[ n ] )
            button[ n ] ->reset();
    widget() ->repaint( FALSE );

    //mainlayout_->setRowSpacing( 3, isSetShade() ? 0 : MARGIN );
    //     if ( DeKoratorFactory::useMasks_ )
    //         doShape();
}

//////////////////////////////////////////////////////////////////////////////
// keepAboveChange()
// ------------
// The above state has changed
void DeKoratorClient::keepAboveChange( bool a )
{
    buttonTypeAll btnType;

    if ( a )
    {
        btnType = abovedown;
    }
    else
    {
        btnType = above;
    }
    if ( button[ ButtonAbove ] )
    {
        button[ ButtonAbove ] ->setPixmap( btnType );
    }
}

//////////////////////////////////////////////////////////////////////////////
// keepBelowChange()
// ------------
// The below state has changed
void DeKoratorClient::keepBelowChange( bool b )
{
    buttonTypeAll btnType;

    if ( b )
    {
        btnType = belowdown;
    }
    else
    {
        btnType = below;
    }
    if ( button[ ButtonBelow ] )
    {
        button[ ButtonBelow ] ->setPixmap( btnType );
    }
}

//////////////////////////////////////////////////////////////////////////////
// borders()
// ----------
// Get the size of the borders
void DeKoratorClient::borders( int & l, int & r, int & t, int & b ) const
{
    l = LEFTFRAMESIZE;
    r = RIGHTFRAMESIZE;
    t = TITLESIZE ;
    //     if ( SHOWBTMBORDER )
    //b = 10;
    //     else
    //         b = isShade() ? 0 : BUTTOMFRAMESIZE;
    //b = SHOWBTMBORDER ? BUTTOMFRAMESIZE : isShade() ? 1 : BUTTOMFRAMESIZE;
    if ( !isShade() || SHOWBTMBORDER )
    {
        b = BUTTOMFRAMESIZE;
        bottomSpacer_->changeSize( 1, BUTTOMFRAMESIZE, TQSizePolicy::Expanding, TQSizePolicy::Fixed );
    }
    else
    {
        b = 0;
        bottomSpacer_->changeSize( 1, b, TQSizePolicy::Expanding, TQSizePolicy::Fixed );
    }
    widget() ->layout() ->activate();
}

//////////////////////////////////////////////////////////////////////////////
// resize()
// --------
// Called to resize the window
void DeKoratorClient::resize( const TQSize & size )
{
    widget() ->resize( size );
}

//////////////////////////////////////////////////////////////////////////////
// minimumSize()
// -------------
// Return the minimum allowable size for this window
TQSize DeKoratorClient::minimumSize() const
{
    TQSize size = widget() ->minimumSize();
    size.setWidth( size.width() + TOPLEFTCORNERWIDTH + TOPRIGHTCORNERWIDTH );

    return size;

}

//////////////////////////////////////////////////////////////////////////////
// mousePosition()
// ---------------
// Return logical mouse position
KDecoration::Position DeKoratorClient::mousePosition( const TQPoint & point ) const
{
    //    bool res = TRUE;
    Position pos;
    if ( isShade() )
    {
        return PositionCenter;
    }

    if ( point.y() <= 5 )
    {
        // inside top frame
        if ( point.x() <= LEFTFRAMESIZE )
            pos = PositionTopLeft;
        else if ( point.x() >= ( width() - RIGHTFRAMESIZE ) )
            pos = PositionTopRight;
        else
            pos = PositionTop;
    }
    else if ( point.y() >= ( height() - BUTTOMFRAMESIZE ) )
    {
        // inside handle
        if ( point.x() <= LEFTFRAMESIZE )
            pos = PositionBottomLeft;
        else if ( point.x() >= ( width() - RIGHTFRAMESIZE ) )
            pos = PositionBottomRight;
        else
            pos = PositionBottom;
    }
    else if ( point.x() <= LEFTFRAMESIZE )
    {
        // on left frame
        if ( point.y() <= TITLESIZE )
            pos = PositionTopLeft;
        else if ( point.y() >= ( height() - BUTTOMFRAMESIZE ) )
            pos = PositionBottomLeft;
        else
            pos = PositionLeft;
    }
    else if ( point.x() >= width() - RIGHTFRAMESIZE )
    {
        // on right frame
        if ( point.y() <= TITLESIZE )
            pos = PositionTopRight;
        else if ( point.y() >= ( height() - BUTTOMFRAMESIZE ) )
            pos = PositionBottomRight;
        else
            pos = PositionRight;
    }
    else
    {
        // inside the frame
        pos = PositionCenter;
    }
    return pos;

    //     const int corner = 24;
    //     Position pos;
    //
    //     if (point.y() <= MARGIN) {
    //         // inside top frame
    //         if (point.x() <= corner)                 pos = PositionTopLeft;
    //         else if (point.x() >= (width()-corner))  pos = PositionTopRight;
    //         else                                     pos = PositionTop;
    //     } else if (point.y() >= (height()-MARGIN*2)) {
    //         // inside handle
    //         if (point.x() <= corner)                 pos = PositionBottomLeft;
    //         else if (point.x() >= (width()-corner))  pos = PositionBottomRight;
    //         else                                     pos = PositionBottom;
    //     } else if (point.x() <= MARGIN) {
    //         // on left frame
    //         if (point.y() <= corner)                 pos = PositionTopLeft;
    //         else if (point.y() >= (height()-corner)) pos = PositionBottomLeft;
    //         else                                     pos = PositionLeft;
    //     } else if (point.x() >= width()-MARGIN) {
    //         // on right frame
    //         if (point.y() <= corner)                 pos = PositionTopRight;
    //         else if (point.y() >= (height()-corner)) pos = PositionBottomRight;
    //         else                                     pos = PositionRight;
    //     } else {
    //         // inside the frame
    //         pos = PositionCenter;
    //     }
    //     return pos;

}


//////////////////////////////////////////////////////////////////////////////
// eventFilter()
// -------------
// Event filter
bool DeKoratorClient::eventFilter( TQObject * obj, TQEvent * e )
{
    if ( obj != widget() )
        return FALSE;

    switch ( e->type() )
    {

    case TQEvent::MouseButtonDblClick:
        {
            mouseDoubleClickEvent( static_cast<TQMouseEvent *>( e ) );
            return TRUE;
        }
    case TQEvent::Wheel:
        {
            wheelEvent( static_cast<TQWheelEvent *>( e ) );
            return TRUE;
        }
    case TQEvent::MouseButtonPress:
        {
            processMousePressEvent( static_cast<TQMouseEvent *>( e ) );
            if ( USEMASKS )
                doShape();
            return TRUE;
        }
    case TQEvent::Paint:
        {
            paintEvent( static_cast<TQPaintEvent *>( e ) );
            return TRUE;
        }
    case TQEvent::Resize:
        {
            resizeEvent( static_cast<TQResizeEvent *>( e ) );
            return TRUE;
        }
    case TQEvent::Show:
        {
            showEvent( static_cast<TQShowEvent *>( e ) );
            return TRUE;
        }
    default:
        {
            return FALSE;
        }
    }

    return FALSE;
}

//////////////////////////////////////////////////////////////////////////////
// mouseDoubleClickEvent()
// -----------------------
// Doubleclick on title
void DeKoratorClient::mouseDoubleClickEvent( TQMouseEvent * e )
{
    if ( titleBarSpacer_->geometry().contains( e->pos() ) )
        titlebarDblClickOperation();
}

//////////////////////////////////////////////////////////////////////////////
// wheelEvent()
// -----------------------
//
void DeKoratorClient::wheelEvent( TQWheelEvent *e )
{
    if ( titleLayout_->geometry().contains( e->pos() ) )
        titlebarMouseWheelOperation( e->delta() );
}


//////////////////////////////////////////////////////////////////////////////
// paintEvent()
// ------------
// Repaint the window
void DeKoratorClient::paintEvent( TQPaintEvent* )
{
    if ( !DeKoratorFactory::initialized() )
        return ;
    if ( TITLESIZE )
    {
        if ( captionBufferDirty_ && USESHDTEXT )
            updateCaptionBuffer();

        TQPainter painter( widget() );
        int tx, ty, tw, th;
        int w = width() , h = height();
        TQRect titleR( titleBarSpacer_->geometry() );
        TQRect leftTitleR( leftTitleBarSpacer_->geometry() );
        TQRect rightTitleR( rightTitleBarSpacer_->geometry() );
        titleR.rect( &tx, &ty, &tw, &th );
        TQRect rect;

        TQPainter painter2;
        TQPixmap pix( w, TITLESIZE );
        painter2.begin( &pix );
        {
            // topLeftCorner

            rect.setRect( 0, 0, TOPLEFTCORNERWIDTH, TITLESIZE );
            painter2.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ topLeftCorner ] ) : *( DECOPIXINACTARR[ topLeftCorner ] ) );

            //         rect.setRect( 0, 0, TOPLEFTCORNERWIDTH, TITLESIZE );
            //         painter2.drawTiledPixmap( rect, isActive() ? decoFactory_->topLeftCornerBg_ : decoFactory_->topLeftCornerBgInAct_ );

            // Space under the left button group
            painter2.drawTiledPixmap( leftTitleR.right() + 1, titleR.top(),
                                      ( titleR.left() - 1 ) - leftTitleR.right(), titleR.height(), isActive() ? *( DECOPIXACTARR[ leftButtons ] ) : *( DECOPIXINACTARR[ leftButtons ] ) );

            if ( tw > 0 )
            {
                //tqWarning("%d",titleR.width());

                //leftTitleR
                rect.setRect( tx, 0, TQMIN( LEFTTITLEWIDTH, tw ), TITLESIZE );

                painter2.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ leftTitle ] ) : *( DECOPIXINACTARR[ leftTitle ] ) );

                //             rect.setRect( tx, 0, TQMIN( LEFTTITLEWIDTH, tw ), TITLESIZE );
                //             painter2.drawTiledPixmap( rect, isActive() ? decoFactory_->leftTitleBg_ : decoFactory_->leftTitleBgInAct_ );

                //midTitle
                if ( tw > LEFTTITLEWIDTH + RIGHTTITLEWIDTH )
                {
                    rect.setRect( tx + LEFTTITLEWIDTH, 0, tw - ( RIGHTTITLEWIDTH + LEFTTITLEWIDTH ), th );

                    painter2.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ midTitle ] ) : *( DECOPIXINACTARR[ midTitle ] ) );

                    //                 painter2.drawTiledPixmap( rect, isActive() ? decoFactory_->midTitleBg_ : decoFactory_->midTitleBgInAct_ );
                }

                //rightTitleR
                if ( tw > LEFTTITLEWIDTH )
                {
                    rect.setRect( TQMAX( tx + tw - RIGHTTITLEWIDTH, tx + LEFTTITLEWIDTH ), 0, TQMIN( RIGHTTITLEWIDTH, tw - LEFTTITLEWIDTH ), th );

                    painter2.drawTiledPixmap( rect.x(), rect.y(), rect.width(), rect.height(), isActive() ? *( DECOPIXACTARR[ rightTitle ] ) : *( DECOPIXINACTARR[ rightTitle ] ), ( tw > LEFTTITLEWIDTH + RIGHTTITLEWIDTH ) ? 0 : LEFTTITLEWIDTH - ( tw - RIGHTTITLEWIDTH ), 0 );

                    //                 painter2.drawTiledPixmap( rect.x(), rect.y(), rect.width(), rect.height(), isActive() ? decoFactory_->rightTitleBg_ : decoFactory_->rightTitleBgInAct_, ( tw > LEFTTITLEWIDTH + RIGHTTITLEWIDTH ) ? 0 : LEFTTITLEWIDTH - ( tw - RIGHTTITLEWIDTH ), 0 );
                }
            }

            // Space under the right button group
            painter2.drawTiledPixmap( titleR.right() + 1, titleR.top(),
                                      ( rightTitleR.left() - 1 ) - titleR.right(), titleR.height(), isActive() ? *( DECOPIXACTARR[ rightButtons ] ) : *( DECOPIXINACTARR[ rightButtons ] ) );


            //topRightCorner
            rect.setRect( widget() ->width() - TOPRIGHTCORNERWIDTH, 0, TOPRIGHTCORNERWIDTH, TITLESIZE );

            painter2.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ topRightCorner ] ) : *( DECOPIXINACTARR[ topRightCorner ] ) );

            // painter2.drawTiledPixmap( rect, isActive() ? decoFactory_->topRightCornerBg_ : decoFactory_->topRightCornerBgInAct_ );


            TQString c( caption() );
            TQFontMetrics fm( options() ->font( isActive() ) );
            int captionWidth = fm.width( c );
            // shadow text effect
            if ( USESHDTEXT )
            {

                int captionHeight = fm.height( );
                int dx = 0, dy = 0;

                if ( TITLEALIGN == TQt::AlignLeft || captionWidth > titleR.width() )
                {
                    dx = tx + 1 + ( isActive() ? ACTIVESHDTEXTX : INACTIVESHDTEXTX ) ;
                    dy = ( TITLESIZE / 2 ) - ( captionHeight / 2 ) + ( isActive() ? ACTIVESHDTEXTY : INACTIVESHDTEXTY ) ;
                }
                else if ( TITLEALIGN == TQt::AlignHCenter )
                {
                    dx = tx + ( tw / 2 ) - ( ( captionWidth + ( MARGIN * 2 ) ) / 2 ) + ( isActive() ? ACTIVESHDTEXTX : INACTIVESHDTEXTX ) ;
                    dy = ( TITLESIZE / 2 ) - ( captionHeight / 2 ) + ( isActive() ? ACTIVESHDTEXTY : INACTIVESHDTEXTY ) ;
                }
                else if ( TITLEALIGN == TQt::AlignRight )
                {
                    dx = tx + tw - ( captionWidth + ( MARGIN * 2 ) ) - 1 + ( isActive() ? ACTIVESHDTEXTX : INACTIVESHDTEXTX ) ;
                    dy = ( TITLESIZE / 2 ) - ( captionHeight / 2 ) + ( isActive() ? ACTIVESHDTEXTY : INACTIVESHDTEXTY ) ;
                }

                painter2.drawImage( dx, dy, isActive() ? activeShadowImg_ : inActiveShadowImg_, 0, 0, isActive() ? TQMIN( activeShadowImg_.width(), titleR.width() ) : TQMIN( inActiveShadowImg_.width(), titleR.width() ), isActive() ? activeShadowImg_.height() : inActiveShadowImg_.height() );
            }


            //draw titleR text
            painter2.setFont( options() ->font( isActive(), FALSE ) );
            painter2.setPen( options() ->color( KDecoration::ColorFont, isActive() ) );

            TQt::AlignmentFlags titleAlignBak = TITLEALIGN;
            if ( captionWidth > titleR.width() )
                titleAlignBak = TQt::AlignLeft;

            painter2.drawText( tx + MARGIN, ty, tw - ( MARGIN * 2 ), th, titleAlignBak | AlignVCenter, caption() );
        }
        painter2.end();
        painter.drawPixmap( 0, 0, pix );


        // draw frames
        if ( ! isShade() || SHOWBTMBORDER )
        {

            if ( h - TITLESIZE - BUTTOMFRAMESIZE > 0 )
            {
                int leftRightFramesHeight = h - TITLESIZE - BUTTOMFRAMESIZE ;

                //left frame
                //top
                rect.setRect( 0, TITLESIZE , LEFTFRAMESIZE, TQMIN( TOPLEFTFRAMEHEIGHT, leftRightFramesHeight ) );

                painter.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ topLeftFrame ] ) : *( DECOPIXINACTARR[ topLeftFrame ] ) );

                // mid
                if ( leftRightFramesHeight > TOPLEFTFRAMEHEIGHT + BOTTOMLEFTFRAMEHEIGHT )
                {
                    rect.setRect( 0, TITLESIZE + TOPLEFTFRAMEHEIGHT , LEFTFRAMESIZE, leftRightFramesHeight - TOPLEFTFRAMEHEIGHT - BOTTOMLEFTFRAMEHEIGHT );

                    painter.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ midLeftFrame ] ) : *( DECOPIXINACTARR[ midLeftFrame ] ) );

                    //                 painter.drawTiledPixmap( rect, isActive() ? decoFactory_->midLeftFrameBg_ : decoFactory_->midLeftFrameBgInAct_ );
                }

                // buttom
                if ( leftRightFramesHeight > TOPLEFTFRAMEHEIGHT )
                {
                    rect.setRect( 0, TQMAX( h - BUTTOMFRAMESIZE - BOTTOMLEFTFRAMEHEIGHT, TITLESIZE + TOPLEFTFRAMEHEIGHT ) , LEFTFRAMESIZE, TQMIN( BOTTOMLEFTFRAMEHEIGHT, leftRightFramesHeight - TOPLEFTFRAMEHEIGHT ) );

                    painter.drawTiledPixmap( rect.x(), rect.y(), rect.width(), rect.height(), isActive() ? *( DECOPIXACTARR[ buttomLeftFrame ] ) : *( DECOPIXINACTARR[ buttomLeftFrame ] ), 0, ( leftRightFramesHeight > TOPLEFTFRAMEHEIGHT + BOTTOMLEFTFRAMEHEIGHT ) ? 0 : TITLESIZE + TOPLEFTFRAMEHEIGHT - ( h - BUTTOMFRAMESIZE - BOTTOMLEFTFRAMEHEIGHT ) );

                    //                 painter.drawTiledPixmap( rect.x(), rect.y(), rect.width(), rect.height(), isActive() ? decoFactory_->buttomLeftFrameBg_ : decoFactory_->buttomLeftFrameBgInAct_, 0, ( leftRightFramesHeight > TOPLEFTFRAMEHEIGHT + BOTTOMLEFTFRAMEHEIGHT ) ? 0 : TITLESIZE + TOPLEFTFRAMEHEIGHT - ( h - BUTTOMFRAMESIZE - BOTTOMLEFTFRAMEHEIGHT ) );
                }


                //rightFrame
                // top
                rect.setRect( w - RIGHTFRAMESIZE, TITLESIZE , RIGHTFRAMESIZE, TQMIN( TOPRIGHTFRAMEHEIGHT, leftRightFramesHeight ) );

                painter.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ topRightFrame ] ) : *( DECOPIXINACTARR[ topRightFrame ] ) );

                //             painter.drawTiledPixmap( rect, isActive() ? decoFactory_->topRightFrameBg_ : decoFactory_->topRightFrameBgInAct_ );

                // mid
                if ( leftRightFramesHeight > TOPRIGHTFRAMEHEIGHT + BOTTOMRIGHTFRAMEHEIGHT )
                {
                    rect.setRect( w - RIGHTFRAMESIZE, TITLESIZE + TOPRIGHTFRAMEHEIGHT, RIGHTFRAMESIZE, leftRightFramesHeight - TOPRIGHTFRAMEHEIGHT - BOTTOMRIGHTFRAMEHEIGHT );

                    painter.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ midRightFrame ] ) : *( DECOPIXINACTARR[ midRightFrame ] ) );

                    //                 painter.drawTiledPixmap( rect, isActive() ? decoFactory_->midRightFrameBg_ : decoFactory_->rightFrameBgInAct_ );
                }

                // bottom
                if ( leftRightFramesHeight > TOPRIGHTFRAMEHEIGHT )
                {
                    rect.setRect( w - RIGHTFRAMESIZE, TQMAX( h - BUTTOMFRAMESIZE - BOTTOMRIGHTFRAMEHEIGHT, TITLESIZE + TOPRIGHTFRAMEHEIGHT ) , RIGHTFRAMESIZE, TQMIN( BOTTOMRIGHTFRAMEHEIGHT, leftRightFramesHeight - TOPRIGHTFRAMEHEIGHT ) );

                    painter.drawTiledPixmap( rect.x(), rect.y(), rect.width(), rect.height(), isActive() ? *( DECOPIXACTARR[ buttomRightFrame ] ) : *( DECOPIXINACTARR[ buttomRightFrame ] ), 0, ( leftRightFramesHeight > TOPRIGHTFRAMEHEIGHT + BOTTOMRIGHTFRAMEHEIGHT ) ? 0 : TITLESIZE + TOPRIGHTFRAMEHEIGHT - ( h - BUTTOMFRAMESIZE - BOTTOMRIGHTFRAMEHEIGHT ) );

                    //                 painter.drawTiledPixmap( rect.x(), rect.y(), rect.width(), rect.height(), isActive() ? decoFactory_->buttomRightFrameBg_ : decoFactory_->buttomRightFrameBgInAct_, 0, ( leftRightFramesHeight > TOPRIGHTFRAMEHEIGHT + BOTTOMRIGHTFRAMEHEIGHT ) ? 0 : TITLESIZE + TOPRIGHTFRAMEHEIGHT - ( h - BUTTOMFRAMESIZE - BOTTOMRIGHTFRAMEHEIGHT ) );
                }
            }


            // buttom frame
            if ( w > 0 )
            {            // left
                rect.setRect( 0 , h - BUTTOMFRAMESIZE, TQMIN( LEFTBOTTOMFRAMEWIDTH, w ) , BUTTOMFRAMESIZE );

                painter.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ leftButtomFrame ] ) : *( DECOPIXINACTARR[ leftButtomFrame ] ) );

                // mid
                if ( w > LEFTBOTTOMFRAMEWIDTH + RIGHTBOTTOMFRAMEWIDTH )
                {
                    rect.setRect( LEFTBOTTOMFRAMEWIDTH , h - BUTTOMFRAMESIZE, w - LEFTBOTTOMFRAMEWIDTH - RIGHTBOTTOMFRAMEWIDTH, BUTTOMFRAMESIZE );

                    painter.drawTiledPixmap( rect, isActive() ? *( DECOPIXACTARR[ midButtomFrame ] ) : *( DECOPIXINACTARR[ midButtomFrame ] ) );

                    //                 painter.drawTiledPixmap( rect, isActive() ? decoFactory_->midButtomFrameBg_ : decoFactory_->midButtomFrameBgInAct_ );
                }

                // right
                if ( w > LEFTBOTTOMFRAMEWIDTH )
                {
                    rect.setRect( TQMAX( w - RIGHTBOTTOMFRAMEWIDTH, LEFTBOTTOMFRAMEWIDTH ) , h - BUTTOMFRAMESIZE, TQMIN( RIGHTBOTTOMFRAMEWIDTH, w - LEFTBOTTOMFRAMEWIDTH ) , BUTTOMFRAMESIZE );

                    painter.drawTiledPixmap( rect.x(), rect.y(), rect.width(), rect.height(), isActive() ? *( DECOPIXACTARR[ rightButtomFrame ] ) : *( DECOPIXINACTARR[ rightButtomFrame ] ), ( w > LEFTBOTTOMFRAMEWIDTH + RIGHTBOTTOMFRAMEWIDTH ) ? 0 : LEFTBOTTOMFRAMEWIDTH - ( w - RIGHTBOTTOMFRAMEWIDTH ), 0 );

                    //                 painter.drawTiledPixmap( rect.x(), rect.y(), rect.width(), rect.height(), isActive() ? decoFactory_->rightButtomFrameBg_ : decoFactory_->rightButtomFrameBgInAct_, ( w > LEFTBOTTOMFRAMEWIDTH + RIGHTBOTTOMFRAMEWIDTH ) ? 0 : LEFTBOTTOMFRAMEWIDTH - ( w - RIGHTBOTTOMFRAMEWIDTH ), 0 );
                }
            }
        }
        else
        {
            painter.setPen( TQColor( 70, 70, 70 ) );
            painter.drawLine( 0 , h - 1, w, h - 1 );
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
// update_captionBuffer()
// ------------
//
void DeKoratorClient::updateCaptionBuffer()
{
    if ( !DeKoratorFactory::initialized() )
        return ;

    TQPainter painter;
    TQString c( caption() );
    TQFontMetrics fm( options() ->font( isActive() ) );
    int captionWidth = fm.width( c );
    int captionHeight = fm.height( );
    TQPixmap textPixmap;

    // prepare the shadow
    textPixmap = TQPixmap( captionWidth + ( MARGIN * 2 ) , captionHeight ); // 2*2 px shadow space
    textPixmap.fill( TQColor( 0, 0, 0 ) );
    textPixmap.setMask( textPixmap.createHeuristicMask( TRUE ) );
    painter.begin( &textPixmap );
    painter.setFont( options() ->font( isActive(), FALSE ) );
    painter.setPen( white );
    painter.drawText( textPixmap.rect(), AlignCenter, caption() );
    painter.end();


    ShadowEngine se;
    //if ( isActive() )
    activeShadowImg_ = se.makeShadow( textPixmap, ACTIVESHADECOLOR );
    //else
    inActiveShadowImg_ = se.makeShadow( textPixmap, INACTIVESHADECOLOR );

    captionBufferDirty_ = false;
}

//////////////////////////////////////////////////////////////////////////////
// resizeEvent()
// -------------
// Window is being resized
void DeKoratorClient::resizeEvent( TQResizeEvent *e )
{
    if ( widget() ->isShown() )
    {
        TQRegion region = widget() ->rect();
        region = region.subtract( titleBarSpacer_->geometry() );
        widget() ->erase( region );
    }
    if ( USEMASKS )
    {

        if ( oldSize_ != e->size() )
        {
            //tqWarning("TQResizeEvent");
            sizeChanged = true;
        }
        else
            sizeChanged = false;

        oldSize_ = e->size();

        // 		if(e->type() == TQEvent::Resize)
        // 		{
        //
        // 			//oldSize((TQResizeEvent*)e)->size());
        // 			tqWarning( "resizeEvent" );
        // 		}

        //        maskDirty_ = true;
        doShape();
    }
}

//////////////////////////////////////////////////////////////////////////////
// showEvent()
// -----------
// Window is being shown
void DeKoratorClient::showEvent( TQShowEvent * )
{
    widget() ->repaint();
    if ( USEMASKS )
        doShape();
}

//////////////////////////////////////////////////////////////////////////////
// maxButtonPressed()
// -----------------
// Max button was pressed
void DeKoratorClient::maxButtonPressed()
{
    if ( button[ ButtonMax ] )
    {
#if KDE_IS_VERSION(3, 3, 0)
        maximize( button[ ButtonMax ] ->lastMousePress() );
#else

        switch ( button[ ButtonMax ] ->lastMousePress() )
        {
        case MidButton:
            maximize( maximizeMode() ^ MaximizeVertical );
            break;
        case RightButton:
            maximize( maximizeMode() ^ MaximizeHorizontal );
            break;
        default:
            ( maximizeMode() == MaximizeFull ) ? maximize( MaximizeRestore )
            : maximize( MaximizeFull );
        }
#endif

    }
}

//////////////////////////////////////////////////////////////////////////////
// shadeButtonPressed()
// -----------------
// Shade button was pressed
void DeKoratorClient::shadeButtonPressed()
{
    if ( button[ ButtonShade ] )
    {
        setShade( !isSetShade() );
    }
}

//////////////////////////////////////////////////////////////////////////////
// aboveButtonPressed()
// -----------------
// Above button was pressed
void DeKoratorClient::aboveButtonPressed()
{
    if ( button[ ButtonAbove ] )
    {
        setKeepAbove( !keepAbove() );
    }
}

//////////////////////////////////////////////////////////////////////////////
// belowButtonPressed()
// -----------------
// Below buttTQt::green; //on was pressed
void DeKoratorClient::belowButtonPressed()
{
    if ( button[ ButtonBelow ] )
    {
        setKeepBelow( !keepBelow() );
    }
}

//////////////////////////////////////////////////////////////////////////////
// menuButtonPressed()
// -------------------
// Menu button was pressed (popup the menu)
void DeKoratorClient::menuButtonPressed()
{
    //     if ( button[ ButtonMenu ] )
    //     {
    //         TQPoint p( button[ ButtonMenu ] ->rect().bottomLeft().x(),
    //                   button[ ButtonMenu ] ->rect().bottomLeft().y() );
    //         KDecorationFactory* f = factory();
    //         showWindowMenu( button[ ButtonMenu ] ->mapToGlobal( p ) );
    //         if ( !f->exists( this ) ) return ; // decoration was destroyed
    //         button[ ButtonMenu ] ->setDown( FALSE );
    //     }

    static TQTime * t = NULL;
    static DeKoratorClient* lastClient = NULL;
    if ( t == NULL )
        t = new TQTime;
    bool dbl = ( lastClient == this && t->elapsed() <= TQApplication::doubleClickInterval() );
    lastClient = this;
    t->start();
    if ( !dbl || !DBLCLKCLOSE )
    {
        TQPoint p( button[ ButtonMenu ] ->rect().bottomLeft().x(),
                  button[ ButtonMenu ] ->rect().bottomLeft().y() );
        KDecorationFactory* f = factory();
        showWindowMenu( button[ ButtonMenu ] ->mapToGlobal( p ) );
        if ( !f->exists( this ) )
            return ; // decoration was destroyed
        button[ ButtonMenu ] ->setDown( FALSE );
    }
    else
        closing_ = true;
}

//////////////////////////////////////////////////////////////////////////////
// menuButtonReleased()
// -------------------
//
void DeKoratorClient::menuButtonReleased()
{
    if ( closing_ )
        closeWindow();
}

//////////////////////////////////////////////////////////////////////////////
// doShape()
// -------------------
//
void DeKoratorClient::doShape()
{
    int w = width();
    int h = height();
    TQRegion mask( 0, 0, w, h );

    if ( sizeChanged )
    {
        //tqWarning("doShape");

        // top left
        TQRegion mtr;
        TQRegion m = TQRegion( decoFactory_->topLeftCornerBitmap_ );
        mask -= TQRegion( m );


        // top mid
        if ( TOPMIDMASKWIDTH >= 1 )
        {
            int pos = TOPLEFTMASKWIDTH;
            int rep = ( w - TOPLEFTMASKWIDTH - TOPRIGHTMASKWIDTH ) / TOPMIDMASKWIDTH;
            m = TQRegion( decoFactory_->topMidBitmap_ );
            TQRegion mBak = m;

            for ( int i = 0 ; i < rep ; i++ )
            {
                m = mBak;
                m.translate( TOPLEFTMASKWIDTH + ( i * TOPMIDMASKWIDTH ), 0 );
                mask -= TQRegion( m );
                pos += TOPMIDMASKWIDTH;
            }

            m = mBak;
            mtr = mBak;
            mtr.translate( w - pos - TOPRIGHTMASKWIDTH, 0 );
            m -= mtr;
            m.translate( pos, 0 );
            mask -= m;
        }

        {
            //top right
            m = TQRegion( decoFactory_->topRightCornerBitmap_ );
            m.translate( width() - TOPRIGHTMASKWIDTH, 0 );
            mask -= TQRegion( m );
        }


        if ( !isShade() || SHOWBTMBORDER )
        {
            //buttom left
            m = TQRegion( decoFactory_->buttomLeftCornerBitmap_ );
            m.translate( 0, h - BOTTOMLEFTMASKHEIGHT );
            mask -= TQRegion( m );

            // bottom mid
            if ( BOTTOMMIDMASKWIDTH >= 1 )
            {
                int pos = BOTTOMLEFTMASKWIDTH;
                int rep = ( w - BOTTOMLEFTMASKWIDTH - BOTTOMRIGHTMASKWIDTH ) / BOTTOMMIDMASKWIDTH;
                int hm = h - BOTTOMMIDMASKHEIGHT;
                m = TQRegion( decoFactory_->buttomMidBitmap_ );
                TQRegion mBak = m;

                for ( int i = 0 ; i < rep ; i++ )
                {
                    m = mBak;
                    m.translate( BOTTOMLEFTMASKWIDTH + ( i * BOTTOMMIDMASKWIDTH ), hm );
                    mask -= TQRegion( m );
                    pos += BOTTOMMIDMASKWIDTH;
                }

                m = mBak;
                mtr = mBak;
                mtr.translate( w - pos - BOTTOMRIGHTMASKWIDTH, 0 );
                m -= mtr;
                m.translate( pos, hm );
                mask -= m;
            }

            //buttom right
            m = TQRegion( decoFactory_->buttomRightCornerBitmap_ );
            m.translate( width() - BOTTOMRIGHTMASKWIDTH, h - BOTTOMRIGHTMASKHEIGHT );
            mask -= TQRegion( m );
        }
        mask_ = mask;
    }

    setMask( mask_ );
}


#include "deKoratorclient.moc"