Added two new settings to liquid-style / Liquid-Settings:

 - en/disable the new window decoration
 - set the stipple contrast (from no stipple to twice the normal value)

4 files changed, 58 insertions, 15 deletions

diff --git a/noncore/styles/liquid/liquid.cpp b/noncore/styles/liquid/liquid.cpp
index 313d52c..acf0a42 100644
--- a/noncore/styles/liquid/liquid.cpp
+++ b/noncore/styles/liquid/liquid.cpp
@@ -17,129 +17,129 @@
 #include <qpalette.h>
 #include <qbitmap.h>
 #include <qtabbar.h>
 #include <qpopupmenu.h>
 #include <qobjectlist.h>
 #include <qimage.h>
 #include <qtimer.h>
 #include <qpixmapcache.h>
 #include <qradiobutton.h>
 #include <qcombobox.h>
 #include <qdrawutil.h>
 #include <qwidgetlist.h>
 #include <qtoolbutton.h>
 #include <qheader.h>
 #include <unistd.h>
 #include <qmenubar.h>
 
 
 #include <stdio.h>
 
 #include "htmlmasks.h"
 #include "embeddata.h"
 
 typedef void (QStyle::*QDrawMenuBarItemImpl) (QPainter *, int, int, int, int, QMenuItem *,
                           QColorGroup &, bool, bool);
 
 QDrawMenuBarItemImpl qt_set_draw_menu_bar_impl(QDrawMenuBarItemImpl impl);
 
 void TransMenuHandler::stripePixmap(QPixmap &pix, const QColor &color)
 {
     QImage img(pix.convertToImage());
     QImageEffect::fade(img, 0.9, color);
     int x, y;
     int r, g, b;
     for(y=0; y < img.height(); y+=3){
         unsigned int *data = (unsigned int  *) img.scanLine(y);
         for(x=0; x < img.width(); ++x){
             r = qRed(data[x]);
             g = qGreen(data[x]);
             b = qBlue(data[x]);
             if(r-10)
                 r-=10;
             if(g-10)
                 g-=10;
             if(b-10)
                 b-=10;
             data[x] = qRgb(r, g, b);
         }
     }
     pix.convertFromImage(img);
 }
 
 TransMenuHandler::TransMenuHandler(QObject *parent)
     : QObject(parent)
 {
     pixDict.setAutoDelete(true);
     reloadSettings();
 }
 
 void TransMenuHandler::reloadSettings()
 {
     pixDict.clear();
 
     Config config ( "qpe" );
-    config. setGroup ( "MosfetMenus" );
+    config. setGroup ( "Liquid-Style" );
 
     type = config. readNumEntry("Type", TransStippleBg);
     color = QColor ( config. readEntry("Color",  QApplication::palette().active().button().name()));
     fgColor = QColor ( config. readEntry("TextColor", QApplication::palette().active().text().name()));
     opacity = config. readNumEntry("Opacity", 10);
     if ( opacity < -20 )
     	opacity = 20;
     else if ( opacity > 20 )
     	opacity = 20;
     
     shadowText = config. readBoolEntry("ShadowText", true);
 }
 
 bool TransMenuHandler::eventFilter(QObject *obj, QEvent *ev)
 {
     QWidget *p = (QWidget *)obj;
 
     if(ev->type() == QEvent::Show){
         if(type == TransStippleBg || type == TransStippleBtn ||
            type == Custom){
             QApplication::syncX();
             QPixmap *pix = new QPixmap;
             if(p->testWFlags(Qt::WType_Popup)){
                 QRect r(p->x(), p->y(), p->width(), p->height());
                 QRect deskR = QApplication::desktop()->rect();
                 if(r.right() > deskR.right() || r.bottom() > deskR.bottom()){
                     r.setBottom(deskR.bottom());
                     r.setRight(deskR.right());
                 }
                 *pix = QPixmap::grabWindow(QApplication::desktop()-> winId(), r.x(), r.y(),
                                            r.width(), r.height());
             }
             else{ // tear off menu
                 pix->resize(p->width(), p->height());
                 pix->fill(Qt::black.rgb());
             }
             if(type == TransStippleBg){
                 stripePixmap(*pix, p->colorGroup().background());
             }
             else if(type == TransStippleBtn){
                 stripePixmap(*pix, p->colorGroup().button());
             }
             else{
                 QPixmapEffect::fade(*pix, (((float)opacity)+80)*0.01, color);
             }
 
             if (p->inherits("QPopupMenu"))
                 pixDict.insert(p->winId(), pix);
             else {
             	p->setBackgroundPixmap(*pix);
             	
             	QObjectList *ol = p-> queryList("QWidget");
 				for ( QObjectListIt it( *ol ); it. current ( ); ++it ) {
 					QWidget *wid = (QWidget *) it.current ( );
 					
 					wid-> setBackgroundPixmap(*pix);
 			    	wid-> setBackgroundOrigin(QWidget::ParentOrigin);					
                 }
 				delete ol;
    			}
         }
     }
     else if(ev->type() == QEvent::Hide){
         if(type == TransStippleBg || type == TransStippleBtn ||
@@ -649,202 +649,209 @@ QPixmap* LiquidStyle::getPixmap(BitmapData item)
         break;
     case HSBSliderBtmHover:
         pixmaps[HSBSliderBtmHover] = processEmbedded("sbslider_btm", btnHoverH, btnHoverS, btnHoverV, true);
         *pixmaps[HSBSliderBtmHover] = pixmaps[HSBSliderBtmHover]->xForm(rMatrix);
         break;
     case HSBSliderMidHover:
         pixmaps[HSBSliderMidHover] = processEmbedded("sbslider_mid", btnHoverH, btnHoverS, btnHoverV);
         *pixmaps[HSBSliderMidHover] = pixmaps[HSBSliderMidHover]->xForm(rMatrix);
         break;
     case VSBSliderTopBg:
         pixmaps[VSBSliderTopBg] = processEmbedded("sbslider_top", bH, bS, bV, true);
         break;
     case VSBSliderBtmBg:
         pixmaps[VSBSliderBtmBg] = processEmbedded("sbslider_btm", bH, bS, bV, true);
         break;
     case VSBSliderMidBg:
         pixmaps[VSBSliderMidBg] = processEmbedded("sbslider_mid", bH, bS, bV);
         break;
     case HSBSliderTopBg:
         pixmaps[HSBSliderTopBg] = processEmbedded("sbslider_top", bH, bS, bV, true);
         *pixmaps[HSBSliderTopBg] = pixmaps[HSBSliderTopBg]->xForm(rMatrix);
         break;
     case HSBSliderBtmBg:
         pixmaps[HSBSliderBtmBg] = processEmbedded("sbslider_btm", bH, bS, bV, true);
         *pixmaps[HSBSliderBtmBg] = pixmaps[HSBSliderBtmBg]->xForm(rMatrix);
         break;
     case HSBSliderMidBg:
         pixmaps[HSBSliderMidBg] = processEmbedded("sbslider_mid", bH, bS, bV);
         *pixmaps[HSBSliderMidBg] = pixmaps[HSBSliderMidBg]->xForm(rMatrix);
         break;
     default:
         break;
     }
     return(pixmaps[item]);
 }
 
 void LiquidStyle::polish(QPalette &appPal)
 {
 
     int i;
     for(i=0; i < BITMAP_ITEMS; ++i){
         if(pixmaps[i]){
             delete pixmaps[i];
             pixmaps[i] = NULL;
         }
     }
     QWidgetList *list = QApplication::allWidgets();
     QWidgetListIt it( *list );
     QWidget *w;
     while ((w=it.current()) != 0 ){
         ++it;
         if(w->inherits("QPushButton")){
             unapplyCustomAttributes((QPushButton *)w);
         }
     }
 
     loadCustomButtons();
     lowLightVal = 100 + (2* /*KGlobalSettings::contrast()*/ 3 +4)*10;
     btnDict.clear();
     btnBorderDict.clear();
     bevelFillDict.clear();
     smallBevelFillDict.clear();
 
     Config config ( "qpe" );
+    config. setGroup ( "Liquid-Style" );
+	int contrast = config. readNumEntry ( "StippleContrast", 5 );
+	if ( contrast < 0 )
+		contrast = 0;
+	else if ( contrast > 10 )
+		contrast = 10;
+
     QPalette pal = QApplication::palette();
 
     // button color stuff
     config. setGroup ( "Appearance" );
     QColor c = QColor ( config. readEntry("Button", ( Qt::lightGray ). name ( )));	
     if ( c == QColor ( config. readEntry ( "background", ( Qt::lightGray ). name ( )))) {
         // force button color to be different from background
         QBrush btnBrush(QColor(200, 202, 228));
         appPal.setBrush(QColorGroup::Button, btnBrush);
     }
     c.hsv(&btnH, &btnS, &btnV);
     c.light(120).hsv(&btnHoverH, &btnHoverS, &btnHoverV);
 
     // menu pixmap
     if(!menuPix){
         menuPix = new QPixmap;
         menuPix->resize(64, 64);
     }
     QPainter painter;
     menuPix->fill(c.rgb());
     painter.begin(menuPix);
     painter.setPen(c.dark(105));
     for(i=0; i < 63; i+=4){
         painter.drawLine(0, i, 63, i);
         painter.drawLine(0, i+1, 63, i+1);
     };
     painter.end();
     menuBrush.setColor(c);
     menuBrush.setPixmap(*menuPix);
 
     // pager brush
     c = c.dark(120);
     QPixmap *pix = smallBevelFillDict.find(c.rgb()); // better be NULL ;-)
     if(!pix){
         int h, s, v;
         c.hsv(&h, &s, &v);
         pix = new QPixmap(*smallBevelFillPix);
         adjustHSV(*pix, h, s, v);
         smallBevelFillDict.insert(c.rgb(), pix);
     }
     pagerHoverBrush.setColor(c);
     pagerHoverBrush.setPixmap(*pix);
 
     c = c.dark(120);
     pix = smallBevelFillDict.find(c.rgb()); // better be NULL ;-)
     if(!pix){
         int h, s, v;
         c.hsv(&h, &s, &v);
         pix = new QPixmap(*smallBevelFillPix);
         adjustHSV(*pix, h, s, v);
         smallBevelFillDict.insert(c.rgb(), pix);
     }
     pagerBrush.setColor(c);
     pagerBrush.setPixmap(*pix);
 
     // background color stuff
     c = QColor ( config. readEntry ( "Background", ( Qt::lightGray ).name ( )));
     c.hsv(&bH, &bS, &bV);
     c.light(120).hsv(&bHoverH, &bHoverS, &bHoverV);
 
     // FIXME?
     if(vsbSliderFillPix)
         delete vsbSliderFillPix;
     vsbSliderFillPix = new QPixmap(bevelFillPix->xForm(rMatrix));
     adjustHSV(*vsbSliderFillPix, bH, bS, bV);
 
     // background brush
     QPixmap wallPaper(32, 32);
     wallPaper.fill(c.rgb());
     painter.begin(&wallPaper);
     for(i=0; i < 32; i+=4){
-        painter.setPen(c.dark(105));
+        painter.setPen(c.dark(100 + contrast));
         painter.drawLine(0, i, 32, i);
-        painter.setPen(c.dark(103));
+        painter.setPen(c.dark(100 + 3 * contrast / 5 ) );
         painter.drawLine(0, i+1, 32, i+1);
     };
     painter.end();
     bgBrush.setColor(c);
     bgBrush.setPixmap(wallPaper);
     appPal.setBrush(QColorGroup::Background, bgBrush);
 
     // lineedits
     c = QColor ( config. readEntry("Base", ( Qt::white). name ( )));
     QPixmap basePix;
     basePix.resize(32, 32);
     basePix.fill(c.rgb());
     painter.begin(&basePix);
     painter.setPen(c.dark(105));
     for(i=0; i < 32; i+=4){
         painter.drawLine(0, i, 32, i);
         painter.drawLine(0, i+1, 32, i+1);
     };
     painter.end();
     baseBrush.setColor(c);
     baseBrush.setPixmap(basePix);
     it.toFirst();
     while ((w=it.current()) != 0 ){
         ++it;
         if(w->inherits("QLineEdit")){
             QPalette pal = w->palette();
             pal.setBrush(QColorGroup::Base, baseBrush);
             w->setPalette(pal);
         }
         else if(w->inherits("QPushButton")){
             applyCustomAttributes((QPushButton *)w);
         }
     }
 
 }
 
 void LiquidStyle::polish(QWidget *w)
 {
     if(w->inherits("QMenuBar")){
         //((QFrame*)w)->setLineWidth(0);
         w->setBackgroundMode(QWidget::PaletteBackground);
         return;
     }
     if(w->inherits("QPopupMenu"))
         w->setBackgroundMode(QWidget::NoBackground);
     else if(w-> testWFlags(Qt::WType_Popup) && !w->inherits("QListBox")) {
     	w->installEventFilter(menuHandler);
     }
     
     if(w->isTopLevel()){
         return;
     }
    
     
     w-> setBackgroundOrigin ( QWidget::ParentOrigin );
 
     if(w->inherits("QComboBox") ||
        w->inherits("QLineEdit") || w->inherits("QRadioButton") ||
        w->inherits("QCheckBox") || w->inherits("QScrollBar")) {
         w->installEventFilter(this);
     }
     if(w->inherits("QLineEdit")){
         QPalette pal = w->palette();
         pal.setBrush(QColorGroup::Base, baseBrush);
@@ -928,128 +935,132 @@ void LiquidStyle::unPolish(QWidget *w)
     }
 
     if(w->isTopLevel())
         return;
 
     // for viewport children, don't just check for NoBackground....
     bool isViewportChild = w->parent() &&
         ((qstrcmp(w->parent()->name(), "qt_viewport") == 0) ||
          (qstrcmp(w->parent()->name(), "qt_clipped_viewport") == 0));
 
     w->setPalette(QApplication::palette());
     if(w->backgroundMode() == QWidget::X11ParentRelative || isViewportChild){
         if(w->inherits("QPushButton"))
             w->setBackgroundMode(QWidget::PaletteButton);
         else
             w->setBackgroundMode(QWidget::PaletteBackground);
     }
 
     if(isViewportChild)
         w->setAutoMask(false);
 
     if(w->inherits("QPushButton")){
         unapplyCustomAttributes((QPushButton *)w);
         w->removeEventFilter(this);
     }
 /*
     if(w->inherits("QPushButton") || w-> inherits("QComboBox")){
     	w-> setBackgroundMode ( PaletteBackground );
     }
 */
     if(w->inherits("QComboBox") ||
        w->inherits("QLineEdit") || w->inherits("QRadioButton") ||
        w->inherits("QCheckBox") || w->inherits("QScrollBar")) {
         w->removeEventFilter(this);
     }
     if(w->inherits("QButton") || w->inherits("QComboBox")){
         if(w->parent() && w->parent()->inherits("KHTMLPart")){
             w->setAutoMask(false);
         }
     }
     if(w->inherits("QToolBar")){
         w->removeEventFilter(this);
         w->setBackgroundMode(QWidget::PaletteBackground);
         return;
     }
     if(w->inherits("QHeader")){
         w->setMouseTracking(false);
         w->removeEventFilter(this);
     }
 }
 
 void LiquidStyle::polish(QApplication *app)
 {
 
     QWindowsStyle::polish(app);
     menuAni = app->isEffectEnabled(UI_AnimateMenu);
     menuFade = app->isEffectEnabled(UI_FadeMenu);
     if(menuAni)
         app->setEffectEnabled(UI_AnimateMenu, false);
     if(menuFade)
         app->setEffectEnabled(UI_FadeMenu, false);
 	
     qt_set_draw_menu_bar_impl((QDrawMenuBarItemImpl) &LiquidStyle::drawMenuBarItem);
     
+    Config config ( "qpe" );
+    config. setGroup ( "Liquid-Style" );
+    
+    if ( config. readBoolEntry ( "WinDecoration", true ))	
     QApplication::qwsSetDecoration ( new LiquidDecoration ( ));
 }
 
 void LiquidStyle::unPolish(QApplication *app)
 {
     QWindowsStyle::unPolish(app);
     app->setEffectEnabled(UI_AnimateMenu, menuAni);
     app->setEffectEnabled(UI_FadeMenu, menuFade);
 
     qt_set_draw_menu_bar_impl ( 0 );
     
     QApplication::qwsSetDecoration ( new QPEDecoration ( ));
 }
 
 /*
  * This is a fun method ;-) Here's an overview. KToolBar grabs resize to
  * force everything to erase and repaint on resize. This is going away, I'm
  * trying to get shaped widgets to work right without masking. QPushButton,
  * QComboBox, and Panel applet handles capture mouse enter and leaves in order
  * to set the highlightwidget and repaint for mouse hovers. CheckBoxes and
  * RadioButtons need to do this differently. Qt buffers these in pixmaps and
  * caches them in QPixmapCache, which is bad for doing things like hover
  * because the style methods aren't called in paintEvents if everything
  * is cached. We use our own Paint event handler instead. Taskbuttons and
  * pager buttons draw into a pixmap buffer, so we handle those with palette
  * modifications. For QHeader, different header items are actually one widget
  * that draws multiple items, so we need to check which ID is hightlighted
  * and draw it. Finally, we also check enter and leave events for QLineEdit,
  * since if it's inside a combobox we want to highlight the combobox during
  * hovering in the edit.
  */
 bool LiquidStyle::eventFilter(QObject *obj, QEvent *ev)
 {
     if(obj->inherits("QToolBar")){
         if(ev->type() == QEvent::Resize){
             const QObjectList *tbChildList = obj->children();
             QObjectListIt it(*tbChildList);
             QObject *child;
             while((child = it.current()) != NULL){
                 ++it;
                 if(child->isWidgetType())
                     ((QWidget *)child)->repaint(true);
             }
 
         }
     }
     else if(obj->inherits("QPushButton") || obj->inherits("QComboBox")){
         QWidget *btn = (QWidget *)obj;
         if(ev->type() == QEvent::Enter){
             if(btn->isEnabled()){
                 highlightWidget = btn;
                 btn->repaint(false);
             }
         }
         else if(ev->type() == QEvent::Leave){
             if(btn == highlightWidget){
                 highlightWidget = NULL;
                 btn->repaint(false);
             }
         }
     }
     else if(obj->inherits("QToolButton")){
         QToolButton *btn = (QToolButton *)btn;
         if(!btn->autoRaise()){
diff --git a/noncore/styles/liquid/liquiddeco.cpp b/noncore/styles/liquid/liquiddeco.cpp
index 8eee1b1..5488c67 100644
--- a/noncore/styles/liquid/liquiddeco.cpp
+++ b/noncore/styles/liquid/liquiddeco.cpp
@@ -37,147 +37,141 @@
 
 #include "liquiddeco.h"
 
 #include <stdlib.h>
 
 extern QRect qt_maxWindowRect;
 
 class HackWidget : public QWidget
 {
 public:
 	bool needsOk()
 	{
 		return ( getWState() & WState_Reserved1 );
 	}
 };
 
 
 LiquidDecoration::LiquidDecoration()
 		: QPEDecoration()
 {}
 
 LiquidDecoration::~LiquidDecoration()
 {}
 
 int LiquidDecoration::getTitleHeight( const QWidget * )
 {
 	return 15;
 }
 
 
 void LiquidDecoration::paint( QPainter *painter, const QWidget *widget )
 {
 	int titleWidth = getTitleWidth( widget );
 	int titleHeight = getTitleHeight( widget );
 
 	QRect rect( widget->rect() );
 
 	// Border rect
 	QRect br( rect.left() - BORDER_WIDTH,
 	          rect.top() - BORDER_WIDTH - titleHeight,
 	          rect.width() + 2 * BORDER_WIDTH,
 	          rect.height() + BORDER_WIDTH + BOTTOM_BORDER_WIDTH + titleHeight );
 
 	// title bar rect
 	QRect tr;
 
 	tr = QRect( rect.left(), rect.top() - titleHeight, rect.width(), titleHeight );
 
 	QRegion oldClip = painter->clipRegion();
 	painter->setClipRegion( oldClip - QRegion( tr ) );	// reduce flicker
 
 	bool isActive = ( widget == qApp->activeWindow() );
 
 	QColorGroup cg = QApplication::palette().active();
 	if ( isActive )
 		cg. setBrush ( QColorGroup::Button, cg. brush ( QColorGroup::Highlight ) );
 
 	qDrawWinPanel( painter, br.x(), br.y(), br.width(),
 	               br.height() - 4, cg, FALSE,
 	               &cg.brush( QColorGroup::Background ) );
 
 	painter->setClipRegion( oldClip );
 
 	if ( titleWidth > 0 ) {
-		QBrush titleBrush;
-		QPen titlePen;
-		QPen titleLines;
-		int titleLeft = titleHeight + 4;
-
-		titleLeft = rect.left() + 5;
 		painter->setPen( cg.midlight() );
 		painter->drawLine( rect.left() - BORDER_WIDTH + 2,
 		                   rect.bottom() + 1, rect.right() + BORDER_WIDTH - 2,
 		                   rect.bottom() + 1 );
 
 		QRect t ( rect.left() - 2, rect.top() - titleHeight - 2, rect.width() + 3, titleHeight + 2 );
 
 
 
 		QApplication::style().drawBevelButton( painter, t.x(), t.y(), t.width(), t.height(), cg, isActive );
 
 		t.setLeft( t.left() + 4 );
 		t.setRight( t.right() - 2 );
 
 		QFont f( QApplication::font() );
 		f.setWeight( QFont::Bold );
 
 		painter-> setFont( f );
 
 		QColor textcol = cg.color( isActive ? QColorGroup::HighlightedText : QColorGroup::Text );
-		QColor shadecol = ( qGray ( textcol. rgb ( ) ) > 128 ) ? textcol. dark ( 130 ) : textcol.light( 200 );
+		QColor shadecol = ( qGray ( textcol. rgb ( ) ) > 128 ) ? textcol. dark ( 230 ) : textcol.light( 300 );
 
 		if ( textcol == shadecol ) {
 			if ( qGray ( shadecol. rgb ( ) ) < 128 )
 				shadecol = QColor ( 225, 225, 225 );
 			else
 				shadecol = QColor ( 30, 30, 30 );
 		}
 
 		painter-> setPen( shadecol );
 		painter-> drawText( t.x() + 1, t.y() + 1, t.width(), t.height(), Qt::AlignLeft | Qt::AlignVCenter | Qt::SingleLine, widget->caption() );
 		painter-> setPen( textcol );
 		painter-> drawText( t.x(), t.y(), t.width(), t.height(), Qt::AlignLeft | Qt::AlignVCenter | Qt::SingleLine, widget->caption() );
 	}
 
 #ifndef MINIMIZE_HELP_HACK
 	paintButton( painter, widget, ( QWSDecoration::Region ) Help, 0 );
 #endif
 }
 
 void LiquidDecoration::paintButton( QPainter *painter, const QWidget *w,
                                     QWSDecoration::Region type, int state )
 {
 	const QColorGroup & cg = w->palette().active();
 
 	QRect brect( region( w, w->rect(), type ).boundingRect() );
 
 	const QImage *img = 0;
 
 	switch ( ( int ) type ) {
 		case Close:
 			img = &imageClose;
 			break;
 		case Minimize:
 			if ( ( ( HackWidget * ) w ) ->needsOk() ||
 			        ( w->inherits( "QDialog" ) && !w->inherits( "QMessageBox" ) ) )
 				img = &imageOk;
 			else if ( helpExists )
 				img = &imageHelp;
 			break;
 		case Help:
 			img = &imageHelp;
 			break;
 		default:
 			return ;
 	}
 
 	if ( img ) {
 		if ( ( state & QWSButton::MouseOver ) && ( state & QWSButton::Clicked ) ) 
 			painter->drawImage( brect.x() + 1, brect.y() + 3, *img );
 		else 
 			painter->drawImage( brect.x(), brect.y() + 2, *img );
 	}
 }
 
 
 
diff --git a/noncore/styles/liquid/settings/liquidset.cpp b/noncore/styles/liquid/settings/liquidset.cpp
index 0ef5dbe..1479ac0 100644
--- a/noncore/styles/liquid/settings/liquidset.cpp
+++ b/noncore/styles/liquid/settings/liquidset.cpp
@@ -1,199 +1,234 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 
 
 #include "liquidset.h"
 #include "../liquid.h"
 
 #include <qpe/qpeapplication.h>
 #include <qpe/global.h>
 
 #include <qslider.h>
 #include <qtoolbutton.h>
 #include <qbuttongroup.h>
 #include <qradiobutton.h>
 #include <qcheckbox.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qpalette.h>
 
 #include <qpe/config.h>
 
 #include <opie/colorpopupmenu.h>
 
 
 static void changeButtonColor ( QWidget *btn, const QColor &col )
 {
 	QPalette pal = btn-> palette ( );
 
+	pal. setColor ( QPalette::Normal, QColorGroup::Button, col );
 	pal. setColor ( QPalette::Active, QColorGroup::Button, col );
 	pal. setColor ( QPalette::Disabled, QColorGroup::Button, col );
 	pal. setColor ( QPalette::Inactive, QColorGroup::Button, col );
+	pal. setColor ( QPalette::Normal, QColorGroup::Background, col );
+	pal. setColor ( QPalette::Active, QColorGroup::Background, col );
+	pal. setColor ( QPalette::Disabled, QColorGroup::Background, col );
+	pal. setColor ( QPalette::Inactive, QColorGroup::Background, col );
 
 	btn-> setPalette ( pal );
 }
 
 
 LiquidSet::LiquidSet ( QWidget* parent, const char *name, WFlags fl )
 		: QDialog ( parent, name, fl )
 {
 	setCaption ( tr( "Liquid Style" ) );
 	
 	Config config ( "qpe" );
-    config. setGroup ( "MosfetMenus" );
+    config. setGroup ( "Liquid-Style" );
 
 	m_type      = config. readNumEntry ( "Type", TransStippleBg );
 	m_menucol   = QColor ( config. readEntry ( "Color",  QApplication::palette ( ). active ( ). button ( ). name ( )));
 	m_textcol   = QColor ( config. readEntry ( "TextColor", QApplication::palette ( ). active ( ). text ( ). name ( )));
 	int opacity = config. readNumEntry ( "Opacity", 10 );
 	m_shadow    = config. readBoolEntry ( "ShadowText", true );
+	m_deco       = config. readBoolEntry ( "WinDecoration", true );
+	int contrast = config. readNumEntry ( "StippleContrast", 5 );
 
 	QVBoxLayout *vbox = new QVBoxLayout ( this );
 	vbox-> setSpacing ( 3 );
 	vbox-> setMargin ( 6 );
 
 	QButtonGroup *btngrp = new QButtonGroup ( this );
 	btngrp-> hide ( );
 
 	QRadioButton *rad;
 	
 	rad = new QRadioButton ( tr( "No translucency" ), this );
 	btngrp-> insert ( rad, None );
 	vbox-> addWidget ( rad );
 	
 	rad = new QRadioButton ( tr( "Stippled, background color" ), this );
 	btngrp-> insert ( rad, StippledBg );
 	vbox-> addWidget ( rad );
 	
 	rad = new QRadioButton ( tr( "Stippled, button color" ), this );
 	btngrp-> insert ( rad, StippledBtn );
 	vbox-> addWidget ( rad );
 	
 	rad = new QRadioButton ( tr( "Translucent stippled, background color" ), this );
 	btngrp-> insert ( rad, TransStippleBg );
 	vbox-> addWidget ( rad );
 	
 	rad = new QRadioButton ( tr( "Translucent stippled, button color" ), this );
 	btngrp-> insert ( rad, TransStippleBtn );
 	vbox-> addWidget ( rad );
 	
 	rad = new QRadioButton ( tr( "Custom translucency" ), this );
 	btngrp-> insert ( rad, Custom );
 	vbox-> addWidget ( rad );
 	
 	btngrp-> setExclusive ( true );
 	btngrp-> setButton ( m_type );
 	
 	QGridLayout *grid = new QGridLayout ( vbox );
 	grid-> addColSpacing ( 0, 16 );
 	grid-> addColSpacing ( 3, 8 );
 	
 	grid-> addWidget ( m_menulbl = new QLabel ( tr( "Menu color" ), this ), 0, 1 );
 	grid-> addWidget ( m_textlbl = new QLabel ( tr( "Text color" ), this ), 0, 4 );
 	grid-> addWidget ( m_opaclbl = new QLabel ( tr( "Opacity" ), this ), 1, 1 );
 
 	m_menubtn = new QToolButton ( this );
 	grid-> addWidget ( m_menubtn, 0, 2 );
 
 	QPopupMenu *popup;
 
 	popup = new ColorPopupMenu ( m_menucol, this );
 	m_menubtn-> setPopup ( popup );
 	m_menubtn-> setPopupDelay ( 0 );
 	connect ( popup, SIGNAL( colorSelected ( const QColor & )), this, SLOT( changeMenuColor ( const QColor & )));
 	changeMenuColor ( m_menucol );
 
 	m_textbtn = new QToolButton ( this );
 	grid-> addWidget ( m_textbtn, 0, 5 );
 
 	popup = new ColorPopupMenu ( m_textcol, this );
 	m_textbtn-> setPopup ( popup );
 	m_textbtn-> setPopupDelay ( 0 );
 	connect ( popup, SIGNAL( colorSelected ( const QColor & )), this, SLOT( changeTextColor ( const QColor & )));
 	changeTextColor ( m_textcol );
 
 	m_opacsld = new QSlider ( Horizontal, this );
 	m_opacsld-> setRange ( -20, 20 );
 	m_opacsld-> setValue ( opacity );
 	m_opacsld-> setTickmarks ( QSlider::Below );
 	grid-> addMultiCellWidget ( m_opacsld, 1, 1, 2, 5 );
 	
 	vbox-> addSpacing ( 4 );
 	
-	QCheckBox *shadow = new QCheckBox ( tr( "Use shadowed text" ), this );
+	QCheckBox *shadow = new QCheckBox ( tr( "Use shadowed menu text" ), this );
 	shadow-> setChecked ( m_shadow );
 	vbox-> addWidget ( shadow );
 	
+	vbox-> addSpacing ( 4 );
+	
+	QCheckBox *windeco = new QCheckBox ( tr( "Draw liquid window title bars" ), this );
+	windeco-> setChecked ( m_deco );
+	vbox-> addWidget ( windeco );
+
+	vbox-> addSpacing ( 4 );
+	
+	QHBoxLayout *hbox = new QHBoxLayout ( vbox );
+	
+	hbox-> addWidget ( new QLabel ( tr( "Stipple contrast" ), this )); 
+	
+	m_contsld = new QSlider ( Horizontal, this );
+	m_contsld-> setRange ( 0, 10 );
+	m_contsld-> setValue ( contrast );
+	m_contsld-> setTickmarks ( QSlider::Below );
+	hbox-> addWidget ( m_contsld, 10 );
+	
 	vbox-> addStretch ( 10 );
 	
+	changeType ( m_type );
+	
 	connect ( btngrp, SIGNAL( clicked ( int ) ), this, SLOT( changeType ( int ) ) );
 	connect ( shadow, SIGNAL( toggled ( bool ) ), this, SLOT( changeShadow ( bool ) ) );
+	connect ( windeco, SIGNAL( toggled ( bool ) ), this, SLOT( changeDeco ( bool ) ) );
 }
 
 void LiquidSet::changeType ( int t )
 {
 	bool custom = ( t == Custom );
 	
 	m_menulbl-> setEnabled ( custom );	
 	m_textlbl-> setEnabled ( custom );	
 	m_opaclbl-> setEnabled ( custom );	
 	m_menubtn-> setEnabled ( custom );	
 	m_textbtn-> setEnabled ( custom );	
 	m_opacsld-> setEnabled ( custom );	
 	
 	m_type = t;
 }
 
 void LiquidSet::changeMenuColor ( const QColor &col )
 {
-	m_menubtn-> setPalette ( col );
+	changeButtonColor ( m_menubtn, col );
 	m_menucol = col;
 }
 
 void LiquidSet::changeTextColor ( const QColor &col )
 {
-	m_textbtn-> setPalette ( col );
+	changeButtonColor ( m_textbtn, col );
 	m_textcol = col;
 }
 
 void LiquidSet::changeShadow ( bool b )
 {
 	m_shadow = b;
 }
 
+void LiquidSet::changeDeco ( bool b )
+{
+	m_deco = b;
+}
+
 
 void LiquidSet::accept ( )
 {
 	Config config ( "qpe" );
-    config. setGroup ( "MosfetMenus" );
+    config. setGroup ( "Liquid-Style" );
 
 	config. writeEntry ( "Type", m_type  );
 	config. writeEntry ( "Color",  m_menucol. name ( ));
 	config. writeEntry ( "TextColor", m_textcol. name ( ));
 	config. writeEntry ( "Opacity", m_opacsld-> value ( ));
 	config. writeEntry ( "ShadowText", m_shadow );	
+	config. writeEntry ( "WinDecoration", m_deco );
+	config. writeEntry ( "StippleContrast", m_contsld-> value ( ));
 	config. write ( );
 
 	Global::applyStyle ( );
 
 	QDialog::accept ( );
 }
 
diff --git a/noncore/styles/liquid/settings/liquidset.h b/noncore/styles/liquid/settings/liquidset.h
index 944b1ec..a0f590a 100644
--- a/noncore/styles/liquid/settings/liquidset.h
+++ b/noncore/styles/liquid/settings/liquidset.h
@@ -1,39 +1,42 @@
 #ifndef __OPIE_LIQUID_SET_H__
 #define __OPIE_LIQUID_SET_H__
 
 #include <qdialog.h>
 #include <qcolor.h>
 
 class QLabel;
 class QToolButton;
 class QSlider;
 
 class LiquidSet : public QDialog {
 	Q_OBJECT
 	
 public:
 	LiquidSet ( QWidget *parent = 0, const char *name = 0, WFlags fl = 0 );
 
 public slots:
 	void changeType ( int t );
 	void changeMenuColor ( const QColor &col );
 	void changeTextColor ( const QColor &col );
 	void changeShadow ( bool b );
+	void changeDeco ( bool b );
 
 protected:
 	virtual void accept ( );
 	
 private:
 	QColor m_menucol;
 	QColor m_textcol;
 	int    m_type;
 	bool   m_shadow;
+	bool   m_deco;
 	
 	QSlider *    m_opacsld;
+	QSlider *    m_contsld;
 	QLabel *     m_menulbl;
 	QLabel *     m_textlbl;
 	QLabel *     m_opaclbl;
 	QToolButton *m_menubtn;
 	QToolButton *m_textbtn;
 };
 #endif