tde-style-polyester/client/polyester.cpp

//////////////////////////////////////////////////////////////////////////////
// polyester.cc
// -------------------
// Polyester window decoration for KDE
// Copyright (c) 2006 Marco Martin
// -------------------
// derived from Smooth Blend
// Copyright (c) 2005 Ryan Nickell
// -------------------
// Shadow engine from Plastik decoration
// Copyright (C) 2003 Sandro Giessl <ceebx@users.sourceforge.net>
// -------------------
// Please see the header file for copyright and license information.
//////////////////////////////////////////////////////////////////////////////


#include <tdeconfig.h>
#include <tdeversion.h>
#include <tdeglobal.h>
#include <tdeglobalsettings.h>
#include <tdelocale.h>
#include <kpixmap.h>
#include <kimageeffect.h>
#include <kpixmapeffect.h>
#include <kpixmap.h>

#include <tqbitmap.h>
#include <tqlabel.h>
#include <tqlayout.h>
#include <tqpainter.h>
#include <tqtooltip.h>
#include <tqtimer.h>
#include <tqapplication.h>
#include <tqsettings.h>
#include <math.h>
#include <stdlib.h>

#include "polyester.h"
#include "buttons.h"
#include "shadow.h"
#include "../style/misc.h"

using namespace polyester;

//////////////////////////////////////////////////////////////////////////////
// polyesterFactory Class
//////////////////////////////////////////////////////////////////////////////
polyesterFactory* factory=NULL;

bool polyesterFactory::initialized_              = false;
TQt::AlignmentFlags polyesterFactory::titlealign_ = TQt::AlignHCenter;
int polyesterFactory::contrast_                  = 6;
bool polyesterFactory::cornerflags_              = true;
int polyesterFactory::titlesize_                 = 22;
int polyesterFactory::buttonsize_                = 18;
bool polyesterFactory::squareButton_             = false;
int polyesterFactory::framesize_                 = 2;
int polyesterFactory::roundsize_                 = 50;
int polyesterFactory::titleBarStyle_             = 0;
int polyesterFactory::buttonStyle_               = 1;
bool polyesterFactory::titleshadow_              = true;
bool polyesterFactory::nomodalbuttons            = false;
bool polyesterFactory::lightBorder_              = true;
bool polyesterFactory::animatebuttons            = true;
int polyesterFactory::btnComboBox                = 0;
bool polyesterFactory::menuClose                 = false;

// global constants
static const int TOPMARGIN       = 4; // do not change
static const int DECOHEIGHT      = 4; // do not change
static const int SIDETITLEMARGIN = 2;
// Default button layout
const char default_left[]  = "M";
const char default_right[] = "HIAX";

static const uint TIMERINTERVAL = 25; // msec
static const uint ANIMATIONSTEPS = 20;

extern "C" KDE_EXPORT KDecorationFactory* create_factory() {
    return new polyester::polyesterFactory();
}

//////////////////////////////////////////////////////////////////////////////
// polyesterFactory()
// ----------------
// Constructor

polyesterFactory::polyesterFactory() {
    readConfig();
    initialized_ = true;
}

//////////////////////////////////////////////////////////////////////////////
// ~polyesterFactory()
// -----------------
// Destructor

polyesterFactory::~polyesterFactory() {
    initialized_ = false;
}

//////////////////////////////////////////////////////////////////////////////
// createDecoration()
// -----------------
// Create the decoration

KDecoration* polyesterFactory::createDecoration(KDecorationBridge* b) {
    return new polyesterClient(b, this);
}

//////////////////////////////////////////////////////////////////////////////
// reset()
// -------
// Reset the handler. Returns true if decorations need to be remade, false if
// only a repaint is necessary

bool polyesterFactory::reset(unsigned long changed) {
    // read in the configuration
    initialized_ = false;
    bool confchange = readConfig();
    initialized_ = true;

    if (confchange ||
            (changed & (SettingDecoration | SettingButtons | SettingBorder))) {
        return true;
    } else {
        resetDecorations(changed);
        return false;
    }
}

//////////////////////////////////////////////////////////////////////////////
// readConfig()
// ------------
// Read in the configuration file

bool polyesterFactory::readConfig() {
    // create a config object
    TDEConfig config("twinpolyesterrc");
    config.setGroup("General");

    // grab settings
    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;

    TQSettings globalSettings;
    contrast_ = globalSettings.readNumEntry("/TQt/KDE/contrast", 6);
    cornerflags_ = config.readBoolEntry("RoundCorners", true);
    titlesize_ = config.readNumEntry("TitleSize",20);
    titleBarStyle_ = config.readNumEntry("TitleBarStyle", 0);
    buttonStyle_ = config.readNumEntry("ButtonStyle", 1);

    buttonsize_ = config.readNumEntry("ButtonSize",18);
    squareButton_ = config.readBoolEntry("SquareButton", false);
    framesize_ = config.readNumEntry("FrameSize",2);
    roundsize_ = config.readNumEntry("RoundPercent",50);


    titleshadow_ = config.readBoolEntry("TitleShadow", true);
    lightBorder_ = config.readBoolEntry("LightBorder", true);
    animatebuttons = config.readBoolEntry("AnimateButtons", true);
    nomodalbuttons = config.readBoolEntry("NoModalButtons", false);
    btnComboBox = config.readNumEntry("ButtonComboBox", 0);
    menuClose = config.readBoolEntry("CloseOnMenuDoubleClick");

    if(buttonsize_ > titlesize_ - framesize_)
    {
        buttonsize_ = titlesize_-framesize_;
    }

    return true;
}

//////////////////////////////////////////////////////////////////////////////
// polyesterButton Class 
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// polyesterButton()
// ---------------
// Constructor
polyesterButton::polyesterButton(polyesterClient *parent, const char *name, const TQString& tip, ButtonType type, int button_size, bool squareButton, bool toggle): TQButton(parent->widget(), name), 
     client_(parent), 
     type_(type), 
     size_(button_size),
     deco_(0), 
     lastmouse_(NoButton),
     buttonImgActive_created(false),
     buttonImgInactive_created(false),
     hover_(false)
{
    setBackgroundMode(NoBackground);

    int buttonWidth = button_size;
    if( squareButton )
      buttonProportions_ = 1;
    else
    {
      buttonProportions_ = sqrt(2);
      buttonWidth = (int)round(button_size*buttonProportions_);
      //makes always centered icons
      if( buttonWidth % 2 != 0 )
        buttonWidth++;
    }

    setFixedSize( buttonWidth, button_size);
    setCursor(arrowCursor);
    TQToolTip::add(this, tip);
    setToggleButton(toggle);
    //button animation setup
    animTmr = new TQTimer(this);
    connect(animTmr, TQ_SIGNAL(timeout() ), this, TQ_SLOT(animate() ) );
    connect(this, TQ_SIGNAL(pressed() ), this, TQ_SLOT(buttonClicked() ) );
    connect(this, TQ_SIGNAL(released() ), this, TQ_SLOT(buttonReleased() ) );
    animProgress = 0;
    m_clicked=false;
}

polyesterButton::~polyesterButton() {
    if ( deco_ )
        delete deco_;
}

//////////////////////////////////////////////////////////////////////////////
// sizeHint()
// ----------
// Return size hint

TQSize polyesterButton::sizeHint() const {
    return TQSize(size_, size_);
}

//////////////////////////////////////////////////////////////////////////////
// buttonClicked()
// ----------
// Button animation progress reset so we don't get any leave event animation
// when the mouse is still pressed
void polyesterButton::buttonClicked() {
    m_clicked=true;
    animProgress=0;
}
void polyesterButton::buttonReleased() {
    //This doesn't work b/c a released() TQ_SIGNAL is thrown when a leaveEvent occurs
    //m_clicked=false;
}

//////////////////////////////////////////////////////////////////////////////
// animate()
// ----------
// Button animation timing
void polyesterButton::animate() {
    animTmr->stop();
    if (!::factory->animateButtons() )
      return;

    if(hover_) {
        if(animProgress < ANIMATIONSTEPS) {
            animProgress++;
            animTmr->start(TIMERINTERVAL, true); // single-shot
        }
    } else {
        if(animProgress > 0) {
            animProgress--;
            animTmr->start(TIMERINTERVAL, true); // single-shot
        }
    }
    repaint(false);
}
//////////////////////////////////////////////////////////////////////////////
// enterEvent()
// ------------
// Mouse has entered the button

void polyesterButton::enterEvent(TQEvent *e) {
    // we wanted to pass on the event
    TQButton::enterEvent(e);
    // we want to do mouseovers, so keep track of it here
    hover_=true;
    if(!m_clicked)
    {
        animate();
    }
}

//////////////////////////////////////////////////////////////////////////////
// leaveEvent()
// ------------
// Mouse has left the button

void polyesterButton::leaveEvent(TQEvent *e) {
    // we wanted to pass on the event
    TQButton::leaveEvent(e);
    // we want to do mouseovers, so keep track of it here
    hover_=false; 
    if(!m_clicked)
    {
        animate();
    }
}

//////////////////////////////////////////////////////////////////////////////
// mousePressEvent()
// -----------------
// Button has been pressed

void polyesterButton::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 polyesterButton::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);
    if(m_clicked)
    {
        m_clicked=false;
    }
}

void polyesterButton::setOn(bool on)
{
    TQButton::setOn(on);
}

void polyesterButton::setDown(bool on)
{
    TQButton::setDown(on);
}

//////////////////////////////////////////////////////////
// getButtonImage()
// ----------------
// get the button TQImage based on type and window mode
TQImage polyesterButton::getButtonImage(ButtonType type)
{
    TQImage finalImage;
    switch(type) {
        case ButtonClose:
            finalImage = uic_findImage( "close.png" );
            break;
        case ButtonHelp:
            finalImage = uic_findImage( "help.png" );
            break;
        case ButtonMin:
            finalImage = uic_findImage( "minimize.png" );
            break;
        case ButtonMax:
            if(client_->maximizeMode() == KDecorationDefines::MaximizeFull)
            {
                finalImage = uic_findImage( "restore.png" );
            }
            else
            {
                finalImage = uic_findImage( "maximize.png" );
            }
            break;
        case ButtonSticky:
            if(client_->isOnAllDesktops())
            {
                finalImage = uic_findImage( "circle2.png" );
            }
            else
            {
                finalImage = uic_findImage( "circle.png" );
            }
            break;
        case ButtonShade:
            if(client_->isShade())
            {
                finalImage = uic_findImage( "unsplat.png" );
            }
            else
            {
                finalImage = uic_findImage( "splat.png" );
            }
            break;
        case ButtonAbove:
            if(client_->keepAbove())
            {
                finalImage = uic_findImage( "keep_above_lit.png" );
            }
            else
            {
                finalImage = uic_findImage( "keep_above.png" );
            }
            break;
        case ButtonBelow:
            if(client_->keepBelow())
            {
                finalImage = uic_findImage( "keep_below_lit.png" );
            }
            else
            {
                finalImage = uic_findImage( "keep_below.png" );
            }
            break;
        default:
            finalImage = uic_findImage( "splat.png" );
            break;
    }
    if(tqGray(KDecoration::options()->color(KDecoration::ColorButtonBg, client_->isActive()).rgb()) < 150)
        finalImage.invertPixels();

    return finalImage;
}

//////////////////////////////////////////////////////////
// drawButton()
// -------------------------
// draw the pixmap button

void polyesterButton::drawButton( TQPainter *painter ) {
    if ( !polyesterFactory::initialized() )
        return ;

    int newWidth = width() - 2;
    int newHeight = height() - 2;
    int dx = (width() - newWidth) / 2;
    int dy = (height() - newHeight) / 2;
    TQImage tmpResult;
    TQColorGroup group;
    TQColor redColor(red);
    bool active = client_->isActive();

    genButtonPix(active);

    TQPixmap backgroundTile = client_->getTitleBarTile(active);
    group = KDecoration::options()->colorGroup(KDecoration::ColorButtonBg, active);

    //draw the titlebar behind the buttons and app icons
    if ((client_->maximizeMode()==client_->MaximizeFull) && !KDecoration::options()->moveResizeMaximizedWindows())
    {
        painter->drawTiledPixmap(0, 0, width(), height(), backgroundTile, 0, 1);
    }
    else
    {
        painter->drawTiledPixmap(0, 0, width(), height(), backgroundTile,
                                 0, y()-::factory->frameSize());
    }

    //the menu button doesn't have a button appearance
    if (type_ == ButtonMenu)
    {
      //slight movement to show the menu button is depressed
      if (isDown()) {
          dx++;
          dy++;
      }
      TQPixmap menuButtonPixmap(client_->icon().pixmap(TQIconSet::Small, TQIconSet::Normal));
      TQImage menuButtonImage(menuButtonPixmap.convertToImage());
      //draw the menu button the same size as the other buttons
      //using TQIconSet::Large gives us a 32x32 icon to resize, resizing larger than
      //that may produce pixilation of the image
      //painter->setPen(group.background());

      painter->drawImage( dx+(int)round(abs(width()-size_)/2), dy, menuButtonImage.smoothScale(size_-2, newHeight) );
      return;
    }

    //build the button image with the icon superimposed to the button
    TQImage buttonImage = (active?(buttonImgActive):(buttonImgInactive))->copy();
    KImageEffect::blendOnLower( (int)round(abs(width()-size_)/2), 0,
                                getButtonImage(type_).smoothScale( size_,size_),
                                buttonImage );

    //highlight on a mouse over repaint
    double factor = animProgress * 0.05;//0.13;

    //do the animation thing
    if( !isDown() && factor != 0.0 )
    {
      tmpResult = buttonImage.copy();
      //always colorize with a threatening red color the close button
      if( type_ == ButtonClose)
      {
        //tmpResult = KImageEffect::blend( TQColor(180, 50, 50), buttonImage, factor );
        KImageEffect::desaturate( tmpResult, factor );
        KImageEffect::channelIntensity( tmpResult, factor/3, KImageEffect::Red );
        KImageEffect::channelIntensity( tmpResult, -factor/2, KImageEffect::Green );
        KImageEffect::channelIntensity( tmpResult, -factor/2, KImageEffect::Blue );
      }
      else
          switch(::factory->getBtnComboBox())
          {
              //colorize
              case 0:
                  if( type_ == ButtonMax)
                  {
                    KImageEffect::desaturate( tmpResult, factor );
                    KImageEffect::channelIntensity( tmpResult, -factor/3, KImageEffect::Red );
                    KImageEffect::channelIntensity( tmpResult, factor/2, KImageEffect::Green );
                    KImageEffect::channelIntensity( tmpResult, -factor/3, KImageEffect::Blue );
                  }
                  else if( type_ == ButtonMin)
                  {
                    KImageEffect::desaturate( tmpResult, factor );
                    KImageEffect::channelIntensity( tmpResult, factor/4, KImageEffect::Red );
                    KImageEffect::channelIntensity( tmpResult, factor/4, KImageEffect::Green );
                    KImageEffect::channelIntensity( tmpResult, -factor/2, KImageEffect::Blue );
                  }
                  else if( type_ == ButtonSticky)
                  {
                    KImageEffect::desaturate( tmpResult, factor );
                    KImageEffect::channelIntensity( tmpResult, -factor/3, KImageEffect::Red );
                    KImageEffect::channelIntensity( tmpResult, -factor/3, KImageEffect::Green );
                    KImageEffect::channelIntensity( tmpResult, factor/2, KImageEffect::Blue );
                  }
                  else
                  {
                    KImageEffect::desaturate( tmpResult, factor );
                    KImageEffect::channelIntensity( tmpResult, -factor/2, KImageEffect::Red );
                    KImageEffect::channelIntensity( tmpResult, factor/3, KImageEffect::Green );
                    KImageEffect::channelIntensity( tmpResult, factor/3, KImageEffect::Blue );
                  }
                  break;
              //intensify
              case 1:
                  KImageEffect::intensity( tmpResult, factor);
                  break;
              //fade
              case 2:
                  KImageEffect::intensity( tmpResult, -factor/2);

                  break;
          }
    }

    KImageEffect::blendOnLower(tmpResult, TQPoint(1,1), buttonImage, TQRect(1,1,width()-2, height()-2) );

    TQPixmap finalButton = TQPixmap(buttonImage);

    painter->drawPixmap( 0, 0, finalButton );
}

void polyesterButton::genButtonPix( bool active )
{
 if(active && buttonImgActive_created) return;
 else if(!active && buttonImgInactive_created) return;

 KPixmap tempPixmap;
 TQPixmap *tempButton = new TQPixmap(width(), height());
 TQPainter painter(tempButton);

 TQColorGroup group;
 group = KDecoration::options()->colorGroup(KDecoration::ColorButtonBg, client_->isActive());

 if( ::factory->buttonStyle() == BUTTON_GLASS )
    tempPixmap.resize(width()-2, (height()/2)-1);
 else
    tempPixmap.resize(width()-2, height()-2);

 /*
 if(  ::factory->buttonStyle() != BUTTON_FLAT  )
 {
  tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                       group.background().light(100+(::factory->buttonStyle()!=BUTTON_REVGRADIENT?60:-20)),
                                       group.background().light(100+(::factory->buttonStyle()!=BUTTON_GLASS?
                                                                       (::factory->buttonStyle()==BUTTON_REVGRADIENT?
                                                                          60:-20)
                                                                       :0)),
                                       KPixmapEffect::VerticalGradient
                                      );
 }
 else
 {
  tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                       group.background(),
                                       group.background(),
                                       KPixmapEffect::VerticalGradient
                                      );
 }
*/

 int contrast = ::factory->contrast();

 switch( ::factory->buttonStyle() )
 {
   case BUTTON_GRADIENT:
       tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                       group.background().light(105+contrast*8),
                                       group.background().dark(100+contrast*2),
                                       KPixmapEffect::VerticalGradient
                                      );
     break;
   case BUTTON_GLASS:
       tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                       group.background().light(105+contrast*8),
                                       group.background(),
                                       KPixmapEffect::VerticalGradient
                                      );
     break;
   case BUTTON_REVGRADIENT:
       tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                       group.background().dark(100+contrast*2),
                                       group.background().light(105+contrast*8),
                                       KPixmapEffect::VerticalGradient
                                      );
     break;

   //case BUTTON_FLAT:
   default:
       tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                       group.background(),
                                       group.background(),
                                       KPixmapEffect::VerticalGradient
                                      );
     break;
 }

 //draw the main area of the buttons
 //painter.begin(tempButton);
 painter.drawPixmap(1, 1, tempPixmap);

 //if the button is glass create the second gradient
 if( ::factory->buttonStyle() == BUTTON_GLASS )
 {
    tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                        group.background().dark(105+contrast),
                                        group.background(),
                                        KPixmapEffect::VerticalGradient
                                       );

    painter.drawPixmap(1, (height()/2), tempPixmap);
  }

 //border
 TQColor borderColor = group.background().dark(160);
 painter.setPen( borderColor );
 painter.drawLine(0, 2, 0, height()-3);
 painter.drawLine(width()-1, 2, width()-1, height()-3);
 painter.drawLine(2, 0, width()-3, 0);
 painter.drawLine(2, height()-1, width()-3, height()-1);
 painter.drawPoint(1, 1);
 painter.drawPoint(width()-2, 1);
 painter.drawPoint(1, height()-2);
 painter.drawPoint(width()-2, height()-2);

 //little 3d effect
 painter.setPen( group.background().light(140) );
 painter.drawLine(1, 2, 1, height()-3);
 painter.drawLine(2, 1, width()-3, 1);
 if(!::factory->lightBorder())
   painter.setPen( group.background().dark(110) );
 painter.drawLine(width()-2, 2, width()-2, height()-3);
 painter.drawLine(2, height()-2, width()-3, height()-2);
 painter.end();

  //border antialiasing
 TQImage *tempAlphaImg = new TQImage( tempButton->convertToImage() );
 //tempAlphaImg = tempPixmap.convertToImage();
 tempAlphaImg->setAlphaBuffer(true);
 int borderRed = borderColor.red();
 int borderGreen = borderColor.green();
 int borderBlue = borderColor.blue();

 tempAlphaImg->setPixel(0,0, tqRgba(borderRed, borderGreen , borderBlue, 40));
 tempAlphaImg->setPixel(width()-1, 0, tqRgba(borderRed, borderGreen , borderBlue, 40));
 tempAlphaImg->setPixel(0,height()-1, tqRgba(borderRed, borderGreen , borderBlue, 40));
 tempAlphaImg->setPixel(width()-1,height()-1, tqRgba(borderRed, borderGreen , borderBlue, 40));

 tempAlphaImg->setPixel(0,1, tqRgba(borderRed, borderGreen , borderBlue, 127));
 tempAlphaImg->setPixel(1,0, tqRgba(borderRed, borderGreen , borderBlue, 127));

 tempAlphaImg->setPixel(width()-2,0, tqRgba(borderRed, borderGreen , borderBlue, 127));
 tempAlphaImg->setPixel(width()-1,1, tqRgba(borderRed, borderGreen , borderBlue, 127));

 tempAlphaImg->setPixel(0,height()-2, tqRgba(borderRed, borderGreen , borderBlue, 127));
 tempAlphaImg->setPixel(1,height()-1, tqRgba(borderRed, borderGreen , borderBlue, 127));

 tempAlphaImg->setPixel(width()-1,height()-2, tqRgba(borderRed, borderGreen , borderBlue, 127));
 tempAlphaImg->setPixel(width()-2,height()-1, tqRgba(borderRed, borderGreen , borderBlue, 127));


 if( client_->isActive() )
 {
   buttonImgActive = tempAlphaImg;
   buttonImgActive_created = true;
 }
 else
 {
   buttonImgInactive = tempAlphaImg;
   buttonImgInactive_created = true;
 }

}

//////////////////////////////////////////////////////////////////////////////
// polyesterClient Class
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// polyesterClient()
// ---------------
// Constructor

polyesterClient::polyesterClient(KDecorationBridge *b, KDecorationFactory *f)
    : KDecoration(b, f),
    mainLayout_(0),
    titleLayout_(0),
    topSpacer_(0),
    titleSpacer_(0),
    leftTitleSpacer_(0), rightTitleSpacer_(0),
    decoSpacer_(0),
    leftSpacer_(0), rightSpacer_(0),
    bottomSpacer_(0), windowSpacer_(0),
    aCaptionBuffer(0), iCaptionBuffer(0),
    aTitleBarTile(0), iTitleBarTile(0), aTitleBarTopTile(0), iTitleBarTopTile(0),
    pixmaps_created(false),
    //captionBufferDirty(true),
    closing(false),
    s_titleHeight(0),
    s_titleFont(TQFont()),
    maskDirty(true),
    aDoubleBufferDirty(true),
    iDoubleBufferDirty(true)
    {
        aCaptionBuffer = new TQPixmap();
        iCaptionBuffer = new TQPixmap();

        //copying the most used configuration options
        frameSize = ::factory->frameSize();

        NET::WindowType type = windowType(NET::NormalMask | NET::DesktopMask |
                                          NET::DockMask | NET::ToolbarMask |
                                          NET::MenuMask | NET::DialogMask|
                                          NET::OverrideMask | NET::TopMenuMask |
                                          NET::UtilityMask | NET::SplashMask);
        if( type == NET::Utility || type == NET::Menu || type == NET::Toolbar )
        {
           titleSize = (int)((double)::factory->titleSize()/1.2);
           buttonSize = titleSize - 2;
           roundedCorners = false;
        }
        else
        {
           titleSize = ::factory->titleSize();
           //don't allow buttonSize > titleSize
           buttonSize = titleSize - 2 < ::factory->buttonSize()?
                                                 titleSize - 2 :
                                                 ::factory->buttonSize();
           roundedCorners = ::factory->roundedCorners();
        }

        //s_titleFont = isTool()?polyesterFactory::titleFontTool():polyesterFactory::titleFont();
        s_titleFont = options()->font();
        s_titleHeight = titleSize;
    }

//////////////////////////////////////////////////////////////////////////////////
// ~polyesterClient()
// --------------------
// Destructor
polyesterClient::~polyesterClient() {
    delete aCaptionBuffer;
    delete iCaptionBuffer;
}

void polyesterClient::create_pixmaps() {
    if(pixmaps_created)
        return;
    KPixmap tempPixmap;
    TQPainter painter;


    // active top title bar tile
    tempPixmap.resize(1, s_titleHeight+frameSize);
    tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                         KDecoration::options()->color(ColorTitleBar, true).light(160),
                                         KDecoration::options()->color(ColorTitleBlend, true).light(104),
                                         KPixmapEffect::VerticalGradient
                                        );
    // tempPixmap.fill(KDecoration::options()->color(ColorTitleBar, true).light(150));
    aTitleBarTopTile = new TQPixmap(1, s_titleHeight+frameSize);
    painter.begin(aTitleBarTopTile);
    painter.drawPixmap(0, 0, tempPixmap);
    painter.end();
    
    // inactive top title bar tile
    tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                         KDecoration::options()->color(ColorTitleBar, false).light(160),
                                         KDecoration::options()->color(ColorTitleBlend, false),
                                         KPixmapEffect::VerticalGradient
                                        );
    iTitleBarTopTile = new TQPixmap(1, s_titleHeight+frameSize);
    painter.begin(iTitleBarTopTile);
    painter.drawPixmap(0, 0, tempPixmap);
    painter.end();

    // active title bar tile
    if( ::factory->titleBarStyle() == TITLEBAR_GLASS)
       tempPixmap.resize(1, ((s_titleHeight+frameSize)/2) - 1 );
    else
       tempPixmap.resize(1, s_titleHeight+frameSize);

    TQColor color1;
    TQColor color2;
    TQColor glassColor;
    if( ::factory->titleBarStyle() == TITLEBAR_GLASS )
    {
      glassColor = alphaBlendColors( KDecoration::options()->color(ColorTitleBar, true),
                                     KDecoration::options()->color(ColorTitleBlend, true),
                                     127 );
      color1 = glassColor.light(105+::factory->contrast()*4);
      color2 = glassColor;
    }
    else
    {
      color1 = KDecoration::options()->color(ColorTitleBar, true);
      color2 = KDecoration::options()->color(ColorTitleBlend, true);
    }

    tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                         color1,
                                         color2,
                                         KPixmapEffect::VerticalGradient
                                        );

    aTitleBarTile = new TQPixmap(1, s_titleHeight+frameSize);
    painter.begin(aTitleBarTile);
    painter.drawPixmap(0, 0, tempPixmap);

    if( ::factory->titleBarStyle() == TITLEBAR_GLASS )
    {
       int y = tempPixmap.height();
       tempPixmap.resize(1, (s_titleHeight+frameSize)-y );
       tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                            glassColor.dark(105+::factory->contrast()),
                                            glassColor,
                                            KPixmapEffect::VerticalGradient
                                           );
       painter.drawPixmap(0, y, tempPixmap);
    }
    //  painter.drawPixmap(0, 0, *aTitleBarTopTile);
    painter.end();

    // inactive title bar tile
    //de-glassify inactive titlebar
    if( ::factory->titleBarStyle() == TITLEBAR_GLASS )
       tempPixmap.resize(1, s_titleHeight+frameSize);
    tempPixmap = KPixmapEffect::gradient(tempPixmap,
                                         KDecoration::options()->color(ColorTitleBar, false),
                                         KDecoration::options()->color(ColorTitleBlend, false),
                                         KPixmapEffect::VerticalGradient
                                        );
    iTitleBarTile = new TQPixmap(1, s_titleHeight+frameSize);
    painter.begin(iTitleBarTile);
    painter.drawPixmap(0, 0, tempPixmap);
    painter.end();


    pixmaps_created = true;
}

void polyesterClient::delete_pixmaps() {
    delete aTitleBarTopTile;
    aTitleBarTopTile = 0;

    delete iTitleBarTopTile;
    iTitleBarTopTile = 0;

    delete aTitleBarTile;
    aTitleBarTile = 0;

    delete iTitleBarTile;
    iTitleBarTile = 0;

    pixmaps_created = false;
}
//////////////////////////////////////////////////////////////////////////////
// init()
// ------
// Actual initializer for class

void polyesterClient::init() {
    createMainWidget( WResizeNoErase | WRepaintNoErase);
    widget()->installEventFilter(this);
    handlebar = frameSize < 4 ? 4 - frameSize : 0;

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

    create_pixmaps();
    _resetLayout();

}
void polyesterClient::_resetLayout()
{
    // basic layout:
    //  _______________________________________________________________
    // |                         topSpacer                             |
    // |_______________________________________________________________|
    // | leftTitleSpacer | btns |  titlebar   | bts | rightTitleSpacer |
    // |_________________|______|_____________|_____|__________________|
    // |                         decoSpacer                            |
    // |_______________________________________________________________|
    // | |                                                           | |
    // | |                      windowWrapper                        | |
    // | |                                                           | |
    // |leftSpacer                                          rightSpacer|
    // |_|___________________________________________________________|_|
    // |                           bottomSpacer                        |
    // |_______________________________________________________________|
    //
    if (!::factory->initialized()) return;
    
    delete mainLayout_;
    delete titleLayout_;
    delete topSpacer_;
    delete titleSpacer_;
    delete leftTitleSpacer_;
    delete rightTitleSpacer_;
    delete decoSpacer_;
    delete leftSpacer_;
    delete rightSpacer_;
    delete bottomSpacer_;
    delete windowSpacer_;

    mainLayout_ = new TQVBoxLayout(widget());
    // title
    titleLayout_ = new TQHBoxLayout();
    TQHBoxLayout *windowLayout_ = new TQHBoxLayout();


    topSpacer_        = new TQSpacerItem(1, frameSize, TQSizePolicy::Expanding, TQSizePolicy::Fixed);
    titlebar_         = new TQSpacerItem(1, s_titleHeight,
                                        TQSizePolicy::Expanding, TQSizePolicy::Fixed);
    leftTitleSpacer_  = new TQSpacerItem(frameSize, s_titleHeight,
                                        TQSizePolicy::Fixed, TQSizePolicy::Fixed);
    rightTitleSpacer_ = new TQSpacerItem(frameSize, s_titleHeight,
                                        TQSizePolicy::Fixed, TQSizePolicy::Fixed);
    decoSpacer_       = new TQSpacerItem(1, frameSize, TQSizePolicy::Expanding, TQSizePolicy::Fixed);
    leftSpacer_       = new TQSpacerItem(frameSize, 1,
                                        TQSizePolicy::Fixed, TQSizePolicy::Expanding);
    rightSpacer_      = new TQSpacerItem(frameSize, 1,
                                        TQSizePolicy::Fixed, TQSizePolicy::Expanding);
    bottomSpacer_     = new TQSpacerItem(1, frameSize,
                                        TQSizePolicy::Expanding, TQSizePolicy::Fixed);
    
    // sizeof(...) is calculated at compile time
    memset(button, 0, sizeof(polyesterButton *) * ButtonTypeCount);

    // message in preview widget
    if (isPreview()) {
        windowLayout_->addWidget(
            new TQLabel( i18n("<b><center>Polyester Preview</center></b>"), widget() ), 1 ); 
    } else {
        windowLayout_->addItem(new TQSpacerItem(0, 0));
    }

    // setup titlebar buttons
    for (int n=0; n<ButtonTypeCount; n++)
        button[n] = 0;
    //Deal with the title and buttons
   titleLayout_->addItem(leftTitleSpacer_);

    if( !::factory->noModalButtons() || !isModal() || isResizable())
        addButtons(titleLayout_,
                   options()->customButtonPositions() ? options()->titleButtonsLeft() : TQString(default_left),
                   buttonSize);
    titleLayout_->addItem(titlebar_);
    if( !::factory->noModalButtons() ||  !isModal() || isResizable())
        addButtons(titleLayout_,
                   options()->customButtonPositions() ? options()->titleButtonsRight() : TQString(default_right),
                   buttonSize);
        titleLayout_->addItem(rightTitleSpacer_);

    //Mid - left side, middle contents and right side
    TQHBoxLayout * midLayout_   = new TQHBoxLayout();
    midLayout_->addItem(leftSpacer_);
    midLayout_->addLayout(windowLayout_);
    midLayout_->addItem(rightSpacer_);

    //Layout order
    mainLayout_->addItem( topSpacer_ );
    mainLayout_->addLayout( titleLayout_ );
    mainLayout_->addItem( decoSpacer_ );
    mainLayout_->addLayout( midLayout_ );
    mainLayout_->addItem( bottomSpacer_ );
    
    // connections
  //TODO: probably these two connections could be removed
  //  connect(this, TQ_SIGNAL(keepAboveChanged(bool)), TQ_SLOT(keepAboveChange(bool)));
  //  connect(this, TQ_SIGNAL(keepBelowChanged(bool)), TQ_SLOT(keepBelowChange(bool)));
}

//////////////////////////////////////////////////////////////////////////////
// addButtons()
// ------------
// Add buttons to title layout

void polyesterClient::addButtons(TQBoxLayout *layout, const TQString& s, int button_size) {
    TQString tip;
    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 polyesterButton(this, "splat.png", i18n("Menu"),ButtonMenu,button_size,::factory->squareButton());
                    connect(button[ButtonMenu], TQ_SIGNAL(pressed()), this, TQ_SLOT(menuButtonPressed()));
                    connect(button[ButtonMenu], TQ_SIGNAL(released()), this, TQ_SLOT(menuButtonReleased()));
                    layout->addWidget(button[ButtonMenu]);
                    if (n < s.length()-1) layout->addSpacing(1);
                }
                break;

            case 'S': // Sticky button
                if (!button[ButtonSticky]) {
                    if (isOnAllDesktops()) {
                        tip = i18n("Un-Sticky");
                    } else {
                        tip = i18n("Sticky");
                    }
                    button[ButtonSticky] =
                        new polyesterButton(this, "circle.png", tip, ButtonSticky, button_size,::factory->squareButton(), true);
                    connect(button[ButtonSticky], TQ_SIGNAL(clicked()),
                            this, TQ_SLOT(toggleOnAllDesktops()));
                    layout->addWidget(button[ButtonSticky]);
                    if (n < s.length()-1) layout->addSpacing(1);
                }
                break;

            case 'H': // Help button
                if ((!button[ButtonHelp]) && providesContextHelp()) {
                    button[ButtonHelp] =
                        new polyesterButton(this, "help.png", i18n("Help"), ButtonHelp, button_size, ::factory->squareButton());
                    connect(button[ButtonHelp], TQ_SIGNAL(clicked()),
                            this, TQ_SLOT(showContextHelp()));
                    layout->addWidget(button[ButtonHelp]);
                    if (n < s.length()-1) layout->addSpacing(1);
                }
                break;

            case 'I': // Minimize button
                if ((!button[ButtonMin]) && isMinimizable())  {
                    button[ButtonMin] =
                        new polyesterButton(this, "minimize.png", i18n("Minimize"), ButtonMin, button_size,::factory->squareButton());
                    connect(button[ButtonMin], TQ_SIGNAL(clicked()),
                            this, TQ_SLOT(minimize()));
                    layout->addWidget(button[ButtonMin]);
                    if (n < s.length()-1) layout->addSpacing(1);
                }
                break;

            case 'A': // Maximize button
                if ((!button[ButtonMax]) && isMaximizable()) {
                    if (maximizeMode() == MaximizeFull) {
                        tip = i18n("Restore");
                    } else {
                        tip = i18n("Maximize");
                    }
                    button[ButtonMax]  =
                        new polyesterButton(this, "maximize.png", tip, ButtonMax, button_size,::factory->squareButton(), true);
                    connect(button[ButtonMax], TQ_SIGNAL(clicked()),
                            this, TQ_SLOT(maxButtonPressed()));
                    layout->addWidget(button[ButtonMax]);
                    if (n < s.length()-1) layout->addSpacing(1);
                }
                break;

            case 'X': // Close button
                if ((!button[ButtonClose]) && isCloseable()) {
                    button[ButtonClose] =
                        new polyesterButton(this, "close.png", i18n("Close"), ButtonClose, button_size, ::factory->squareButton());
                    connect(button[ButtonClose], TQ_SIGNAL(clicked()),
                            this, TQ_SLOT(closeWindow()));
                    layout->addWidget(button[ButtonClose]);
                    if (n < s.length()-1) layout->addSpacing(1);
                }
                break;

            case 'F': // Above button
                if ((!button[ButtonAbove])) {
                    button[ButtonAbove] =
                        new polyesterButton(this, "keep_above.png",
                                            i18n("Keep Above Others"), ButtonAbove, button_size, ::factory->squareButton(), true);
                    connect(button[ButtonAbove], TQ_SIGNAL(clicked()),
                            this, TQ_SLOT(aboveButtonPressed()));
                    layout->addWidget(button[ButtonAbove]);
                    if (n < s.length()-1) layout->addSpacing(1);
                }
                break;

            case 'B': // Below button
                if ((!button[ButtonBelow])) {
                    button[ButtonBelow] =
                        new polyesterButton(this, "keep_below.png",
                                            i18n("Keep Below Others"), ButtonBelow, button_size, ::factory->squareButton(), true);
                    connect(button[ButtonBelow], TQ_SIGNAL(clicked()),
                            this, TQ_SLOT(belowButtonPressed()));
                    layout->addWidget(button[ButtonBelow]);
                    if (n < s.length()-1) layout->addSpacing(1);
                }
                break;

            case 'L': // Shade button
                if ((!button[ButtonShade && isShadeable()])) {
                    if ( isSetShade()) {
                        tip = i18n("Unshade");
                    } else {
                        tip = i18n("Shade");
                    }
                    button[ButtonShade] =
                        new polyesterButton(this, "splat.png", tip, ButtonShade, button_size, ::factory->squareButton(), true);
                    connect(button[ButtonShade], TQ_SIGNAL(clicked()),
                            this, TQ_SLOT(shadeButtonPressed()));
                    layout->addWidget(button[ButtonShade]);
                    if (n < s.length()-1) layout->addSpacing(1);
                }
                break;

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

//////////////////////////////////////////////////////////////////////////////
// activeChange()
// --------------
// window active state has changed

void polyesterClient::activeChange() {
    for (int n=0; n<ButtonTypeCount; n++)
        if (button[n])
            button[n]->reset();
    maskDirty = true;
    widget()->repaint(false);
}

//////////////////////////////////////////////////////////////////////////////
// captionChange()
// ---------------
// The title has changed

void polyesterClient::captionChange() {
    aDoubleBufferDirty = iDoubleBufferDirty = true;
    widget()->repaint(titlebar_->geometry(), false);
}

//////////////////////////////////////////////////////////////////////////////
// desktopChange()
// ---------------
// Called when desktop/sticky changes

void polyesterClient::desktopChange() {
    bool d = isOnAllDesktops();
    if (button[ButtonSticky]) {
        TQToolTip::remove(button[ButtonSticky]);
        TQToolTip::add(button[ButtonSticky], d ? i18n("Un-Sticky") : i18n("Sticky"));
        button[ButtonSticky]->repaint(false);
    }
}

//////////////////////////////////////////////////////////////////////////////
// iconChange()
// ------------
// The title has changed

void polyesterClient::iconChange() {
    if (button[ButtonMenu]) {
        button[ButtonMenu]->repaint(false);
    }
}

//////////////////////////////////////////////////////////////////////////////
// maximizeChange()
// ----------------
// Maximized state has changed

void polyesterClient::maximizeChange() {
    maskDirty = aDoubleBufferDirty = iDoubleBufferDirty = true;
    bool m = (maximizeMode() == MaximizeFull);
    if (button[ButtonMax]) {
        TQToolTip::remove(button[ButtonMax]);
        TQToolTip::add(button[ButtonMax], m ? i18n("Restore") : i18n("Maximize"));
        button[ButtonMax]->repaint(false);
    }
}

//////////////////////////////////////////////////////////////////////////////
// shadeChange()
// -------------
// Called when window shading changes

void polyesterClient::shadeChange() {
    bool s = isSetShade();
    if (button[ButtonShade]) {
        TQToolTip::remove(button[ButtonShade]);
        TQToolTip::add(button[ButtonShade], s ? i18n("Unshade") : i18n("Shade"));
        button[ButtonShade]->repaint(false);
    }
}

//////////////////////////////////////////////////////////////////////////////
// TODO: probably these two functions can be removed
// keepAboveChange()
// ------------
// The above state has changed

void polyesterClient::keepAboveChange(bool a) {
    if (button[ButtonAbove]) {
        button[ButtonAbove]->setOn(a);
        button[ButtonAbove]->repaint(false);
    }
}

//////////////////////////////////////////////////////////////////////////////
// keepBelowChange()
// ------------
// The below state has changed

void polyesterClient::keepBelowChange(bool b) {
    if (button[ButtonBelow]) {
        button[ButtonBelow]->setOn(b);
        button[ButtonBelow]->repaint(false);
    }
}

//////////////////////////////////////////////////////////////////////////////
// borders()
// ----------
// Get the size of the borders

void polyesterClient::borders(int &left, int &right, int &top, int &bottom) const {

    if ((maximizeMode()==MaximizeFull) && !options()->moveResizeMaximizedWindows()) {
        left = right = bottom = 0;
        top = s_titleHeight;

        // update layout etc.
        topSpacer_->changeSize(1, -1, TQSizePolicy::Expanding, TQSizePolicy::Fixed);
        decoSpacer_->changeSize(1, 0, TQSizePolicy::Expanding, TQSizePolicy::Fixed);
        leftSpacer_->changeSize(left, 1, TQSizePolicy::Fixed, TQSizePolicy::Expanding);
        leftTitleSpacer_->changeSize(left, s_titleHeight, TQSizePolicy::Fixed, TQSizePolicy::Fixed);
        rightSpacer_->changeSize(right, 1, TQSizePolicy::Fixed, TQSizePolicy::Expanding);
        rightTitleSpacer_->changeSize(right, s_titleHeight, TQSizePolicy::Fixed, TQSizePolicy::Fixed);
        bottomSpacer_->changeSize(1, bottom, TQSizePolicy::Expanding, TQSizePolicy::Fixed);
    } else {
        /*if the borders are rounded add more left and right borders*/
        if( roundedCorners )
          left = right = bottom = frameSize*2;
        else
          left = right = bottom = frameSize+1;
        top = titleSize + (frameSize*2);

        // update layout etc.
        topSpacer_->changeSize(1, frameSize, TQSizePolicy::Expanding, TQSizePolicy::Fixed);
        decoSpacer_->changeSize(1, frameSize, TQSizePolicy::Expanding, TQSizePolicy::Fixed);
        leftSpacer_->changeSize(left, 1, TQSizePolicy::Fixed, TQSizePolicy::Expanding);
        leftTitleSpacer_->changeSize(left, s_titleHeight, TQSizePolicy::Fixed, TQSizePolicy::Fixed);
        rightSpacer_->changeSize(right, 1, TQSizePolicy::Fixed, TQSizePolicy::Expanding);
        rightTitleSpacer_->changeSize(right,s_titleHeight,TQSizePolicy::Fixed, TQSizePolicy::Fixed);
        bottomSpacer_->changeSize(1, bottom, TQSizePolicy::Expanding, TQSizePolicy::Fixed);
    }
    widget()->layout()->activate();
}

//////////////////////////////////////////////////////////////////////////////
// resize()
// --------
// Called to resize the window

void polyesterClient::resize(const TQSize &size) {
    widget()->resize(size);
}

//////////////////////////////////////////////////////////////////////////////
// minimumSize()
// -------------
// Return the minimum allowable size for this window

TQSize polyesterClient::minimumSize() const {
    return widget()->minimumSize();
}

//////////////////////////////////////////////////////////////////////////////
// mousePosition()
// ---------------
// Return logical mouse position

KDecoration::Position polyesterClient::mousePosition(const TQPoint &point) const {
    const int corner = 24;
    Position pos;
    int fs = frameSize + handlebar;
    //int fs = ::factory->frameSize();

    if (point.y() <= fs) {
        // 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()-fs*2)) {
        // inside handle
        if (point.x() <= corner)
            pos = PositionBottomLeft;
        else if (point.x() >= (width()-corner))
            pos = PositionBottomRight;
        else
            pos = PositionBottom;
    } else if (point.x() <= fs ) {
        // 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()-fs) {
        // 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 polyesterClient::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::MouseButtonPress: {
            processMousePressEvent(static_cast<TQMouseEvent *>(e));
            return true;
        }
    case TQEvent::Wheel: {
           wheelEvent(static_cast< TQWheelEvent* >(e));
           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 polyesterClient::mouseDoubleClickEvent(TQMouseEvent *e) {
    if (titlebar_->geometry().contains(e->pos()))
        titlebarDblClickOperation();
}

//////////////////////////////////////////////////////////////////////////////
// wheelEvent()
// -----------------------
// Mousewheel over titlebar

void polyesterClient::wheelEvent(TQWheelEvent * e) {
#if TDE_VERSION > TDE_MAKE_VERSION(3,4,3)
if (titleLayout_->geometry().contains(e->pos()))
titlebarMouseWheelOperation(e->delta());
#endif
}

//////////////////////////////////////////////////////////////////////////////
// paintEvent()
// ------------
// Repaint the window

void polyesterClient::paintEvent(TQPaintEvent* e) {
    if (!::factory->initialized())
    {
        return;
    }

    //int frameSize = ::factory->frameSize();
    const uint maxCaptionLength = 200; // truncate captions longer than this!
                                       // FIXME: truncate related to window size
//titlebar_->geometry().width()/(widget()->font().pointSize());
    TQString captionText(caption());
    if (captionText.length() > maxCaptionLength) {
        captionText.truncate(maxCaptionLength);
        captionText.append(" [...]");
    }


    TQColor blackColor(black);
    TQColor redColor(red);
    TQColorGroup group,widgetGroup;

    bool active = isActive();

    //doublebuffering everything to avoid the flicker
    TQPainter finalPainter(widget());

    //an ugly debug red border used to thest the speed...
    //finalPainter.fillRect(e->rect(),red);return;

    // mask off which corners we dont want
    // otherwise recycle the old buffer
    /*if( doubleBuff.width()>0 )
    {
       finalPainter.drawPixmap(0,0, doubleBuff);
       finalPainter.end();
       return;
    }*/
    if( maskDirty )
        updateMask();
    if( !(active?aDoubleBufferDirty:iDoubleBufferDirty) && ((active?activeBuff.width():inactiveBuff.width()) == widget()->width() ))
    {
       finalPainter.drawPixmap(0,0, active?activeBuff:inactiveBuff );
       finalPainter.end();
       return;
    }


    if( active )
       activeBuff  =  TQPixmap(widget()->width(), widget()->height());
    else
       inactiveBuff  =  TQPixmap(widget()->width(), widget()->height());

    TQPainter painter(active?&activeBuff:&inactiveBuff);
    //get group information first
    group = options()->colorGroup(KDecoration::ColorTitleBlend, active);
    widgetGroup = widget()->colorGroup();

    TQRect topRect( topSpacer_->geometry() );
    TQRect titleRect( titleLayout_->geometry() );
    TQRect textRect( titlebar_->geometry() );
    TQRect Rltitle( leftTitleSpacer_->geometry() );
    TQRect Rrtitle( rightTitleSpacer_->geometry() );
    TQRect Rdeco( decoSpacer_->geometry() );
    TQRect Rleft( leftSpacer_->geometry() );
    TQRect Rright( rightSpacer_->geometry() );
    TQRect Rbottom( bottomSpacer_->geometry() );
    TQRect tempRect;

    
    /*
    if(active)
    {
        tqDebug("topRect.y()   = %i\tbottom() = %i",topRect.top(),topRect.bottom());
        tqDebug("titleRect.y() = %i\tbottom() = %i",titleRect.top(),titleRect.bottom());
        tqDebug("textRect.y()  = %i\tbottom() = %i",textRect.top(),textRect.bottom());
        tqDebug("Rltitle.y()   = %i\tbottom() = %i",Rltitle.top(),Rltitle.bottom());
        tqDebug("Rrtitle.y()   = %i\tbottom() = %i",Rrtitle.top(),Rrtitle.bottom());
        tqDebug("Rdeco.y()     = %i\tbottom() = %i",Rdeco.top(),Rdeco.bottom());
        tqDebug("Rleft.y()     = %i\tbottom() = %i",Rleft.top(),Rleft.bottom());
        tqDebug("Rright.y()    = %i\tbottom() = %i",Rright.top(),Rright.bottom());
        tqDebug("Rbottom.y()   = %i\tbottom() = %i",Rbottom.top(),Rbottom.bottom());
    }
    */

    // top
    painter.drawTiledPixmap(topRect, active ? *aTitleBarTopTile:*iTitleBarTopTile);
    painter.drawTiledPixmap(titleRect.x(),
                            titleRect.y(),
                            titleRect.width(),
                            titleRect.height() + Rdeco.height(),
                            active ? *aTitleBarTile:*iTitleBarTile);

    textRect.setRect(textRect.x()+SIDETITLEMARGIN,
                     textRect.y(),
                     textRect.width()-SIDETITLEMARGIN*2,
                     textRect.height());


    //is the title text too long?
    bool titleTooLong = false;
    TQt::AlignmentFlags titleAlign = ::factory->titleAlign();
    const int gradientWidth = 60;
    if( TQFontMetrics(widget()->font()).width(captionText) > (textRect.width() - gradientWidth) )
    {
        titleTooLong = true;
        titleAlign = TQt::AlignLeft;
    }

    //we are shadowing title bar text only if there is some text
    if(::factory->titleShadow() && textRect.width()>0 && textRect.height()>0)
    {
        TQPixmap textPixmap;
        TQPainter tempPainter;
        TQColor shadowColor;

        textPixmap = TQPixmap(textRect.width(), textRect.height());
        textPixmap.fill(TQColor(0,0,0));
        textPixmap.setMask( textPixmap.createHeuristicMask(TRUE) );
        tempPainter.begin(&textPixmap);


        //shadow text
        tempPainter.setFont(options()->font(isActive(), false));

        tempPainter.setPen(white);

        tempPainter.drawText(1, 1, textRect.width(), textRect.height(),
                         titleAlign | AlignVCenter | TQt::SingleLine,
                         captionText);
        tempPainter.end();

        // make the cute blurred text shadow from Plastik engine
        TQImage shadow;
        ShadowEngine se;

        //deciding if the shadow will be black or white
        if(tqGray(options()->color(KDecoration::ColorFont, isActive()).rgb()) > 150)
            shadowColor = blackColor;
        else
            shadowColor = white;

        shadow = se.makeShadow(textPixmap, shadowColor);

        painter.drawImage(textRect, shadow);

    }

    // draw title text
    painter.setFont(options()->font(isActive(), false));
    painter.setPen(options()->color(KDecoration::ColorFont, isActive()));
    painter.drawText(textRect,
                     titleAlign | AlignVCenter | TQt::SingleLine,
                     captionText);

    // make title fade out when the caption is too long, veery slow but veery cool :-)
    if( titleTooLong )
    {
        int xGradient = textRect.right()-(gradientWidth-1);

        TQPixmap backLayerP = TQPixmap(gradientWidth, textRect.height());
        TQPainter layerPainter(&backLayerP);
        layerPainter.drawTiledPixmap(backLayerP.rect(), active ? *aTitleBarTile:*iTitleBarTile);
        layerPainter.end();
        TQImage backLayer = backLayerP.convertToImage();

        TQImage textLayer = ( active ?
                             activeBuff.convertToImage():
                             inactiveBuff.convertToImage()
                            ).copy( xGradient, textRect.y(),
                                    gradientWidth, textRect.height()
                                  );
        KImageEffect::blend(backLayer,  textLayer, KImageEffect::HorizontalGradient);
        painter.drawImage(xGradient, textRect.y(), backLayer);

    }

    //left of buttons and title
    painter.drawTiledPixmap(Rltitle.x(),
                            Rltitle.y(),
                            Rltitle.width(),
                            Rltitle.height()+Rdeco.height(),
                            active ? *aTitleBarTile:*iTitleBarTile);

    //left 3d effect
    painter.drawTiledPixmap(Rltitle.x(),
                            Rltitle.y(),
                            2,
                            Rltitle.height()+Rdeco.height(),
                            active ? *aTitleBarTopTile:*iTitleBarTopTile);

    // left mid layout
    painter.fillRect(Rleft,widgetGroup.background());

    // right of buttons and title
    painter.drawTiledPixmap(Rrtitle.x(),
                            Rrtitle.y(),
                            Rrtitle.width(),
                            Rrtitle.height()+Rdeco.height(),
                            active ? *aTitleBarTile:*iTitleBarTile);
    //right 3d effect
    painter.drawTiledPixmap(width()-2,
                            Rltitle.y(),
                            2,
                            Rltitle.height()+Rdeco.height(),
                            active ? *aTitleBarTopTile:*iTitleBarTopTile);

    // right mid layout
    painter.fillRect(Rright,widgetGroup.background());
    
    // bottom
    /*
    if(isShade())
    {
        frame.setRect(0,::factory->titleSize()+FRAMESIZE, width(), FRAMESIZE);
    }
    else
    {
        frame.setRect(0, height() - (FRAMESIZE*2), width(),  (FRAMESIZE*2));
    }
    */
    painter.fillRect(Rbottom, KDecoration::options()->color(ColorTitleBlend, active));//widgetGroup.background());

    //if the window is maximized the border is invisible
    if( (maximizeMode()==MaximizeFull) && !options()->moveResizeMaximizedWindows() )
      painter.setPen(KDecoration::options()->color(ColorTitleBar, active));
    else
      painter.setPen(group.background().dark(150));

    // outline outside the frame but not the corners if they are rounded
    tempRect = widget()->rect();
    painter.drawRect(tempRect);

    if(roundedCorners && !maximizeMode()) {
        // local temp right and bottom
        int r(width());
        painter.setPen(group.background().dark(150));
        painter.drawPoint(4, 1);
        painter.drawPoint(3, 1);
        painter.drawPoint(2, 2);
        painter.drawPoint(1, 3);
        painter.drawPoint(1, 4);
        painter.drawPoint(r - 5, 1);
        painter.drawPoint(r - 4, 1);
        painter.drawPoint(r - 3, 2);
        painter.drawPoint(r - 2, 3);
        painter.drawPoint(r - 2, 4);

        painter.setPen(KDecoration::options()->color(ColorTitleBar, active).light(160));
        painter.drawPoint(4, 2);
        painter.drawPoint(3, 2);
        painter.drawPoint(2, 3);
        painter.drawPoint(2, 4);

        //painter.setPen(KDecoration::options()->color(ColorTitleBlend, active));
        painter.drawPoint(r - 5, 2);
        painter.drawPoint(r - 4, 2);
        painter.drawPoint(r - 3, 3);
        painter.drawPoint(r - 3, 4);
    } 

    // finally copy the buffer into the widget
    //finalPainter.begin(doubleBuff);
    finalPainter.drawPixmap(0,0, active?activeBuff:inactiveBuff);
    finalPainter.end();

    if( active )
        aDoubleBufferDirty = false;
    else
        iDoubleBufferDirty = false;
}

//////////////////////////////////////////////////////////////////////////////
// updateMask()
// ------------
// update the frame mask
void polyesterClient::updateMask() {

    if ( (!options()->moveResizeMaximizedWindows() && maximizeMode() & MaximizeFull ) ) 
    {
        setMask(TQRegion(widget()->rect()));
        return;
    }

    int r(width());
    int b(height());
    TQRegion mask;

    mask=TQRegion(widget()->rect());
    mask=TQRegion( 0, 0, r, b );

   // Remove top-left corner.
    if( roundedCorners &&
        maximizeMode() != KDecorationDefines::MaximizeFull )
    {
        mask -= TQRegion(0, 0, 5, 1);
        mask -= TQRegion(0, 1, 3, 1);
        mask -= TQRegion(0, 2, 2, 1);
        mask -= TQRegion(0, 3, 1, 2);
        mask -= TQRegion(r - 5, 0, 5, 1);
        mask -= TQRegion(r - 3, 1, 3, 1);
        mask -= TQRegion(r - 2, 2, 2, 1);
        mask -= TQRegion(r - 1, 3, 1, 2);
    }
    //always remove one corner pixel so it simulates a soft corner like plastik
    mask -= TQRegion(0,0,1,1);
    mask -= TQRegion(r-1,0,1,1);
    mask -= TQRegion(0, b-1, 1,1);
    mask -= TQRegion(r-1,b-1,1,1);

    setMask(mask, 1);

    maskDirty =  false;
}

//////////////////////////////////////////////////////////////////////////////
// resizeEvent()
// -------------
// Window is being resized

void polyesterClient::resizeEvent(TQResizeEvent *) {
    maskDirty = aDoubleBufferDirty = iDoubleBufferDirty = true;
    if (widget()->isShown()) {
        TQRegion region = widget()->rect();
        region = region.subtract(titlebar_->geometry());
        widget()->erase(region);
    }
    updateMask();
}

//////////////////////////////////////////////////////////////////////////////
// showEvent()
// -----------
// Window is being shown

void polyesterClient::showEvent(TQShowEvent *) {
    widget()->repaint();
    updateMask();
}

//////////////////////////////////////////////////////////////////////////////
// maxButtonPressed()
// -----------------
// Max button was pressed

void polyesterClient::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 polyesterClient::shadeButtonPressed() {
    if (button[ButtonShade]) {
        setShade( !isSetShade());
    }
}

//////////////////////////////////////////////////////////////////////////////
// aboveButtonPressed()
// -----------------
// Above button was pressed

void polyesterClient::aboveButtonPressed() {
    if (button[ButtonAbove]) {
        setKeepAbove( !keepAbove());
    }
}

//////////////////////////////////////////////////////////////////////////////
// belowButtonPressed()
// -----------------
// Below button was pressed

void polyesterClient::belowButtonPressed() {
    if (button[ButtonBelow]) {
        setKeepBelow( !keepBelow());
    }
}

//////////////////////////////////////////////////////////////////////////////
// menuButtonPressed()
// -------------------
// Menu button was pressed (popup the menu)

void polyesterClient::menuButtonPressed() {
    static TQTime* t = NULL;
    static polyesterClient* lastClient = NULL;
    if (t == NULL)
        t = new TQTime;
    bool dbl = (lastClient==this && t->elapsed() <= TQApplication::doubleClickInterval());
    lastClient = this;
    t->start();
    //if (button[ButtonMenu] && !dbl && !::factory->menuClosed()) {
    if ( !dbl || !::factory->menuClosed()) {
        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;
    }
}

void polyesterClient::menuButtonReleased()
{
    if(closing)
    {
        closeWindow();
    }
}

#include "polyester.moc"