summaryrefslogtreecommitdiffstats
path: root/style
diff options
context:
space:
mode:
Diffstat (limited to 'style')
-rw-r--r--style/Makefile.am16
-rw-r--r--style/baghira.cpp3384
-rw-r--r--style/baghira.h627
-rw-r--r--style/baghira.themerc6
-rw-r--r--style/bitmaps.h21
-rw-r--r--style/configure.in.in5
-rw-r--r--style/eventfilter.cpp990
-rw-r--r--style/fracts.h74
-rwxr-xr-xstyle/generatePixmaps.sh54
-rw-r--r--style/optionHandler.cpp251
-rw-r--r--style/polish.cpp878
-rw-r--r--style/utils.cpp1418
12 files changed, 7724 insertions, 0 deletions
diff --git a/style/Makefile.am b/style/Makefile.am
new file mode 100644
index 0000000..2094915
--- /dev/null
+++ b/style/Makefile.am
@@ -0,0 +1,16 @@
+AM_CPPFLAGS = -DQT_PLUGIN
+
+INCLUDES = -I$(top_srcdir)/kdefx $(all_includes)
+noinst_HEADERS = baghira.h pixmaps.h bitmaps.h
+METASOURCES = AUTO
+kde_style_LTLIBRARIES = baghira.la
+baghira_la_LDFLAGS = $(all_libraries) $(KDE_PLUGIN) -module
+baghira_la_LIBADD = -lkdefx -lXtst $(LIB_KDEUI)
+baghira_la_SOURCES = baghira.cpp optionHandler.cpp polish.cpp utils.cpp
+lnkdir = $(kde_datadir)/kstyle/themes
+lnk_DATA = baghira.themerc
+EXTRA_DIST = $(lnk_DATA)
+pixmaps.h: $(srcdir)/generatePixmaps.sh
+ $(SHELL) $(srcdir)/generatePixmaps.sh $(top_srcdir)
+CLEANFILES = pixmaps.h
+baghira.lo: pixmaps.h
diff --git a/style/baghira.cpp b/style/baghira.cpp
new file mode 100644
index 0000000..bae1611
--- /dev/null
+++ b/style/baghira.cpp
@@ -0,0 +1,3384 @@
+#include "baghira.h"
+#include "bitmaps.h"
+#include "pixmaps.h"
+//#include "../deco/baghiradecobuttons.h"
+
+#include <qapplication.h>
+#include <qbitmap.h>
+#include <qbrush.h>
+#include <qbutton.h>
+#include <qcleanuphandler.h>
+#include <qcolor.h>
+#include <qcombobox.h>
+//#include <qevent.h>
+#include <qfont.h>
+#include <qframe.h>
+#include <qgroupbox.h>
+#include <qheader.h>
+#include <qiconset.h>
+#include <qimage.h>
+#include <qlayout.h>
+#include <qlistbox.h>
+#include <qlistview.h>
+#include <qmenubar.h>
+#include <qobject.h>
+#include <qobjectlist.h>
+#include <qpaintdevice.h>
+#include <qpainter.h>
+#include <qpalette.h>
+#include <qpen.h>
+#include <qpoint.h>
+#include <qpopupmenu.h>
+#include <qpushbutton.h>
+//#include <qrangecontrol.h>
+#include <qrect.h>
+#include <qscrollbar.h>
+#include <qscrollview.h>
+#include <qsize.h>
+#include <qslider.h>
+#include <qstring.h>
+#include <qstyleplugin.h>
+#include <qtabbar.h>
+#include <qtabwidget.h>
+#include <qvariant.h>
+#include <ktoolbar.h>
+#include <ktoolbarbutton.h>
+#include <kwordwrap.h>
+#include "config.h"
+
+#define PRINTDEVICE(p) qWarning("device is %s", (p->device()->devType() == QInternal::Widget) ?\
+"Widget": (p->device()->devType() == QInternal::Pixmap) ?\
+"Pixmap": (p->device()->devType() == QInternal::Printer) ?\
+"Printer": (p->device()->devType() == QInternal::Picture) ?\
+"Picture": (p->device()->devType() == QInternal::UndefinedDevice) ?\
+"UndefinedDevice": "fuckdevice!" );
+
+#define GCC_VERSION (__GNUC__ * 10000 \
++ __GNUC_MINOR__ * 100 \
++ __GNUC_PATCHLEVEL__)
+
+static const int windowsItemFrame = 1; // menu item frame width
+static const int windowsSepHeight = 2; // separator item height
+static const int windowsItemHMargin = 3; // menu item hor text margin
+static const int windowsItemVMargin = 1; // menu item ver text margin
+static const int windowsArrowHMargin = 6; // arrow horizontal margin
+static const int windowsTabSpacing = 12; // space between text and tab
+static const int windowsCheckMarkHMargin = 2; // horiz. margins of check mark
+static const int windowsRightBorder = 12; // right border on windows
+static const int windowsCheckMarkWidth = 12; // checkmarks width on windows
+
+// options
+int OptionHandler::menuBackground;
+int OptionHandler::menuOpacity;
+bool OptionHandler::menuColorButton;
+bool OptionHandler::shadowText;
+//color
+QColor OptionHandler::customButtonColor, OptionHandler::menuStripeColor_;
+//widgets
+bool OptionHandler::customWidgetColor;
+QColor OptionHandler::customColors[ 10 ];
+//menu
+bool OptionHandler::useCustomMenuColor;
+QColor OptionHandler::color, OptionHandler::color2, OptionHandler::colorHigh, OptionHandler::fgColor, OptionHandler::fgColorHigh;
+//Panel
+// bool OptionHandler::panelCustom;
+// QColor OptionHandler::customPanelColor;
+//incativeButton
+int OptionHandler::inactiveButtonColor;
+QColor OptionHandler::customInactiveButtonColor;
+
+//Design
+//stipples
+bool OptionHandler::bgStipple, /*OptionHandler::panelStipple,*/ OptionHandler::bevelHighlights_, OptionHandler::drawMenuStripe_, OptionHandler::glossyMenus_;
+Style OptionHandler::style_;
+int OptionHandler::contrast;
+//shadows
+bool OptionHandler::groupboxshadow;
+int OptionHandler::shadowDarkness;
+//istviews;
+bool OptionHandler::drawDotlines, OptionHandler::useCustomExpanderColor;
+int OptionHandler::expanderStyle;
+QColor OptionHandler::expanderColor, OptionHandler::dotlineColor;
+int OptionHandler::dotlineStyle;
+//slider
+bool OptionHandler::squeezesbslider;
+bool OptionHandler::shadowsbslider;
+bool OptionHandler::animateSlider;
+bool OptionHandler::animateProgress;
+//toolbar
+bool OptionHandler::reverseBtnColor, OptionHandler::tbFrame;
+//tweaks
+bool OptionHandler::centerTabs;
+bool OptionHandler::smoothListViewHeaders;
+bool OptionHandler::smootherLVH;
+bool OptionHandler::icyButtons;
+Style OptionHandler::_buttonStyle;
+int OptionHandler::progressBar;
+bool OptionHandler::removeKickerBevel;
+Style OptionHandler::_toolbuttonStyle;
+bool OptionHandler::drawProgressLabel;
+QColor OptionHandler::brushTint;
+QColor OptionHandler::aDecoColor1_;
+QColor OptionHandler::aDecoColor2_;
+QColor OptionHandler::titleColor_[2];
+QColor OptionHandler::titleButtonColor_[3];
+bool OptionHandler::tintBrush;
+tabStyle OptionHandler::tabStyle_;
+unsigned long OptionHandler::wmDesign;
+bool OptionHandler::animateButton;
+int OptionHandler::custCols[8];
+
+QPixmap LiquidStyle::popupBack;
+
+//============
+
+class KAccessToolBarButton : public KToolBarButton
+{
+// to get me access to the toolbbar
+ friend class LiquidStyle;
+public:
+ KAccessToolBarButton( QWidget* parent=0, const char* name=0 )
+ : KToolBarButton( parent, name ) {}
+};
+
+
+class LiquidStylePlugin : public QStylePlugin {
+ public:
+ LiquidStylePlugin() {
+ ;
+ }
+ ~LiquidStylePlugin() {
+ ;
+ }
+
+ QStringList keys() const {
+ return ( QStringList() << "Baghira" );
+ }
+ QStyle *create( const QString & );
+ };
+
+QStyle *LiquidStylePlugin::create( const QString &s ) {
+ if ( s.lower() == "baghira" )
+ return ( new LiquidStyle() );
+ return ( 0 );
+ }
+
+Q_EXPORT_PLUGIN( LiquidStylePlugin )
+
+static const int itemFrame = 1;
+static const int itemHMargin = 3;
+static const int itemVMargin = 1;
+static const int arrowHMargin = 6;
+static const int rightBorder = 12;
+
+
+LiquidStyle::LiquidStyle() : KStyle( AllowMenuTransparency | FilledFrameWorkaround, ThreeButtonScrollBar )
+{
+ QIntDict<ButtonFadeInfo>bfi(31);// assuming 31 btns will be enough - a pointer list would be more accurate, but we need to lookup this every 50ms...
+ QIntDict<ButtonTile>btnShadowedDict(223);// we need around 10/color, 3 colors/button assuming 10 different colors (e.g. kcalc)
+ QIntDict<ButtonTile>buttonGlowDict(109);
+ QIntDict<ButtonTile>buttonDict(331);
+ headerHoverID = -1;
+ headerSortID = -1;
+ hoveredTabIndex = -1;
+ currentTabBar = 0L;
+ paintWidget = 0L;
+ highlightWidget = 0L;
+ currentTaskContainer = 0L;
+ taskContainerHover = false;
+ isTaskContainer = false;
+ isHTMLButton = false;
+ inExitPolish = false;
+ inactiveRoundFrame = 0L;
+ activeRoundFrame = 0L;
+ eventKiller = new EventKiller;
+ bmShower = 0L; // only if b/m
+
+ btnDict.setAutoDelete( true );
+ btnShadowedDict.setAutoDelete( true );
+ bfi.setAutoDelete( true );
+// inverseTabDict.setAutoDelete( true );
+// tabDict.setAutoDelete( true );
+ initialPaletteLoaded = false;
+ qtrcModificationTime = 0;
+
+ // animations kram!
+ progAnimShift = 0;
+ prog2AnimShift = 0;
+ sliderAnimShift = 0;
+ QTimer* timer = new QTimer( this );
+ timer->start(50, false);
+// if (optionHandler->AnimateProgress())
+ connect(timer, SIGNAL(timeout()), this, SLOT(updateProgressPos()));
+ activeScroller = NULL;
+ //--------------------------------------
+
+ tooltipPalette = qApp->palette();
+ tooltipPalette.setBrush( QColorGroup::Background, QColor( 255, 255, 220 ) );
+ tooltipPalette.setBrush( QColorGroup::Foreground, Qt::black );
+
+ rMatrix.rotate( 90.0 );
+ lMatrix.rotate( 270.0 );
+ iMatrix.rotate( 180.0 );
+ mMatrix.setMatrix ( -1, 0, 0, 1, 0, 0);
+ m2Matrix.setMatrix ( 1, 0, 0, -1, 0, 0);
+
+ optionHandler = new OptionHandler( this );
+ if (optionHandler->style() != Milk && optionHandler->AnimateSlider())
+ connect(timer, SIGNAL(timeout()), this, SLOT(updateSliderPos()));
+ if (optionHandler->style() == Brushed)
+ bmShower = new BMShower(this);
+
+ switch (optionHandler->buttonStyle())
+ {
+ case Jaguar:
+ btnBorderImg = new QImage( uic_findImage("button-jaguar") );
+ btnShadowImg = new QImage( uic_findImage( "button-shadow" ) );
+ buttonGlow = new QImage( uic_findImage( "button-glow" ) );
+ combo = new QImage( uic_findImage("combo-jaguar") );
+ comboShadow = new QImage( uic_findImage( "combo-shadow" ) );
+ if (optionHandler->toolbuttonStyle() == Brushed || !optionHandler->SmoothListViewHeaders())
+ rectbutton = new QImage( uic_findImage( "rectbutton" ) );
+ else rectbutton = 0L;
+ break;
+ case Panther:
+ case Tiger:
+ btnBorderImg = new QImage( uic_findImage("button-base") );
+ btnShadowImg = new QImage( uic_findImage( "button-shadow" ) );
+ buttonGlow = new QImage( uic_findImage( "button-glow" ) );
+ combo = new QImage( uic_findImage("combo") );
+ comboShadow = new QImage( uic_findImage( "combo-shadow" ) );
+ if (optionHandler->toolbuttonStyle() == Brushed || !optionHandler->SmoothListViewHeaders())
+ rectbutton = new QImage( uic_findImage( "rectbutton" ) );
+ else rectbutton = 0L;
+ break;
+ case Brushed:
+ btnBorderImg = 0L;
+ btnShadowImg = 0L;
+ buttonGlow = 0L;
+ rectbutton = new QImage( uic_findImage( "rectbutton" ) );
+ switch (optionHandler->toolbuttonStyle())
+ {
+ case Jaguar:
+ combo = new QImage( uic_findImage("combo-jaguar") );
+ comboShadow = new QImage( uic_findImage( "combo-shadow" ) );
+ break;
+ case Panther:
+ case Tiger:
+ case Brushed:
+ combo = new QImage( uic_findImage("combo") );
+ comboShadow = new QImage( uic_findImage( "combo-shadow" ) );
+ break;
+ case Milk:
+ combo = new QImage( uic_findImage("combo-milk") );
+ comboShadow = new QImage( uic_findImage( "combo-shadow" ) );
+ default:
+ break;
+ }
+ break;
+ case Milk:
+ btnBorderImg = new QImage( uic_findImage("button-milk") );
+ btnShadowImg = 0L;
+ buttonGlow = 0L;
+ combo = new QImage( uic_findImage("combo-milk") );
+ comboShadow = new QImage( uic_findImage( "combo-shadow" ) );
+ if (optionHandler->toolbuttonStyle() == Brushed || !optionHandler->SmoothListViewHeaders())
+ rectbutton = new QImage( uic_findImage( "rectbutton" ) );
+ else rectbutton = 0L;
+ default:
+ break;
+ }
+
+ if ( btnBorderImg && btnBorderImg->depth() < 32 )
+ * btnBorderImg = btnBorderImg->convertDepth( 32 );
+
+ if ( btnShadowImg && btnShadowImg->depth() < 32 )
+ * btnShadowImg = btnShadowImg->convertDepth( 32 );
+
+ if ( buttonGlow && buttonGlow->depth() < 32 )
+ * buttonGlow = buttonGlow->convertDepth( 32 );
+
+ if ( combo && combo->depth() < 32 )
+ * combo = combo->convertDepth( 32 );
+
+ if ( comboShadow && comboShadow->depth() < 32 )
+ * comboShadow = comboShadow->convertDepth( 32 );
+
+ if ( rectbutton && rectbutton->depth() < 32 )
+ * rectbutton = rectbutton->convertDepth( 32 );
+
+ if (optionHandler->style() == Milk)
+ {
+ slider_top = new QImage( uic_findImage( "sbslider_top-milk" ) );
+ slider_btm = new QImage( uic_findImage( "sbslider_btm-milk" ) );
+ }
+ else
+ {
+ slider_top = new QImage( uic_findImage( "sbslider_top" ) );
+ slider_btm = new QImage( uic_findImage( "sbslider_btm" ) );
+ }
+
+ if ( slider_top->depth() < 32 )
+ * slider_top = slider_top->convertDepth( 32 );
+
+ if ( slider_btm->depth() < 32 )
+ * slider_btm = slider_btm->convertDepth( 32 );
+
+ if (optionHandler->shadowSbSlider())
+ {
+ slider_top_shd = new QImage( uic_findImage( "sbslider_top_shd" ) );
+ if ( slider_top_shd->depth() < 32 )
+ * slider_top_shd = slider_top_shd->convertDepth( 32 );
+
+ slider_btm_shd = new QImage( uic_findImage( "sbslider_btm_shd" ) );
+ if ( slider_btm_shd->depth() < 32 )
+ * slider_btm_shd = slider_btm_shd->convertDepth( 32 );
+ }
+ else
+ {
+ slider_top_shd = 0L;
+ slider_btm_shd = 0L;
+ }
+
+ roundFrame = new QImage( uic_findImage( "roundFrame" ) );
+ if ( roundFrame->depth() < 32 )
+ * roundFrame = roundFrame->convertDepth( 32 );
+
+ menuPix = NULL;
+ tmpBtnPix = NULL;
+
+ int i;
+ for ( i = 0; i < BITMAP_ITEMS; ++i ) {
+ pixmaps[ i ] = NULL;
+ }
+
+ sbLeft = new QBitmap( 6, 7, sbarrow_left_bits, true );
+ sbLeft->setMask( *sbLeft );
+ sbRight = new QBitmap( 6, 7, sbarrow_right_bits, true );
+ sbRight->setMask( *sbRight );
+ sbUp = new QBitmap( 7, 6, sbarrow_up_bits, true );
+ sbUp->setMask( *sbUp );
+ sbDown = new QBitmap( 7, 6, sbarrow_down_bits, true );
+ sbDown->setMask( *sbDown );
+ checkmark = new QBitmap( 6, 7, checkmark_bits, true );
+ checkmark->setMask( *checkmark );
+
+ isKicker = ( qstrcmp( qApp->argv() [ 0 ], "kicker" ) == 0 ) ||
+ ( qstrcmp( qApp->argv() [ 0 ], "appletproxy" ) == 0 );
+ isOOO = !qstrcmp( qApp->argv() [ 0 ], "soffice.bin" );
+
+ groupShadow = new QPixmap( 64, 64 );
+ QColor c;
+ optionHandler->custCols[0] != -1 ? c = QColor(optionHandler->custCols[0]) : c= QColor(qApp->palette().color(QPalette::Active, isKicker?QColorGroup::Button:QColorGroup::Background));
+
+ groupShadow->fill( ( c.dark( 100 + optionHandler->ShadowDarkness() ) ).rgb() );
+ if ( (optionHandler->style() != Brushed) && optionHandler->useBgStipple() ) {
+ QPainter p;
+ p.begin( groupShadow );
+ p.setPen( c.dark( 100 + optionHandler->ShadowDarkness() + (int)(optionHandler->stippleContrast()/2) ) );
+ for ( int i = 1; i < 64; i += 4 ) {
+ p.drawLine( 0, i, 63, i );
+ p.drawLine( 0, i+2, 63, i+2 );
+ }
+ p.setPen( c.dark( 100 + optionHandler->ShadowDarkness() + optionHandler->stippleContrast()) );
+ for ( int i = 2; i < 63; i += 4 ) {
+ p.drawLine( 0, i, 63, i );
+ }
+ }
+
+ if (optionHandler->style() == Brushed)
+ {
+ plainBrush = optionHandler->TintBrush() ?
+ *tintBrush(uic_findImage( "brushed-tile" ), optionHandler->BrushTint()) :
+ uic_findImage( "brushed-tile" );
+ gradBrush = optionHandler->TintBrush() ?
+ *tintBrush(uic_findImage( "brushed-gradient" ), optionHandler->BrushTint()) :
+ uic_findImage( "brushed-gradient" );
+ }
+}
+
+LiquidStyle::~LiquidStyle() {
+// btnDict.setAutoDelete(true);
+ btnDict.clear();
+// btnShadowedDict.setAutoDelete(true);
+ btnShadowedDict.clear();
+// buttonGlowDict.setAutoDelete(true);
+ buttonGlowDict.clear();
+// comboDict.setAutoDelete(true);
+ comboDict.clear();
+// comboShadowedDict.setAutoDelete(true);
+ comboShadowedDict.clear();
+// if (! tabDict.isEmpty()) tabDict.clear();
+// if (! inverseTabDict.isEmpty()) inverseTabDict.clear();
+// rectBtnDict.setAutoDelete(true);
+ rectBtnDict.clear();
+// progress2Dict.setAutoDelete(true);
+ progress2Dict.clear();
+// bfi.setAutoDelete(true);
+ bfi.clear();
+// fadeColorMap.setAutoDelete(true);
+ fadeColorMap.clear();
+
+ delete optionHandler;
+
+ delete sbUp;
+ delete sbDown;
+ delete sbLeft;
+ delete sbRight;
+ delete checkmark;
+
+
+ if ( btnBorderImg )
+ delete btnBorderImg;
+ if ( btnShadowImg )
+ delete btnShadowImg;
+ if (combo)
+ delete combo;
+ if (comboShadow)
+ delete comboShadow;
+ if (buttonGlow)
+ delete buttonGlow;
+ delete slider_top;
+ delete slider_btm;
+ if (slider_top_shd)
+ delete slider_top_shd;
+ if (slider_btm_shd)
+ delete slider_btm_shd;
+ if (rectbutton)
+ delete rectbutton;
+ delete roundFrame;
+
+ if ( tmpBtnPix )
+ delete tmpBtnPix;
+ if ( menuPix )
+ delete menuPix;
+
+ int i;
+ for ( i = 0; i < BITMAP_ITEMS; ++i ) {
+ if ( pixmaps[ i ] )
+ delete pixmaps[ i ];
+ }
+ if ( groupShadow )
+ delete groupShadow;
+
+ }
+
+inline void LiquidStyle::updateProgressPos()
+{
+ progAnimShift = (progAnimShift + 1) % 20;
+ prog2AnimShift = (prog2AnimShift + 1) % 38;
+ //Update the registered progressbars.
+ QMap<QWidget*, int>::iterator iter;
+ for (iter = progAnimWidgets.begin(); iter != progAnimWidgets.end(); iter++)
+ {
+ if ( !::qt_cast<QProgressBar*>(iter.key()) )
+ continue;
+ (iter.key())->repaint(false);
+ }
+}
+
+inline void LiquidStyle::updateSliderPos(){
+ sliderAnimShift = (sliderAnimShift + 1) % 32;
+ if (activeScroller)
+ activeScroller->repaint(false);
+}
+
+void LiquidStyle::progressBarDestroyed(QObject* obj){
+ progAnimWidgets.remove(static_cast<QWidget*>(obj));
+}
+
+bool LiquidStyle::isPlain() const {
+ return ( !optionHandler->useBgStipple() );
+ }
+
+
+void LiquidStyle::drawPrimitive( PrimitiveElement pe, QPainter *p,
+ const QRect &r, const QColorGroup &cg,
+ SFlags flags, const QStyleOption &opt ) const
+{
+ bool down = flags & Style_Down;
+ bool on = flags & Style_On;
+
+ switch ( pe )
+ {
+ case PE_TabBarBase:
+ {
+ bool isDialog = false;
+ if (p->device() && p->device()->devType() == QInternal::Widget)
+ {
+ QWidget *w = (QWidget*)p->device();
+ if (w && ::qt_cast<QTabWidget*>(w) && w->children())
+ {
+ QObjectListIt it( *w->children() ); // iterate over the buttons
+ QObject *obj;
+ QTabBar *tabBar = 0L;
+ while ( (obj = it.current()) != 0 )
+ {
+ ++it;
+ if (::qt_cast<QTabBar*>(obj))
+ {
+ tabBar = (QTabBar*)obj;
+ break;
+ }
+ }
+ if (!tabBar || !tabBar->isVisible())
+ break;
+ }
+ isDialog = optionHandler->TabStyle() == Clever && w->topLevelWidget()->inherits("QDialog");
+ }
+ if (isDialog || optionHandler->TabStyle() == Chooser)
+ {
+ int x = r.x(); int right = r.right(); int bottom = r.bottom(); int y2 = r.y() + 1;
+ QColor bright( cg.background().dark( 110 ) );
+ QColor mid( cg.background().dark( 130 ) );
+ QColor dark( cg.background().dark( 150 ) );
+ p->setPen( dark );
+ p->drawLine( x + 6, y2, right - 6, y2 );
+ p->drawPoint(x+3,y2+1);p->drawPoint(x+4,y2+1);
+ p->drawPoint(x+2,y2+2);
+ p->drawPoint(x+1,y2+3);
+ p->drawPoint(right-3,y2+1);p->drawPoint(right-4,y2+1);
+ p->drawPoint(right-2,y2+2);
+ p->drawPoint(right-1,y2+3);
+ p->drawLine(x,y2+5,x,bottom);
+ p->drawLine(right,y2+5,right,bottom);
+
+ p->setPen( mid );
+ p->drawPoint(x+4, y2);p->drawPoint(x+5,y2);
+ p->drawPoint(right-4, y2);p->drawPoint(right-5,y2);
+ p->drawPoint(x+2, y2+1);
+ p->drawPoint(right-2, y2+1);
+ p->drawLine(x+5,y2 + 1, right - 5, y2 + 1);
+ p->drawPoint(x+1,y2+2);
+ p->drawPoint(right-1,y2+2);
+ p->drawPoint(x+2,y2+3);
+ p->drawPoint(right-2,y2+3);
+ p->drawPoint(x,y2+4);p->drawPoint(x+1,y2+4);
+ p->drawPoint(right,y2+4);p->drawPoint(right+1,y2+4);
+
+ p->setPen(bright);
+ p->drawPoint(x+3,y2);p->drawPoint(right-3,y2);
+ p->drawLine(x+4,y2+2,right-4,y2+2);
+ p->drawPoint(x,y2+3);p->drawPoint(x+3,y2+3);
+ p->drawPoint(right,y2+3);p->drawPoint(right-3,y2+3);
+ p->drawPoint(x+2,y2+4);p->drawPoint(right-2,y2+4);
+ p->drawLine(x+1,y2+5,x+1,bottom);
+ p->drawLine(right-1,y2+5,right-1,bottom);
+ break;
+ }
+ else
+ {
+ drawCombo( p, cg, cg.button(), r.x()+1, r.y()+1, r.width()-2, r.height()+1, false, false, false, center);
+ QPen oldPen = p->pen();
+// p->setClipping ( false );
+ p->setPen( cg.button().dark( 158 ) );
+ p->drawRect(r);
+// p->fillRect(r, Qt::red);
+// p->flush();
+ p->setPen(oldPen);
+ }
+ break;
+ }
+ case PE_ButtonCommand:
+ case PE_ButtonDefault:
+ {
+ bool sunken = on || down;
+ bool hover = flags & Style_MouseOver;
+ bool focused = flags & Style_HasFocus;
+ QColor newColor = sunken ? cg.button().dark( 110 ) : hover || focused ? cg.button() : optionHandler->InactiveButtonColor();
+ if (optionHandler->AnimateButton() && (sunken || hover || focused))
+ {
+ ButtonFadeInfo *bfi_ = /*(::qt_cast<QWidget*>(*/opt.widget()/*))*/ ? bfi[opt.widget()->winId()] : 0L;
+ if (bfi_)
+ {
+ int index = bfi_->index;
+ newColor = mapFadeColor(newColor, index);
+ }
+ }
+
+ if (optionHandler->buttonStyle() == Brushed)
+ {
+ drawRectangularButton( p, cg, newColor, r.x(), r.y(), r.width(), r.height(), sunken, hover, false, full);
+ }
+ else if ( ( r.width() < 21 || r.height() < 25 ))
+ {
+ drawCombo( p, cg, newColor, r.x(), r.y(), r.width(), r.height()+2, sunken, hover, false, center, isHTMLButton );
+ QPen oldpen(p->pen());
+ p->setPen( newColor.dark(150));
+ p->drawRect(r.x(), r.y(), r.width(), r.height());
+ if (sunken)
+ {
+ p->setPen(newColor.dark(180));
+ p->drawRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
+ }
+ p->setPen(oldpen);
+ break;
+ }
+ else if (optionHandler->buttonStyle() == Milk)
+ drawCombo( p, cg, newColor, r.x(), r.y(), r.width(), r.height(), sunken, hover, false, full, isHTMLButton );
+ else
+ {
+ drawRoundButton( p, cg, newColor, r.x(), r.y(), r.width(), r.height(), sunken, hover, btnOffset.x(), btnOffset.y() );
+ }
+ break;
+ }
+ case PE_ButtonBevel:
+ case PE_ButtonDropDown:
+ {
+ bool sunken = on || down;
+ bool hover = flags & Style_MouseOver;
+ if (optionHandler->buttonStyle() == Brushed)
+ drawRectangularButton( p, cg, sunken ? cg.button().dark( 110 ) : hover ? cg.button() : optionHandler->InactiveButtonColor(), r.x(), r.y(), r.width(), r.height(), sunken, hover, false, full);
+ else
+ drawCombo( p, cg, sunken ? cg.button().dark( 110 ) : hover ? cg.button() : optionHandler->InactiveButtonColor(), r.x(), r.y(), r.width(), r.height(), sunken, hover, false, full );
+ break;
+ }
+ case PE_ButtonTool:
+ {
+ bool sunken = on || down;
+ bool hover = flags & Style_MouseOver;
+ if (optionHandler->buttonStyle() == Brushed)
+ drawRectangularButton( p, cg, sunken ? cg.button().dark( 110 ) : hover ? cg.button() : optionHandler->InactiveButtonColor(), r.x(), r.y(), r.width(), r.height(), sunken, hover, false, full);
+ else
+ drawCombo( p, cg, sunken ? cg.button().dark( 110 ) : hover ? cg.button() : optionHandler->InactiveButtonColor(), r.x(), r.y(), r.width(), r.height(), sunken, hover, false, full );
+ break;
+ }
+ case PE_HeaderSection:
+ {
+ bool sunken = on || down;
+ bool hover = flags & Style_MouseOver;
+ QPen oldpen(p->pen());
+ if ( isTaskContainer ) // is kicker?
+ {
+ if (optionHandler->SmoothListViewHeaders())
+ {
+ drawCombo( p, cg, sunken ? cg.button() : taskContainerHover ? cg.button().light( 110 ) : cg.background(), r.x(), r.y(), r.width(), isKicker ? r.height() + 2 : r.height(), sunken, hover, false, optionHandler->SmootherLVH() ? full : center );
+ if (isKicker && !optionHandler->SmootherLVH())
+ {
+ p->setPen(cg.background().dark(150));
+ p->drawRect(r.x(), r.y(), r.width(), r.height());
+ if (sunken)
+ {
+ p->setPen(cg.background().dark(200));
+ p->drawRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
+ }
+ }
+ }
+ else
+ {
+ drawRectangularButton( p, cg, sunken ? cg.button() : taskContainerHover ? cg.button().light( 110 ) : cg.background(), r.x(), r.y(), r.width(), r.height(), sunken, hover, false, center);
+ p->setPen(cg.background().dark(150));
+ p->drawLine(r.x(),r.y()+1,r.x(),r.height()-2);
+ }
+ const_cast<LiquidStyle*>( this ) ->isTaskContainer = false;
+ const_cast<LiquidStyle*>( this ) ->taskContainerHover = false;
+ }
+ else
+ {
+ if ( (p->device() && p->device()->devType() == QInternal::Widget) && ::qt_cast<QHeader*>((QWidget*)p->device()) )
+ {
+ QHeader *header = (QHeader*)p->device();
+ int id = header->orientation() == Qt::Horizontal ? header->sectionAt( r.x() + 2 + header->offset() ) : header->sectionAt( r.y() + 2 + header->offset() );
+ hover = ((id != -1) && ((currentHeader == header && id == headerHoverID ) || id == headerSortID));
+ if (header->mapToIndex(id) == header->count()-1 && (r.bottom() < header->rect().bottom() || r.right() < header->rect().right()))
+ {
+ bool hadClip = p->hasClipping();
+ p->setClipping( false );
+ if (header->orientation() == Qt::Horizontal)
+ p->fillRect(r.right()+1, r.y(), header->width()-r.right(), r.height(), cg.base());
+ else
+ p->fillRect(r.x(), r.bottom()+1, r.width(), header->height()-r.bottom(), cg.base());
+ p->setClipping( hadClip );
+ }
+ }
+ if (optionHandler->SmoothListViewHeaders())
+ {
+ drawCombo( p, cg, sunken ? cg.button().dark( 110 ) : hover ? cg.button() : optionHandler->InactiveButtonColor(), r.x(), r.y(), r.width(), r.height(), sunken, hover, false, center);
+ }
+ else
+ drawRectangularButton( p, cg, sunken ? cg.button().dark( 110 ) : hover ? cg.button() : optionHandler->InactiveButtonColor(), r.x(), r.y(), r.width(), r.height(), sunken, hover, false, center);
+ }
+ p->setPen(oldpen);
+ break;
+ }
+ case PE_FocusRect:
+ {
+ p->drawWinFocusRect( r );
+ break;
+ }
+ case PE_ScrollBarSlider:
+ case PE_ScrollBarAddPage:
+ case PE_ScrollBarSubPage:
+ {
+ QColor sbBgColor = optionHandler->useCustomColors() ?
+ optionHandler->customColor( CustomSBGroove ) :
+ qApp->palette().active().background();
+
+ bool isActive = optionHandler->ScrollerActive();
+ bool isHover = currentScrollBar->hasMouse();
+ bool isPressed = currentScrollBar->draggingSlider();
+ bool drawSlider = currentScrollBar->minValue() < currentScrollBar->maxValue();
+
+ // horizontal slider
+ if ( flags & Style_Horizontal )
+ {
+ int extent = currentScrollBar->height();
+ QRect bgR( extent, 0, currentScrollBar->width() - extent * 3 + 1, extent );
+ if ( sbBuffer.size() != currentScrollBar->size() )
+ const_cast<LiquidStyle*>( this )->sbBuffer.resize( currentScrollBar->size() );
+ QPainter painter;
+ painter.begin( &sbBuffer );
+ // pixmaps
+ if (drawSlider)
+ {
+ painter.drawPixmap( bgR.x(), bgR.y() + 1, *getPixmap( HSBSliderBtmBg ) );
+ painter.drawTiledPixmap( bgR.x() + 7, bgR.y() + 1, bgR.width() - 15, 13, *getPixmap( HSBSliderMidBg ) );
+ painter.drawPixmap( bgR.right() - 8, bgR.y() + 1, *getPixmap( HSBSliderTopBg ) );
+ }
+ else
+ painter.drawTiledPixmap( bgR.x(), bgR.y() + 1, bgR.width(), 13, *getPixmap( HSBSliderMidBg ) );
+
+ // lines
+ painter.setPen( sbBgColor.dark( 110 ) );
+ painter.drawLine( bgR.x(), bgR.y(), bgR.right(), bgR.y());
+ painter.drawLine( bgR.x(), bgR.bottom(), bgR.right(), bgR.bottom());
+
+ if ( pe == PE_ScrollBarSlider && drawSlider)
+ {
+ int offset = isPressed * ( optionHandler->squeezeSbSlider() + optionHandler->shadowSbSlider()*2);
+ int offset2 = optionHandler->shadowSbSlider()*2 + (isPressed && optionHandler->squeezeSbSlider());
+
+ painter.drawPixmap( r.x() + offset, r.y() + 1,
+ isPressed ? *getPixmap( HSBSliderBtmPressed ) :
+ (isHover || isActive || isOOO) ? *getPixmap( HSBSliderBtmActive ) :
+ *getPixmap( HSBSliderBtm));
+
+ painter.drawPixmap( r.right() - 6 - offset2, r.y() + 1,
+ isPressed ? *getPixmap( HSBSliderTopPressed ) :
+ (isHover || isActive || isOOO) ? *getPixmap( HSBSliderTopActive ) :
+ *getPixmap( HSBSliderTop ) );
+ // mid part last, as i have to redefine clip section
+ painter.setClipRect(r.x() + 7 + offset2, r.y() + 1, r.width() - 14 - 2*offset2, 13, QPainter::CoordPainter);
+ painter.drawTiledPixmap( r.x() + 7 + offset2 + ((isHover && !isPressed) ? (sliderAnimShift - 32) : 0), r.y() + 1, r.width() - 14 - 2*offset2 - ((isHover && !isPressed) ?
+ (sliderAnimShift - 32) : 0), 13, isPressed ? *getPixmap( HSBSliderMidPressed ) :
+ (isHover || isActive || isOOO) ? *getPixmap( HSBSliderMidActive ) :
+ *getPixmap( HSBSliderMid ), isPressed?r.x() : 0, 0);
+ }
+
+ painter.end();
+ }
+
+ // vertical slider
+ else
+ {
+ int extent = currentScrollBar->width();
+ QRect bgR( 0, extent, extent, currentScrollBar->height() - extent * 3 + 1 );
+
+ if ( sbBuffer.size() != currentScrollBar->size() )
+ const_cast<LiquidStyle*>( this ) -> sbBuffer.resize( currentScrollBar->size() );
+ QPainter painter;
+ painter.begin( &sbBuffer ); // set painter to pixelbuffer
+ if (drawSlider)
+ {
+ // top slidergroove rounder
+ painter.drawPixmap( bgR.x() + 1, bgR.y(), *getPixmap( VSBSliderTopBg ) );
+ // the groove
+ painter.drawTiledPixmap( bgR.x() + 1, bgR.y() + 8, 13, bgR.height() - 15, *getPixmap( VSBSliderMidBg ) );
+ // bottom slidergroove rounder
+ painter.drawPixmap( bgR.x() + 1, bgR.bottom() - 7, *getPixmap( VSBSliderBtmBg ) );
+ }
+ else
+ painter.drawTiledPixmap( bgR.x() + 1, bgR.y(), 13, bgR.height(), *getPixmap( VSBSliderMidBg ) );
+
+ painter.setPen( sbBgColor.dark( 110 ) );
+ painter.drawLine( bgR.x(), bgR.y(), bgR.x(), bgR.bottom() );
+ painter.drawLine( bgR.right(), bgR.y(), bgR.right(), bgR.bottom() );
+
+ // here we are, now the slider
+ if ( pe == PE_ScrollBarSlider && drawSlider )
+ {
+ int offset = isPressed * ( optionHandler->squeezeSbSlider() + optionHandler->shadowSbSlider()*2);
+ int offset2 = (isPressed * optionHandler->squeezeSbSlider()) + optionHandler->shadowSbSlider()*2;
+
+ painter.drawPixmap( r.x() + 1, r.y() + offset, isPressed ?
+ *getPixmap( VSBSliderTopPressed ) :
+ (isHover || isActive || isOOO) ? *getPixmap( VSBSliderTopActive ) :
+ *getPixmap( VSBSliderTop));
+ painter.drawPixmap( r.x() + 1, r.bottom() - 6 - offset2, isPressed ?
+ *getPixmap( VSBSliderBtmPressed ) :
+ (isHover || isActive || isOOO) ? *getPixmap( VSBSliderBtmActive ) :
+ *getPixmap( VSBSliderBtm ) );
+ // mid part last, as i have to redefine clipping section
+ painter.setClipRect(r.x() + 1, r.y() + 7+offset2, 13, r.height() - 14 - 2*offset2, QPainter::CoordPainter);
+ painter.drawTiledPixmap( r.x() + 1, r.y() + 7 + offset2 - ((isHover && !isPressed) ? sliderAnimShift : 0),
+ 13, r.height() - 14 - 2*offset2 + ((isHover && !isPressed) ?
+ sliderAnimShift : 0), isPressed ? *getPixmap( VSBSliderMidPressed ) :
+ (isHover || isActive || isOOO) ? *getPixmap( VSBSliderMidActive ) :
+ *getPixmap( VSBSliderMid ),0,isPressed?r.y():0 );
+ }
+ painter.end();
+ }
+ p->drawPixmap( r.x(), r.y(), sbBuffer, r.x(), r.y(), r.width(), r.height() );
+ break;
+ }
+ case PE_ScrollBarAddLine:
+ {
+ QColor c( optionHandler->useCustomColors() ?
+ optionHandler->customColor( CustomSBGroove ) :
+ qApp->palette().active().background() );
+ QColor pixColor = flags & Style_Down ? qApp->palette().active().button() : c;
+
+ bool drawSlider = currentScrollBar->minValue() < currentScrollBar->maxValue();
+
+ if ( flags & Style_Horizontal )
+ {
+ p->drawTiledPixmap( r.x(), r.y() + 1, r.width(), 13, *getPixmap(drawSlider ? HSBSliderMidBgI : HSBSliderMidBg));
+ p->setPen( c.dark( 110 ) );
+ p->drawLine( r.x(), r.y(), r.right(), r.y());
+ p->drawLine( r.x(), r.bottom(), r.right(), r.bottom());
+ }
+ else
+ {
+ p->drawTiledPixmap( r.x() + 1, r.y(), 13, r.height(), *getPixmap(drawSlider ? VSBSliderMidBgI : VSBSliderMidBg));
+ p->setPen( c.dark( 110 ) );
+ p->drawLine( r.x(), r.y(), r.x(), r.bottom());
+ p->drawLine( r.right(), r.y(), r.right(), r.bottom());
+ }
+ if (drawSlider)
+ {
+ p->setPen( flags & Style_Down ? cg.button() : QColor(85,85,85) );
+ p->setBrush( flags & Style_Down ? cg.button() : QColor(85,85,85) );
+ p->drawPixmap( r.x() + 4, r.y() + 4, flags & Style_Horizontal ? *sbRight : *sbDown );
+ }
+ break;
+ }
+ case PE_ScrollBarSubLine:
+ {
+ QColor c( optionHandler->useCustomColors() ?
+ optionHandler->customColor( CustomSBGroove ) :
+ qApp->palette().active().background() );
+ QColor pixColor = flags & Style_Down ? qApp->palette().active().button() : c;
+ bool top = flags & Style_Horizontal ? r.x() == 0 : r.y() == 0;
+
+ bool drawSlider = currentScrollBar->minValue() < currentScrollBar->maxValue();
+
+ if ( flags & Style_Horizontal )
+ {
+ if ( top )
+ {
+ p->drawTiledPixmap( r.x(), r.y() + 1, r.width(), 13, *getPixmap(drawSlider ? HSBSliderMidBgI : HSBSliderMidBg));
+ }
+ else
+ {
+ p->drawTiledPixmap( r.x(), r.y() + 1, r.width(), 13, *getPixmap(drawSlider ? HSBSliderMidBgI : HSBSliderMidBg));
+ }
+ p->setPen( c.dark( 110 ) );
+ p->drawLine( r.x(), r.y(), r.right(), r.y());
+ p->drawLine( r.x(), r.bottom(), r.right(), r.bottom());
+ }
+ else
+ {
+ if ( top )
+ {
+ p->drawTiledPixmap( r.x() + 1, r.y(), 13, r.height(), *getPixmap(drawSlider ? VSBSliderMidBgI : VSBSliderMidBg));
+ }
+ else
+ {
+ p->drawTiledPixmap( r.x() + 1, r.y(), 13, r.height(), *getPixmap(drawSlider ? VSBSliderMidBgI : VSBSliderMidBg));
+ }
+ p->setPen( c.dark( 110 ) );
+ p->drawLine( r.x(), r.y(), r.x(), r.bottom());
+ p->drawLine( r.right(), r.y(), r.right(), r.bottom());
+ }
+ if (drawSlider)
+ {
+ p->setPen( flags & Style_Down ? cg.button() : QColor(85,85,85) );
+ p->setBrush( flags & Style_Down ? cg.button() : QColor(85,85,85) );
+ if (currentScrollBar->minValue() < currentScrollBar->maxValue()) p->drawPixmap( r.x() + 4, r.y() + 4, flags & Style_Horizontal ? *sbLeft : *sbUp );
+ }
+ break;
+ }
+ case PE_Indicator:
+ {
+ bool hover = flags & Style_MouseOver;
+ bool pressed = flags & Style_Down;
+// bool isMasked = p->device() && p->device() ->devType() == QInternal::Widget && ( ( QWidget * ) p->device() ) ->autoMask();
+#if 0
+ if ( isMasked )
+ {
+ if ( !( flags & Style_Off ) )
+ p->drawPixmap( r.x(), r.y(),
+ hover ? *getPixmap( HTMLCBDownHover ) :
+ *getPixmap( HTMLCBDown ) );
+ else
+ p->drawPixmap( r.x(), r.y(), hover ?
+ *getPixmap( HTMLCBHover ) : *getPixmap( HTMLCB ) );
+ }
+ else
+#endif
+ {
+ if ( flags & Style_On )
+ p->drawPixmap( r.x(), r.y(),
+ pressed ? *getPixmap( CBDownPressed ) :
+ hover ? *getPixmap( CBDownHover ) :
+ *getPixmap( CBDown ) );
+ else if ( flags & Style_Off )
+ p->drawPixmap( r.x(), r.y(),
+ pressed ? *getPixmap( CBPressed ) :
+ hover ? *getPixmap( CBHover ) :
+ *getPixmap( CB ) );
+ else //tristate
+ p->drawPixmap( r.x(), r.y(),
+ pressed ? *getPixmap( CBTriPressed ) :
+ hover ? *getPixmap( CBTriHover ) :
+ *getPixmap( CBTri ) );
+ }
+ break;
+ }
+ case PE_IndicatorMask:
+ {
+ p->fillRect( r, Qt::color1 );
+ break;
+ }
+ case PE_ExclusiveIndicator:
+ {
+ bool hover = flags & Style_MouseOver;
+ bool pressed = flags & Style_Down;
+
+ if ( on || down )
+ p->drawPixmap( r.x(), r.y(),
+ pressed ? *getPixmap( RadioOnPressed ) :
+ hover ? *getPixmap( RadioOnHover ) :
+ *getPixmap( RadioOn ) );
+ else
+ p->drawPixmap( r.x(), r.y(),
+ pressed ? *getPixmap( RadioOffPressed ) :
+ hover ? *getPixmap( RadioOffHover ) :
+ *getPixmap( RadioOff ) );
+ break;
+ }
+ case PE_ExclusiveIndicatorMask:
+ {
+ break;
+ }
+ case PE_Splitter:
+ case PE_DockWindowResizeHandle:
+ {
+ QPen oldpen(p->pen());
+ QBrush oldbrush(p->brush());
+ if (highlightWidget == p->device())
+ {
+ if (flags & Style_Horizontal)
+ { //vertical?
+ p->setPen(cg.mid());
+ p->drawLine(r.x(), r.y(), r.x(), r.bottom());
+ p->drawLine(r.right(), r.y(), r.right(), r.bottom());
+ p->setPen(cg.button().dark(140));
+ p->setBrush(cg.button().dark(140));
+ p->drawEllipse(r.x()+1,r.y() + (int)(r.height() / 2.5), 4, 4);
+ }
+ else
+ {
+ p->setPen(cg.mid());
+ p->drawLine(r.x(), r.y(), r.right(), r.y());
+ p->drawLine(r.x(), r.bottom(), r.right(), r.bottom());
+ p->setPen(cg.button().dark(140));
+ p->setBrush(cg.button().dark(140));
+ p->drawEllipse(r.x()+r.width()/2,r.y() + 1, 4, 4);
+ }
+
+ }
+ else
+ {
+ if (flags & Style_Horizontal)
+ {
+ p->setPen(cg.mid());
+ p->drawLine(r.x(), r.y(), r.x(), r.bottom());
+ p->drawLine(r.right(), r.y(), r.right(), r.bottom());
+ p->setPen(cg.background().dark(130));
+ p->setBrush(cg.background().dark(150));
+ p->drawEllipse(r.x()+1,r.y() + (int)(r.height() / 2.5), 4, 4);
+ }
+ else
+ {
+ p->setPen(cg.mid());
+ p->drawLine(r.x(), r.y(), r.right(), r.y());
+ p->drawLine(r.x(), r.bottom(), r.right(), r.bottom());
+ p->setPen(cg.background().dark(130));
+ p->setBrush(cg.background().dark(150));
+ p->drawEllipse(r.x()+r.width()/2,r.y() + 1, 4, 4);
+ }
+ }
+ p->setPen(oldpen);
+ p->setBrush(oldbrush);
+ break;
+ }
+// case PE_BoxFrame:
+ case PE_PanelGroupBox:
+ case PE_GroupBoxFrame:
+ {
+ QColor bgColor;
+ QWidget* w = (p->device() && p->device()->devType() == QInternal::Widget) ?
+ (QWidget*)(p->device()) : 0;
+ QGroupBox* gb = ::qt_cast<QGroupBox*>(w);
+
+ optionHandler->drawGroupBoxShadow() ?
+ bgColor = QColor(cg.background().dark( 100 + optionHandler->ShadowDarkness() )) :
+ bgColor = QColor(cg.background());
+ QColor bright( bgColor.dark( 110 ) );
+ QColor mid( bgColor.dark( 130 ) );
+ QColor dark( bgColor.dark( 150 ) );
+
+ int titleHeight = (gb && !gb->title().isEmpty() && pe == PE_PanelGroupBox) ?
+ p->fontMetrics().height()+(gb->isCheckable()?4:1) : 0;
+
+ int x = r.x(); int right = r.right(); int bottom = r.bottom();
+ int y2 = r.y();
+
+ /***
+ ok, to get the sunken look somwhat efficient and less glitchy
+ we reset the groupbox brush and only repaint the title
+ (saves us from several is item in groupbox checks as well)
+ only problem left: draw the parents brush on the title window aligned...
+ ***/
+
+ if (gb && titleHeight)
+ {
+ bool hadClip = p->hasClipping();
+ QRegion oldClip = p->clipRegion();
+ if (gb->parentWidget())
+ {
+ const QPixmap *pix = gb->parentWidget()->paletteBackgroundPixmap();
+
+ if (optionHandler->drawGroupBoxShadow())
+ {
+ QPointArray pa1(3);
+ pa1.setPoint(0, x,y2);
+ pa1.setPoint(1, x+5,y2);
+ pa1.setPoint(2, x,y2+5);
+ QPointArray pa2(3);
+ pa2.setPoint(0, right-5,y2);
+ pa2.setPoint(1, right,y2);
+ pa2.setPoint(2, right,y2+5);
+ QPointArray pa3(3);
+ pa3.setPoint(0, right,bottom-5);
+ pa3.setPoint(1, right,bottom);
+ pa3.setPoint(2, right-5,bottom);
+ QPointArray pa4(3);
+ pa4.setPoint(0, x+5,bottom);
+ pa4.setPoint(1, x,bottom);
+ pa4.setPoint(2, x,bottom-5);
+
+ QRegion reg2(0,0, r.right(), titleHeight);
+ p->setClipRegion(QRegion(pa1)+QRegion(pa2)+QRegion(pa3)+QRegion(pa4)+reg2);
+ }
+ else
+ p->setClipRect(0,0,r.right(),titleHeight);
+ pix ? p->drawTiledPixmap( QRect( 0, 0, w->width(), w->height()), *pix, w->backgroundOffset()) : p->fillRect(QRect(0, 0, w->width(), w->height()),w->parentWidget()->backgroundBrush());
+ }
+ if (gb && !gb->isCheckable())
+ {
+ QString title = gb->title();
+ QFont font( p->font() );
+ font.setBold( true );
+ p->setFont( font );
+ drawItem( p, QRect(10,0,r.width(),titleHeight), ShowPrefix, cg, flags & Style_Enabled, 0, title, -1, &cg.text() );
+ }
+ p->setClipRegion(oldClip);
+ p->setClipping(hadClip);
+ }
+
+ //outer rect
+ // top
+ p->setPen( dark );
+ if (pe == PE_PanelGroupBox)
+ {
+ p->drawLine( x + 6, y2, right - 6, y2 );
+ // left points
+ p->drawPoint(x+3,y2+1);p->drawPoint(x+4,y2+1);
+ p->drawPoint(x+2,y2+2);
+ p->drawPoint(x+1,y2+3);
+ // right points
+ p->drawPoint(right-3,y2+1);p->drawPoint(right-4,y2+1);
+ p->drawPoint(right-2,y2+2);
+ p->drawPoint(right-1,y2+3);
+ // vertcal outer lines
+ p->drawLine(x,y2+5,x,bottom-5);
+ p->drawLine(right,y2+5,right,bottom-5);
+ }
+ else
+ {
+ // vertcal outer lines
+ p->drawLine(x,y2,x,bottom-5);
+ p->drawLine(right,y2,right,bottom-5);
+ }
+
+ p->setPen( mid );
+ if (pe == PE_PanelGroupBox)
+ {
+ // top stuff
+ p->drawPoint(x+4, y2);p->drawPoint(x+5,y2);
+ p->drawPoint(right-4, y2);p->drawPoint(right-5,y2);
+ p->drawPoint(x+2, y2+1);
+ p->drawPoint(right-2, y2+1);
+ p->drawLine(x+5,y2 + 1, right - 5, y2 + 1);
+ p->drawPoint(x+1,y2+2);
+ p->drawPoint(right-1,y2+2);
+ p->drawPoint(x+2,y2+3);
+ p->drawPoint(right-2,y2+3);
+ p->drawPoint(x,y2+4);p->drawPoint(x+1,y2+4);
+ p->drawPoint(right,y2+4);p->drawPoint(right+1,y2+4);
+ }
+ // bottom stuff
+ p->drawPoint(x,bottom - 4); p->drawPoint(x+1,bottom - 4);
+ p->drawPoint(right,bottom - 4); p->drawPoint(right-1,bottom - 4);
+ p->drawPoint(x+1,bottom - 3);
+ p->drawPoint(right-1,bottom - 3);
+ p->drawPoint(x+1,bottom - 2); p->drawPoint(x+2,bottom - 2);
+ p->drawPoint(right-1,bottom - 2); p->drawPoint(right-2,bottom - 2);
+ p->drawPoint(x+2, bottom - 1); p->drawPoint(x+3, bottom - 1);
+ p->drawPoint(right-2, bottom - 1); p->drawPoint(right-3, bottom - 1);
+ p->drawLine(x + 4, bottom,right - 4, bottom);
+
+ p->setPen(bright);
+ // top stuff
+ if (pe == PE_PanelGroupBox)
+ {
+ p->drawPoint(x+3,y2);p->drawPoint(right-3,y2);
+ p->drawLine(x+4,y2+2,right-4,y2+2);
+ p->drawPoint(x,y2+3);p->drawPoint(x+3,y2+3);
+ p->drawPoint(right,y2+3);p->drawPoint(right-3,y2+3);
+ p->drawPoint(x+2,y2+4);p->drawPoint(right-2,y2+4);
+ // vertical lines
+ p->drawLine(x+1,y2+5,x+1,bottom-5);
+ p->drawLine(right-1,y2+5,right-1,bottom-5);
+ }
+ else
+ {
+ // vertical lines
+ p->drawLine(x+1,y2,x+1,bottom-5);
+ p->drawLine(right-1,y2,right-1,bottom-5);
+ }
+ // bottom stuff
+ p->drawPoint(x, bottom-3);p->drawPoint(right, bottom-3);
+ p->drawPoint(x+3, bottom);p->drawPoint(right-3, bottom);
+
+ break;
+ }
+ case PE_StatusBarSection:
+ {
+ break;
+ }
+ case PE_WindowFrame:
+ {
+ drawEditFrame( p, r, cg, false, false, true );
+ break;
+ }
+ case PE_Panel:
+ {
+ bool sunken = flags & Style_Sunken;
+ if (!(isKicker && optionHandler->RemoveKickerBevel()))
+ sunken ? drawEditFrame( p, r, cg ) : drawEditFrame( p, r, cg, false, false, true );
+ break;
+ }
+ case PE_PanelTabWidget:
+ {
+ // don't ask
+ bool isDialog = optionHandler->TabStyle() == Clever &&
+ (p->device() && p->device()->devType() == QInternal::Widget)&&
+ ((QWidget*)p->device())->topLevelWidget()->inherits("QDialog");
+
+ QColor bright( cg.background().dark( 110 ) );
+ QColor mid( cg.background().dark( 130 ) );
+ QColor dark( cg.background().dark( 150 ) );
+ int x = r.x(); int right = r.right(); int bottom = r.bottom(); int y2 = r.y();
+ if (isDialog || optionHandler->TabStyle() == Chooser)
+ {
+ //outer rect
+ // top
+ p->setPen( dark );
+ // vertcal outer lines
+ p->drawLine(x,y2,x,bottom-5);
+ p->drawLine(right,y2,right,bottom-5);
+
+ p->setPen( mid );
+ // bottom stuff
+ p->drawPoint(x,bottom - 4); p->drawPoint(x+1,bottom - 4);
+ p->drawPoint(right,bottom - 4); p->drawPoint(right-1,bottom - 4);
+ p->drawPoint(x+1,bottom - 3);
+ p->drawPoint(right-1,bottom - 3);
+ p->drawPoint(x+1,bottom - 2); p->drawPoint(x+2,bottom - 2);
+ p->drawPoint(right-1,bottom - 2); p->drawPoint(right-2,bottom - 2);
+ p->drawPoint(x+2, bottom - 1); p->drawPoint(x+3, bottom - 1);
+ p->drawPoint(right-2, bottom - 1); p->drawPoint(right-3, bottom - 1);
+ p->drawLine(x + 4, bottom,right - 4, bottom);
+
+ p->setPen(bright);
+ // top stuff
+ // vertical lines
+ p->drawLine(x+1,y2,x+1,bottom-5);
+ p->drawLine(right-1,y2,right-1,bottom-5);
+
+ // bottom stuff
+ p->drawPoint(x, bottom-3);p->drawPoint(right, bottom-3);
+ p->drawPoint(x+3, bottom);p->drawPoint(right-3, bottom);
+ break;
+ }
+ else
+ {
+ p->setPen( mid );
+ p->drawLine( x, y2, x, bottom-2 );
+ p->drawLine( right, y2, right, bottom-2 );
+ p->setPen( dark );
+ p->drawLine( x, bottom-1, right, bottom-1 );
+ p->drawLine( x, bottom, right, bottom );
+ break;
+ }
+ }
+ case PE_PanelLineEdit:
+ {
+ bool focused = flags & Style_HasFocus;
+ bool isHTML = p->device() && p->device()->devType() == QInternal::Widget && isHTMLWidget((QWidget*)p->device());
+ drawEditFrame( p, r, cg, isHTML, focused, false);
+ break;
+ }
+ case PE_PanelPopup:
+ {
+ int x, y, w , h;
+ r.rect( &x, &y, &w, &h );
+ QColor c( optionHandler->UseCustomMenuColor()?
+ optionHandler->Color():
+ optionHandler->MenuColorButton()?
+ optionHandler->buttonColor():
+ optionHandler->bgColor() );
+ p->setPen( c.dark( 140 ) );
+ p->drawRect( x, y, w, h );
+ p->setPen( c.light( 120 ) );
+ p->drawRect( x + 1, y + 1, w - 2, h - 2 );
+ break;
+ }
+ case PE_PanelMenuBar:
+ {
+ break;
+ }
+ case PE_PanelDockWindow:
+ {
+ break;
+ }
+ case PE_Separator:
+ case PE_DockWindowSeparator:
+ {
+ break; //don't draw anything
+ if (!(p->device() && p->device()->devType() == QInternal::Widget && ::qt_cast<QToolBar*>((QWidget*)p->device())))
+ {
+ if ( !( flags & Style_Horizontal ) )
+ {
+ p->setPen( cg.mid() );
+ p->drawLine( 4, r.height() / 2, r.width() - 5, r.height() / 2 );
+ p->setPen( cg.light() );
+ p->drawLine( 4, r.height() / 2 + 1, r.width() - 5, r.height() / 2 + 1 );
+ }
+ else
+ {
+ p->setPen( cg.mid() );
+ p->drawLine( r.width() / 2, 4, r.width() / 2, r.height() - 5 );
+ p->setPen( cg.light() );
+ p->drawLine( r.width() / 2 + 1, 4, r.width() / 2 + 1, r.height() - 5 );
+ }
+ }
+ break;
+ }
+ case PE_SpinWidgetUp:
+ case PE_SpinWidgetDown:
+ {
+ bool sunken = on || down;
+ bool hover = flags & Style_MouseOver;
+ int x = r.x() + ( r.width() - 7 ) / 2;
+ int y = pe == PE_SpinWidgetDown ? r.y() + 1 : r.bottom() - 7;
+ QPen oldPen( p->pen() );
+ QBrush oldBrush( p->brush() );
+ p->setPen( sunken ? cg.button() : hover ? cg.mid() : cg.text() );
+ p->setBrush( sunken ? cg.button() : hover ? cg.mid() : cg.text() );
+ p->drawPixmap( x, y, pe == PE_SpinWidgetUp ? *sbUp : *sbDown );
+ p->setBrush( oldBrush );
+ p->setPen( oldPen );
+ break;
+ }
+ case PE_CheckMark:
+ {
+ QPen oldPen( p->pen() );
+ p->setPen( flags & Style_On ? cg.highlightedText() : optionHandler->textColor() );
+ p->drawPixmap(r.x() + r.width()/2 - 4,r.y() + r.height()/2 - 4,*checkmark);
+ p->setPen( oldPen );
+ break;
+ }
+ default:
+ {
+ if ( (pe >= PE_ArrowUp && pe <= PE_ArrowLeft ) || pe == PE_HeaderArrow)
+ {
+ QBrush oldBrush(p->brush());
+ QColor tmpC = flags & Style_Enabled ? (flags & Style_Down || flags & Style_Sunken) && pe != PE_HeaderArrow ? cg.light() : cg.buttonText() : cg.mid();
+ if (tmpC == Qt::black) tmpC = QColor(85,85,85);
+ p->setBrush(tmpC);
+ int x = r.width() > 7 ? r.x() + r.width()/2 - 4 : r.right() - 7;
+ int y = r.height() > 7 ? r.y() + r.height()/2 - 4 : r.bottom() - 7;
+
+ switch ( pe )
+ {
+ case PE_ArrowRight:
+ {
+ p->drawPixmap(x,y,*sbRight);
+ break;
+ }
+ case PE_ArrowUp:
+ {
+ p->drawPixmap(x,y,*sbUp);
+ break;
+ }
+ case PE_ArrowDown:
+ {
+ p->drawPixmap(x,y,*sbDown);
+ break;
+ }
+ case PE_HeaderArrow:
+ {
+ if (flags & Style_Up)
+ p->drawPixmap(x,y,*sbUp);
+ else
+ p->drawPixmap(x,y,*sbDown);
+ break;
+ }
+ default:
+ {
+ p->drawPixmap(x,y,*sbLeft);
+ break;
+ }
+ }
+ p->setBrush( oldBrush );
+ }
+ else
+ KStyle::drawPrimitive( pe, p, r, cg, flags, opt );
+ }
+ } // general switch
+}
+
+void LiquidStyle::drawKStylePrimitive( KStylePrimitive kpe, QPainter* p,
+ const QWidget* widget, const QRect &r,
+ const QColorGroup &cg, SFlags flags,
+ const QStyleOption &opt ) const
+{
+ switch ( kpe )
+ {
+ case KPE_ToolBarHandle:
+ {
+ if (widget && widget->parentWidget() && widget->parentWidget()->hasMouse())
+ {
+ int x, y, w, h;
+ r.rect( &x, &y, &w, &h );
+ w = (int)((w-3)/2);
+ QColor c( (optionHandler->style() == Brushed) ? cg.background() : cg.background().dark(120) );
+ p->setPen(c);
+ p->setBrush(c);
+ for (int i = 0; i < h-3; i += 5 )
+ p->drawEllipse(x+w,y+i,3,3);
+ }
+ break;
+ }
+ case KPE_GeneralHandle:
+ {
+ if (!widget)
+ break;
+ if ( widget->inherits( "AppletHandleDrag" ) )
+ {
+ int x, y, w, h;
+ r.rect( &x, &y, &w, &h );
+ w = (int)((w-3)/2);
+ QColor c( widget->hasMouse() ? cg.button() : cg.background().dark(110) );
+ p->setPen(c);
+ p->setBrush(c);
+ for (int i = 0; i < h-3; i += 5 )
+ p->drawEllipse(x+w,y+i,3,3);
+ break;
+ }
+ else if (widget->hasMouse())
+ {
+ if (optionHandler->style() == Brushed)
+ {
+ drawCombo( p, cg, cg.button(), r.x(), r.y(), r.width(), r.height()+2, false, false, false, center);
+ }
+ else
+ {
+ p->fillRect(r,cg.button());
+ p->setPen(cg.button().dark( 100 + optionHandler->stippleContrast() ));
+ int x=r.x();
+ int y=r.y();
+ int w=r.width();
+ int h=r.height();
+ for (int i = y;i < y+h; i += 4 )
+ {
+ p->drawLine( x, i, x+w, i );
+ p->drawLine( x, i + 1, x+w, i + 1 );
+ }
+ }
+ }
+ else if (optionHandler->style() == Brushed && widget->parentWidget()) // needs alignment
+ {
+ p->drawTiledPixmap(r, *widget->paletteBackgroundPixmap(), widget->parentWidget()->backgroundOffset());
+ }
+ break;
+ }
+ case KPE_SliderGroove:
+ {
+ int x, y, w, h;
+ r.rect( &x, &y, &w, &h );
+ if (qstrcmp( qApp->argv() [ 0 ], "kmix" ) == 0) x = x+3;
+ if ( ( ( const QSlider * ) widget ) ->orientation() == Qt::Horizontal )
+ {
+ int x2 = x + w - 1;
+ y = y + ( h - 5 ) / 2;
+ p->setPen( cg.background().dark( 135 ) );
+ p->drawLine( x + 1, y, x2 - 1, y ); //1
+ p->drawLine( x, y + 4, x2, y + 4 ); //5
+ p->setPen( cg.background().dark( 150 ) );
+ p->drawLine( x, y + 1, x2, y + 1 ); //2
+ p->setPen( cg.background().dark( 115 ) );
+ p->drawLine( x, y + 2, x2, y + 2 ); //3
+ p->drawLine( x, y + 3, x2, y + 3 ); //4
+ p->setPen( cg.background().light( 130 ) );
+ p->drawLine( x + 1, y + 5, x2 - 1, y + 5 ); //6
+ }
+ else
+ {
+ int y2 = y + h - 1;
+ x = x + ( w - 5 ) / 2;
+ p->setPen( cg.background().dark( 135 ) );
+ p->drawLine( x, y + 1, x, y2 - 1 );
+ p->drawLine( x + 4, y, x + 4, y2 );
+ p->setPen( cg.background().dark( 150 ) );
+ p->drawLine( x + 1, y, x + 1, y2 );
+ p->setPen( cg.background().dark( 115 ) );
+ p->drawLine( x + 2, y, x + 2, y2 );
+ p->drawLine( x + 3, y, x + 3, y2 );
+ p->setPen( cg.background().light( 130 ) );
+ p->drawLine( x + 5, y + 1, x + 5, y2 - 1 );
+ }
+ break;
+ }
+ case KPE_SliderHandle:
+ {
+ if (!widget)
+ {
+ p->drawPixmap( r.x(), r.y(), *getPixmap( flags & Style_Enabled ? RadioOffHover : RadioOff));
+ break;
+ }
+ if ((( const QSlider * ) widget ) ->orientation() == Qt::Horizontal)
+ (widget && widget->height() < 17) ? p->drawPixmap( r.x(), r.y(), *getPixmap( flags & Style_Enabled ? RadioOffHover : RadioOff)) : p->drawPixmap( r.x(), (optionHandler->style() == Milk) ? r.y() : r.y()+2, *getPixmap( flags & Style_Enabled ? HSlider : HSliderInactive));
+ else
+ {
+ bool right = (( const QSlider * ) widget )->tickmarks() == QSlider::NoMarks || (( const QSlider * ) widget )->tickmarks() == QSlider::Right;
+ (widget && widget->width() < 17) ? p->drawPixmap( r.x()+2, r.y(), *getPixmap( flags & Style_Enabled ? RadioOffHover : RadioOff)) : p->drawPixmap( (optionHandler->style() == Milk) ? r.x() : right ? r.x()+5 : r.x()-3, r.y(), *getPixmap( flags & Style_Enabled ? (right ? VSlider : VSliderAbove) : (right ? VSliderInactive : VSliderAboveInactive)));
+ }
+ break;
+ }
+ case KPE_ListViewExpander:
+ {
+ p->fillRect(r,Qt::green);
+ // int radius = ( r.width() - 4 ) / 2;
+ // int centerx = r.x() + r.width() / 2;
+ // int centery = r.y() + r.height() / 2;
+ //
+ // int red, green, blue;
+ // red = ( cg.dark().red() >> 1 ) + ( cg.base().red() >> 1 );
+ // green = ( cg.dark().green() >> 1 ) + ( cg.base().green() >> 1 );
+ // blue = ( cg.dark().blue() >> 1 ) + ( cg.base().blue() >> 1 );
+ // QColor blendColor( red, green, blue );
+ //
+ // p->setPen( cg.dark() );
+ // p->drawLine( r.x() + 1, r.y(), r.right() - 1, r.y() );
+ // p->drawLine( r.x() + 1, r.bottom(), r.right() - 1, r.bottom() );
+ // p->drawLine( r.x(), r.y() + 1, r.x(), r.bottom() - 1 );
+ // p->drawLine( r.right(), r.y() + 1, r.right(), r.bottom() - 1 );
+ // p->setPen( blendColor );
+ // p->drawPoint( r.x(), r.y() );
+ // p->drawPoint( r.right(), r.y() );
+ // p->drawPoint( r.x(), r.bottom() );
+ // p->drawPoint( r.right(), r.bottom() );
+ // p->setPen( cg.light() );
+ // p->drawRect( r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2 );
+ // p->fillRect( r.x() + 2, r.y() + 2, r.width() - 4, r.height() - 4,
+ // cg.background() );
+ // p->setPen( cg.text() );
+ // p->drawLine( centerx - radius, centery, centerx + radius, centery );
+ // if ( flags & Style_On )
+ // p->drawLine( centerx, centery - radius, centerx, centery + radius );
+ break;
+ }
+ default:
+ KStyle::drawKStylePrimitive( kpe, p, widget, r, cg, flags, opt );
+ }
+}
+
+void LiquidStyle::drawControl( ControlElement element, QPainter *p,
+ const QWidget *widget, const QRect &r,
+ const QColorGroup &cg, SFlags flags,
+ const QStyleOption &opt ) const
+{
+ switch ( element )
+ {
+ case CE_ProgressBarGroove:
+ {
+ p->setPen(cg.background().dark(160));
+ p->drawRect(r);
+ drawCombo( p, cg, cg.background(), r.x()+1, r.y()+1, r.width()-2, r.height()+1, false, false, false, center );
+ break;
+ }
+ case CE_ProgressBarContents:
+ {
+// qWarning("%s - %s,%s : %s,%s",qApp->argv()[0],widget->className(),widget->name(),widget->parentWidget()->className(),widget->parentWidget()->name());
+ const QProgressBar *progress = ( const QProgressBar * ) widget;
+ QRect contentsR( subRect( SR_ProgressBarContents, widget ) );
+ double val = progress->progress();
+ bool reverse = QApplication::reverseLayout();
+ val = val / progress->totalSteps();
+ if ( val > 0.0 )
+ {
+ int w = QMIN( contentsR.width(), ( int ) (val * contentsR.width() ) );
+ if ( w > 1 )
+ {
+ int x = contentsR.x();
+ int y = contentsR.y();
+ QRect progressRect;
+ if (reverse)
+ progressRect = QRect(x+(contentsR.width()-w), y, w, contentsR.height()+1);
+ else
+ progressRect = QRect(x, y, w, contentsR.height()+1);
+ if (optionHandler->ProgressBar() == liquid)
+ {
+ int x2 = x + w - 1;
+ int y2 = contentsR.bottom();
+ //Clip to the old rectangle
+ p->setClipRect(progressRect, QPainter::CoordPainter);
+ //Expand
+ progressRect.setLeft(progressRect.x() - progAnimShift);
+ p->setPen(cg.button().dark(120));
+ p->drawLine(x, y, x2, y);
+ p->drawLine(x, y, x, y2);
+ p->drawLine(x+1, y2+1, x2-1, y2+1);
+ p->setPen(cg.button().dark(110));
+ p->drawLine(x2, y, x2, y2);
+ p->drawLine(x, y2, x2, y2);
+ QPixmap * pix = getPixmap( Progress );
+ p->drawTiledPixmap(/*x+1, y+1, w-2, contentsR.height()-2*/progressRect, *pix);
+ }
+ else if (optionHandler->ProgressBar() == baghira)
+ {
+ drawCombo( p, cg, cg.button(), r.x()-1, r.y()-1, w, contentsR.height()+5, false, false, false, center);
+ }
+ else
+ {
+ ButtonTile *progress2Tile = progress2Dict.find( cg.button().rgb() );
+ if ( !progress2Tile )
+ {
+ QPixmap *pix = getPixmap(progress2);
+ progress2Tile = separateTiles( pix, 0, 15, 38, 1, 0, true);
+ if ( !progress2Tile )
+ {
+ qWarning( "Progress tile is NULL!" );
+ return ;
+ }
+ else
+ {
+ LiquidStyle *ptr = const_cast<LiquidStyle*>( this );
+ ptr->progress2Dict.insert( cg.button().rgb(), progress2Tile );
+ }
+ }
+ //Clip to the old rectangle
+ p->setClipRect(progressRect, QPainter::CoordPainter);
+ //Expand
+ progressRect.setLeft(progressRect.x() - 38 + prog2AnimShift);
+ int h; /*x, y, w;*/
+ progressRect.rect(&x, &y, &w, &h);
+ bool tooSmall = h < 32;
+ int mid = h/2;
+ p->drawTiledPixmap(x,tooSmall ? mid + 1 : progressRect.bottom()-15,w,16, *progress2Tile->pixmap(TileBtm));
+ p->drawTiledPixmap(x,tooSmall ? mid : y+15,w,tooSmall ? 1 : h-31, *progress2Tile->pixmap(TileMiddle));
+ p->drawTiledPixmap(x,tooSmall ? mid - 15 : y,w,15, *progress2Tile->pixmap(TileTop));
+ }
+ }
+ }
+ break;
+ }/*
+ case CE_ToolButtonLabel:
+ {
+ const QToolButton *toolbutton = (const QToolButton *) widget;
+ QRect rect = r;
+ Qt::ArrowType arrowType = opt.isDefault()
+ ? Qt::DownArrow : opt.arrowType();
+
+ int shiftX = 0;
+ int shiftY = 0;
+ if (flags & (Style_Down | Style_On)) {
+ shiftX = pixelMetric(PM_ButtonShiftHorizontal, widget);
+ shiftY = pixelMetric(PM_ButtonShiftVertical, widget);
+ }
+
+ if (!opt.isDefault())
+ {
+ PrimitiveElement pe;
+ switch (arrowType)
+ {
+ case Qt::LeftArrow: pe = PE_ArrowLeft; break;
+ case Qt::RightArrow: pe = PE_ArrowRight; break;
+ case Qt::UpArrow: pe = PE_ArrowUp; break;
+ default:
+ case Qt::DownArrow: pe = PE_ArrowDown; break;
+ }
+
+ rect.moveBy(shiftX, shiftY);
+ drawPrimitive(pe, p, rect, cg, flags, opt);
+ }
+ else
+ {
+ QColor btext = Qt::black;//(flags & (Style_Down | Style_On)) ? qApp->palette().color(QPalette::Active,QColorGroup::ButtonText) : toolbutton->paletteForegroundColor();
+
+ if (toolbutton->iconSet().isNull() &&
+ ! toolbutton->text().isNull() &&
+ ! toolbutton->usesTextLabel()) {
+ int alignment = AlignCenter | ShowPrefix;
+ if (!styleHint(SH_UnderlineAccelerator, widget, QStyleOption::Default, 0))
+ alignment |= NoAccel;
+
+ rect.moveBy(shiftX, shiftY);
+ drawItem(p, rect, alignment, cg,
+ flags & Style_Enabled, 0, toolbutton->text(),
+ toolbutton->text().length(), &btext);
+ } else {
+ QPixmap pm;
+ QIconSet::Size size =
+ toolbutton->usesBigPixmap() ? QIconSet::Large : QIconSet::Small;
+ QIconSet::State state =
+ toolbutton->isOn() ? QIconSet::On : QIconSet::Off;
+ QIconSet::Mode mode;
+ if (! toolbutton->isEnabled())
+ mode = QIconSet::Disabled;
+ else if (flags & (Style_Down | Style_On) ||
+ (flags & Style_Raised) && (flags & Style_AutoRaise))
+ mode = QIconSet::Active;
+ else
+ mode = QIconSet::Normal;
+ pm = toolbutton->iconSet().pixmap( size, mode, state );
+
+ if ( toolbutton->usesTextLabel() )
+ {
+ p->setFont( toolbutton->font() );
+ QRect pr = rect, tr = rect;
+ int alignment = ShowPrefix;
+ if (!styleHint(SH_UnderlineAccelerator, widget, QStyleOption::Default, 0))
+ alignment |= NoAccel;
+
+ if ( toolbutton->textPosition() == QToolButton::Under )
+ {
+ int fh = p->fontMetrics().height();
+ pr.addCoords( 0, 1, 0, -fh-3 );
+ tr.addCoords( 0, pr.bottom(), 0, -3 );
+ pr.moveBy(shiftX, shiftY);
+ drawItem( p, pr, AlignCenter, cg, TRUE, &pm, QString::null );
+ alignment |= AlignCenter;
+ }
+ else
+ {
+ pr.setWidth( pm.width() + 8 );
+ tr.addCoords( pr.right(), 0, 0, 0 );
+ pr.moveBy(shiftX, shiftY);
+
+ drawItem( p, pr, AlignCenter, cg, TRUE, &pm, QString::null );
+ alignment |= AlignLeft | AlignVCenter;
+ }
+
+ tr.moveBy(shiftX, shiftY);
+ drawItem( p, tr, alignment, cg,
+ flags & Style_Enabled, 0, toolbutton->textLabel(),
+ toolbutton->textLabel().length(), &btext);
+ }
+ else
+ {
+ rect.moveBy(shiftX, shiftY);
+ drawItem( p, rect, AlignCenter, cg, TRUE, &pm, QString::null );
+ }
+ }
+ }
+
+ break;
+ }*/
+
+/*
+ case CE_HeaderLabel:
+ {
+ QRect rect = r;
+ const QHeader* header = (const QHeader *) widget;
+ int section = opt.headerSection();
+
+ QIconSet* icon = header->iconSet( section );
+ if ( icon ) {
+ QPixmap pixmap = icon->pixmap( QIconSet::Small,
+ flags & Style_Enabled ?
+ QIconSet::Normal : QIconSet::Disabled );
+ int pixw = pixmap.width();
+ int pixh = pixmap.height();
+ // "pixh - 1" because of tricky integer division
+
+ QRect pixRect = rect;
+ pixRect.setY( rect.center().y() - (pixh - 1) / 2 );
+ drawItem ( p, pixRect, AlignVCenter, cg, flags & Style_Enabled,
+ &pixmap, QString::null );
+ rect.setLeft( rect.left() + pixw + 2 );
+ }
+ drawItem ( p, rect, AlignVCenter, cg, flags & Style_Enabled,
+ 0, header->label( section ), -1, (isTaskContainer && (flags & Style_MouseOver)) ? &(qApp->palette().color(QPalette::Active,QColorGroup::ButtonText)) : &(cg.buttonText()) );
+ break;
+ }*/
+ case CE_ProgressBarLabel:
+ {
+ if (optionHandler->DrawProgressLabel())
+ {
+ QRect contentsR( subRect( SR_ProgressBarContents, widget ) );
+ if ( !contentsR.isValid() )
+ return ;
+ QFont font( p->font() );
+ font.setBold( true );
+ p->setFont( font );
+ p->setPen( widget->colorGroup().buttonText() );
+ p->setClipRect(r, QPainter::CoordPainter);
+ p->drawText( contentsR, AlignCenter, ( ( const QProgressBar * ) widget ) ->progressString() );
+ }
+ break;
+ }
+ case CE_TabBarTab:
+ { // new style with tiled pixmaps
+ if ( !widget || !widget->parentWidget(true) )
+ break;
+ const QTabBar *tabBar = ( const QTabBar * ) widget;
+ bool selected = flags & Style_Selected;
+ bool hover = currentTabBar && currentTabBar == tabBar && tabBar->indexOf(opt.tab()->identifier()) == hoveredTabIndex;
+
+ myPosition pos;
+ if (tabBar->count() == 1)
+ pos = full;
+ else if ((tabBar->indexOf(opt.tab()->identifier()) == 0))
+ pos = left;
+ else if (tabBar->indexOf(opt.tab()->identifier()) == tabBar->count() - 1)
+ pos = right;
+ else
+ pos = center;
+
+ QColor c;
+ if (hover || selected)
+ {
+ if (optionHandler->useCustomColors())
+ c = optionHandler->customColor(CustomTabOn);
+ else
+ c = optionHandler->buttonColor();
+ }
+ else
+ {
+ if (optionHandler->useCustomColors())
+ c = optionHandler->customColor(CustomTabOff);
+ else
+ c = optionHandler->InactiveButtonColor();
+ }
+
+ bool isDialog = optionHandler->TabStyle() == Clever && widget->topLevelWidget()->inherits("QDialog");
+ if (isDialog || optionHandler->TabStyle() == Chooser)
+ drawCombo( p, cg, c, r.x(), r.y(), r.width(), r.height(), false, false, false, pos );
+ else
+ {
+ LiquidStyle *ptr = const_cast<LiquidStyle*>( this );
+ bool above = tabBar->shape() == QTabBar::RoundedAbove || tabBar->shape() == QTabBar::TriangularAbove;
+ QPixmap *pix;
+ if (above)
+ pix = selected ? getPixmap( TabDown ) : getPixmap( Tab );
+ else
+ pix = selected ? getPixmap( belowTabDown ) : getPixmap( belowTab );
+ ButtonTile *tabTile = above ? tabDict.find( c.rgb() ) : inverseTabDict.find(c.rgb());
+ if ( !tabTile )
+ tabTile = separateTiles( pix, 9, 15, 67, 1, 0, false);
+ if ( !tabTile )
+ {
+ qWarning( "Tab tile is NULL!" );
+ return ;
+ }
+ else
+ above ? ptr->tabDict.insert( c.rgb(), tabTile ) : ptr->inverseTabDict.insert( c.rgb(), tabTile );
+
+ int offset;
+ selected ? offset = 0 : offset = 2;
+
+ if ( r.width() > 18 )
+ {
+ p->drawTiledPixmap( r.x() + 9, r.y() + offset, r.width() - 18, 15, *tabTile->pixmap( TileTop ) );
+ p->drawTiledPixmap( r.x() + 9, r.height() - 11, r.width() - 18, 11, *tabTile->pixmap( TileBtm ) );
+ }
+ if ( r.height() + offset > 26 )
+ {
+ p->drawTiledPixmap( r.x() + 0, r.y() + 15 + offset, 9, r.height() - 26 - offset, *tabTile->pixmap( TileLeft ) );
+ p->drawTiledPixmap( r.right() - 8, r.y() + 15 + offset, 9, r.height() - 26 - offset, *tabTile->pixmap( TileRight ) );
+ }
+ if ( r.width() > 18 && r.height() + offset > 22 )
+ p->drawTiledPixmap( r.x() + 9, r.y() + 15 + offset, r.width() - 18, r.height() - 26 - offset, *tabTile->pixmap( TileMiddle ) );
+ p->drawPixmap( r.x() + 0, r.y() + offset, *tabTile->pixmap( TileTopLeft ) );
+ p->drawPixmap( r.right() - 8, r.y() + offset, *tabTile->pixmap( TileTopRight ) );
+ p->drawPixmap( r.x() + 0, r.height() - 11, *tabTile->pixmap( TileBtmLeft ) );
+ p->drawPixmap( r.right() - 8, r.height() - 11, *tabTile->pixmap( TileBtmRight ) );
+
+ p->setPen( optionHandler->buttonColor());
+ bool drawPoint = optionHandler->CenterTabs() || pos == center || pos == right;
+ if ( selected )
+ {
+ if (drawPoint) p->drawPoint(r.x(), above ? r.bottom() : r.y());
+ p->drawPoint(r.right(), above ? r.bottom() : r.y());
+ }
+ else
+ {
+ p->drawLine( r.x() + drawPoint ? 0 : 1, above ? r.bottom() : r.y(), r.right(), above ? r.bottom() : r.y() );
+ p->setPen( optionHandler->buttonColor().dark( 158 ));
+ p->drawLine( r.x() + drawPoint ? 0 : 1, above ? r.bottom()-1 : r.y()+1, r.right(), above ? r.bottom()-1 : r.y() + 1 );
+ }
+ }
+ break;
+ }
+ case CE_TabBarLabel:
+ {
+ if ( opt.isDefault() )
+ return ;
+ QTab *t = opt.tab();
+ const QTabBar * tb = ( const QTabBar * ) widget;
+ if ( ( tb->currentTab() != t->identifier() ))
+ {
+ if (optionHandler->TabStyle() == TrueTab ||
+ (optionHandler->TabStyle() == Clever && !(widget->topLevelWidget()->inherits("QDialog"))))
+ {
+ drawItem( p, QRect( r.x(), r.y() + 1, r.width(), r.height() ), AlignCenter | ShowPrefix, cg, flags & Style_Enabled, 0, t->text(), -1/*, &cg.text()*/ );
+ break;
+ }
+ drawItem( p, QRect( r.x(), r.y(), r.width(), r.height() ), AlignCenter | ShowPrefix, cg, flags & Style_Enabled, 0, t->text(), -1/*, &cg.text()*/ );
+ break;
+ }
+ drawItem( p, QRect( r.x(), r.y(), r.width(), r.height() ), AlignCenter | ShowPrefix, cg, flags & Style_Enabled, 0, t->text(), -1/*, &cg.text()*/ );
+ break;
+ }
+ case CE_PushButton:
+ {
+ // if (_htmlWidgetWId == widget->winId())
+ // return;
+ QPushButton *btn = ( QPushButton* ) widget;
+ const_cast<LiquidStyle*>( this ) ->isHTMLButton = isHTMLWidget( btn );
+ ButtonFadeInfo *bfi_ = bfi[btn->winId()];
+ if ( widget == highlightWidget || (bfi_ && !bfi_->fadeIn) )
+ flags |= Style_MouseOver;
+ if (btn->isDefault())
+ flags |= Style_HasFocus;
+ // Qt messes this up with WindowOrigin, so we do it ourselves :P
+ if ( !isPlain() && !btn->autoMask() )
+ const_cast<LiquidStyle*>( this ) ->btnOffset = btn->backgroundOffset();
+ const_cast<LiquidStyle*>( this ) ->paintWidget = const_cast<QWidget*>( widget );
+ drawPrimitive( PE_ButtonDefault, p, r, cg, flags, QStyleOption( btn ));
+ const_cast<LiquidStyle*>( this ) ->paintWidget = 0L;
+ const_cast<LiquidStyle*>( this ) ->isHTMLButton = false;
+ break;
+ }
+ case CE_PushButtonLabel:
+ {
+ // if (_htmlWidgetWId == widget->winId())
+ // return;
+ const QPushButton *btn = ( const QPushButton* ) widget;
+ int x, y, w, h;
+ r.rect( &x, &y, &w, &h );
+
+ if ( btn->isOn() || btn->isDown() )
+ flags |= Style_Sunken;
+
+ int xoff = x;
+ if ( btn->iconSet() && !btn->iconSet() ->isNull() )
+ {
+ QIconSet::Mode mode = btn->isEnabled() ? QIconSet::Normal : QIconSet::Disabled;
+ if ( mode == QIconSet::Normal && btn->hasFocus() )
+ mode = QIconSet::Active;
+
+ QIconSet::State state = QIconSet::Off;
+ if ( btn->isToggleButton() && btn->isOn() )
+ state = QIconSet::On;
+
+ QPixmap pix( btn->iconSet() ->pixmap( QIconSet::Small, mode, state ) );
+ xoff += (x<6?8:2);
+ if (btn->text().isEmpty() && !btn->pixmap())
+ p->drawPixmap( x + w/2 - pix.width()/2, y + h / 2 - pix.height() / 2, pix );
+ else
+ p->drawPixmap( x<6?6:x, y + ( h - pix.height() ) / 2, pix );
+ }
+
+ if ( btn->isMenuButton() )
+ {
+ drawPrimitive( PE_ArrowDown, p, QRect( w-14, (int)(h/2), 7, 7 ) , cg, flags, opt );
+ w -= 14;
+ }
+ QColor tmp;
+
+ tmp = btn->isDown() && !optionHandler->IcyButtons() ? btn->colorGroup().highlightedText() : btn->colorGroup().buttonText();
+ drawItem( p, QRect( xoff, optionHandler->style() == Milk ? y-1 : y, w, h ), AlignCenter | ShowPrefix, cg, btn->isEnabled(), btn->pixmap(), btn->text(), -1, &tmp );
+ break;
+ }
+ case CE_MenuBarItem:
+ {
+ QMenuItem *mi = opt.menuItem();
+ bool active = flags & Style_Active;
+ bool focused = flags & Style_HasFocus;
+
+ if ( active && focused )
+ {
+ optionHandler->glossyMenus() ?
+ drawCombo( p, cg, cg.highlight(), r.x(), r.y()-1, r.width(), r.height() + 5, false, false, false, center ) :
+ p->fillRect(r,cg.highlight());
+ }
+
+ // QColor tmpColor( cg.background().dark( 120 ) );
+ if ( optionHandler->useShadowText() && !( active && focused ))
+ {
+ p->setPen(cg.background().dark( 120 ));
+ p->drawText(r, AlignCenter | AlignVCenter | ShowPrefix | DontClip | SingleLine, mi->text());
+ }
+ // drawItem( p, QRect( r.x() + 1, r.y() + 1, r.width(), r.height() ), AlignCenter | AlignVCenter | ShowPrefix | DontClip | SingleLine, cg, flags & Style_Enabled, mi->pixmap(), mi->text(), -1, &tmpColor );
+
+ // drawItem( p, r, AlignCenter | AlignVCenter | ShowPrefix | DontClip | SingleLine, cg, flags & Style_Enabled, mi->pixmap(), mi->text(), -1, active && focused ? &(cg.highlightedText()) : &(cg.text()) );
+ p->setPen(active && focused ? cg.highlightedText() : cg.text());
+ p->drawText(r, AlignCenter | AlignVCenter | ShowPrefix | DontClip | SingleLine, mi->text());
+ break;
+ }
+ case CE_PopupMenuItem:
+ {
+ int x,y,w, h;
+ r.rect( &x, &y, &w, &h );
+
+ const QPopupMenu *popupmenu = ( const QPopupMenu * ) widget;
+ QMenuItem *mi = opt.menuItem();
+
+ int tab = opt.tabWidth();
+ int maxpmw = opt.maxIconWidth();
+ bool dis = mi && !mi->isEnabled();
+ bool checkable = popupmenu->isCheckable();
+ bool act = flags & Style_Active;
+ bool enabled = flags & Style_Enabled;
+ int checkcol = maxpmw;
+
+ QColor menuBgColor( optionHandler->UseCustomMenuColor() ? optionHandler->Color() : optionHandler->bgColor() );
+
+ if ( checkable )
+ checkcol = QMAX( maxpmw, 20 );
+
+ if ( mi && mi->isSeparator() )
+ {
+ p->setPen( menuBgColor.dark( 130 ) );
+ p->drawLine( x + 1, y, x + w - 1, y );
+ p->setPen( menuBgColor.light( 120 ) );
+ p->drawLine( x+1, y + 1, x + w - 1 , y + 1 );
+ return ;
+ }
+ if ( act && mi && enabled)
+ {
+ optionHandler->glossyMenus() ?
+ drawCombo( p, cg, cg.highlight(), r.x(), r.y(), r.width(), r.height() + 2, false/*sunken*/, false/*hover*/, false, center ) :
+ p->fillRect(x,y,w,h,cg.highlight());
+ }
+ else
+ {
+ if (popupBack.isNull())
+ p->fillRect( x, y, w, h, popupmenu->backgroundBrush() );
+ else
+ p->drawTiledPixmap( x, y, w, h, popupBack );
+
+ if (act)
+ {
+ p->setPen(cg.highlight());
+ p->drawRect(x,y,w,h);
+ }
+ }
+ if ( !mi )
+ return ;
+
+ // Menu contents drawing code based on Qt's styles. Qt is property of
+ // TrollTech: www.trolltech.com. Used with permission.
+ int xpos = x;
+ QRect vrect = visualRect( QRect( xpos, y, checkcol, h ), r );
+ int xvis = vrect.x();
+
+ // icon
+ if (optionHandler->drawMenuStripe())
+ p->fillRect(x,y,h,h, optionHandler->menuStripeColor());
+ if ( mi->iconSet() )
+ {
+ QIconSet::Mode mode = dis ? QIconSet::Disabled : QIconSet::Normal;
+ if ( act && !dis )
+ mode = QIconSet::Active;
+ QPixmap pixmap;
+ if ( checkable && mi->isChecked() )
+ pixmap = mi->iconSet() ->pixmap( QIconSet::Small, mode, QIconSet::On );
+ else
+ pixmap = mi->iconSet() ->pixmap( QIconSet::Small, mode );
+ int pixw = pixmap.width();
+ int pixh = pixmap.height();
+ QRect pmr( 0, 0, pixw, pixh );
+ pmr.moveCenter( vrect.center() );
+ p->setPen( cg.text() );
+ p->drawPixmap( pmr.topLeft(), pixmap );
+ }
+ else if ( checkable )
+ {
+ if ( mi->isChecked() )
+ {
+ int xp = xpos + windowsItemFrame;
+
+ SFlags cflags = Style_Default;
+ if ( !dis )
+ cflags |= Style_Enabled;
+ if ( act )
+ cflags |= Style_On;
+ drawPrimitive( PE_CheckMark, p, visualRect( QRect( xp, y + windowsItemFrame, checkcol - 2 * windowsItemFrame, h - 2 * windowsItemFrame ), r ), cg, cflags );
+ }
+ }
+ QColor discol;
+ if ( dis )
+ {
+ discol = cg.text();
+ p->setPen( discol );
+ }
+
+ int xm = windowsItemFrame + checkcol + windowsItemHMargin;
+ xpos += xm;
+
+ vrect = visualRect( QRect( xpos, y + windowsItemVMargin, w - xm - tab + 1, h - 2 * windowsItemVMargin ), r );
+ xvis = vrect.x();
+ if ( mi->custom() )
+ {
+ p->save();
+ if ( dis && !act )
+ {
+ p->setPen( cg.light() );
+ mi->custom() ->paint( p, cg, act, !dis, xvis + 1, y + windowsItemVMargin + 1, w - xm - tab + 1, h - 2 * windowsItemVMargin );
+ p->setPen( discol );
+ }
+ mi->custom() ->paint( p, cg, act, !dis, xvis, y + windowsItemVMargin, w - xm - tab + 1, h - 2 * windowsItemVMargin );
+ p->restore();
+ }
+
+ // Text
+ QString s = mi->text();
+ if ( !s.isNull() )
+ {
+ QColor textColor, shadowColor;
+ shadowColor = optionHandler->bgColor().dark( 130 );
+
+ if ( dis )
+ textColor = shadowColor.light( 115 );
+ else if (/*!optionHandler->glossyMenus() && */act && mi)
+ textColor = cg.highlightedText();
+ else if ( optionHandler->UseCustomMenuColor())
+ textColor = optionHandler->textColor();
+ else
+ textColor = cg.text();
+
+ int t = s.find( '\t' );
+ int text_flags = AlignVCenter | ShowPrefix | DontClip | SingleLine;
+ text_flags |= ( QApplication::reverseLayout() ? AlignRight : AlignLeft );
+ if ( t >= 0 )
+ { // draw tab text
+ int xp;
+ xp = x + w - tab - 20 - windowsItemHMargin - windowsItemFrame + 1;
+ QString tabStr( s.right( s.length() - t - 1 ) );
+ if ( !tabStr.isEmpty() )
+ {
+ if ( optionHandler->useShadowText() )
+ {
+ p->setPen( shadowColor );
+ p->drawText( xp + 1, y + windowsItemVMargin + 1, w - xm - tab + 1, h - 2 * windowsItemVMargin, text_flags, tabStr );
+ }
+ p->setPen( textColor );
+ p->drawText( xp, y + windowsItemVMargin, w - xm - tab + 1, h - 2 * windowsItemVMargin, text_flags, tabStr );
+ }
+ s = s.left( t );
+ }
+ if ( optionHandler->useShadowText() && !(act && mi) )
+ {
+ p->setPen( shadowColor );
+ p->drawText( xvis + 1, y + windowsItemVMargin + 1, w - xm - tab + 1, h - 2 * windowsItemVMargin, text_flags, s, t );
+ }
+ p->setPen( textColor );
+ p->drawText( xvis, y + windowsItemVMargin, w - xm - tab + 1, h - 2 * windowsItemVMargin, text_flags, s, t );
+ }
+ else if ( mi->pixmap() )
+ // draw pixmap
+ {
+ QPixmap * pixmap = mi->pixmap();
+ if ( pixmap->depth() == 1 )
+ p->setBackgroundMode( OpaqueMode );
+ p->drawPixmap( xvis, y + windowsItemFrame, *pixmap );
+ if ( pixmap->depth() == 1 )
+ p->setBackgroundMode( TransparentMode );
+ }
+ // Child menu
+ if ( mi->popup() )
+ {
+ int dim = (int)((float)( h - 2 * windowsItemFrame ) / 2);
+ PrimitiveElement arrow;
+ arrow = ( QApplication::reverseLayout() ? PE_ArrowLeft : PE_ArrowRight );
+ xpos = x + w - windowsArrowHMargin - windowsItemFrame/* - dim*/-8;
+ vrect = visualRect( QRect( xpos, y + h / 2 - dim / 2, /*dim*/8, dim ), r );
+ if ( act )
+ {
+ if ( !dis )
+ discol = cg.highlightedText();
+ QColorGroup g2( discol, cg.highlight(), white, white, dis ? discol : white, discol, white );
+ drawPrimitive( arrow, p, vrect, g2, Style_Enabled );
+ }
+ else
+ {
+ if ( !dis )
+ discol = optionHandler->textColor();
+ QColorGroup g2( discol, cg.background(), white, white, dis ? discol : white, discol, white );
+ drawPrimitive( arrow, p, vrect, g2, mi->isEnabled() ? Style_Enabled : Style_Default );
+ }
+ }
+ break;
+ }
+ /*
+ case CE_ToolBoxTab:
+ {
+ break;
+ }*/
+ default:
+ KStyle::drawControl( element, p, widget, r, cg, flags, opt );
+ }
+}
+
+
+// void LiquidStyle::drawControlMask( ControlElement element, QPainter *p, const QWidget *widget, const QRect &r, const QStyleOption& opt ) const {
+// switch ( element ) {
+// case CE_PushButton: {
+// p->fillRect( r, Qt::color1 );
+// break;
+// }
+// default:
+// KStyle::drawControlMask( element, p, widget, r, opt );
+// break;
+// }
+// }
+
+// void LiquidStyle::drawComplexControlMask( ComplexControl control, QPainter *p, const QWidget *widget, const QRect &r, const QStyleOption &opt ) const {
+// // switch ( control ) {
+// // case CC_ComboBox: {
+// // drawControlMask( CE_PushButton, p, widget, r, opt );
+// // break;
+// // }
+// // default:
+// KStyle::drawComplexControlMask( control, p, widget, r, opt );
+// // }
+// }
+
+void LiquidStyle::drawComplexControl( ComplexControl control, QPainter *p, const QWidget *widget, const QRect &r, const QColorGroup &cg, SFlags flags, SCFlags controls, SCFlags active, const QStyleOption &opt ) const
+{
+ switch ( control )
+ {
+ case CC_ComboBox:
+ {
+ bool sunken = (active & SC_ComboBoxArrow);// || (flags & Style_Active) || (flags & Style_Sunken) || (active & SC_ComboBoxListBoxPopup);
+ bool hovered = (widget == highlightWidget) || (flags & Style_HasFocus);
+ // bool isHtml = isHTMLWidget( widget );
+ const_cast<LiquidStyle*>( this ) ->paintWidget = const_cast<QWidget*>( widget );
+ QPen oldPen( p->pen() );
+ if ( controls & SC_ComboBoxArrow )
+ {
+ if ( controls & SC_ComboBoxEditField && ( ( const QComboBox * ) widget ) ->editable())
+ { // editable?
+#if 0
+ if ( optionHandler->buttonStyle() == Brushed )
+ { // rectangular?
+ drawRectangularButton( p, cg, sunken ? cg.button().light( 110 ) : cg.button(), r.x(), r.y(), r.width(), r.height(), sunken, hovered, true, full/*, isHtml*/);
+ p->fillRect( r.x() + 6, r.y() +2, r.width()-32, r.height() - 7, cg.background());
+ p->setPen( oldPen );
+ return ;
+ }
+ else
+#endif
+ { // round frame
+ drawRoundFrame( p, r, cg, (flags & Style_HasFocus) || sunken , widget->backgroundOffset());
+ p->setPen(cg.mid());
+ p->drawPixmap(r.right() - 16, r.height()/2 - 2, *sbDown);
+ p->setPen( oldPen );
+ // return;
+ }
+#if 0
+ else
+ { // default!
+ drawCombo( p, cg, active == SC_ComboBoxArrow ? cg.button().light( 110 ) : cg.button(), r.x(), r.y(), r.width(), r.height(), sunken, hovered, true, full );
+ p->fillRect( r.x() + 6, r.y() +2, r.width()-32, r.height() - 7, cg.background());
+ p->setPen( oldPen );
+ return;
+ }
+#endif
+ }
+ else
+ { // end editable - default handling
+ if ( optionHandler->buttonStyle() == Brushed )
+ { // retangular?
+ drawRectangularButton( p, cg, sunken ? cg.button().light( 110 ) : cg.button(), r.x(), r.y(), r.width(), r.height(), sunken, hovered, true, full, isHTMLWidget( widget ));
+ // p->setPen( oldPen );
+ // return ;
+ }
+ else
+ { //default plain good old combobox... ;)
+ drawCombo( p, cg, active == SC_ComboBoxArrow ? cg.button().light( 110 ) : cg.button(), r.x(), r.y(), r.width(), r.height(), sunken, hovered, true, full, isHTMLWidget( widget ) );
+ // p->setPen( oldPen );
+ // return;
+ }
+ }
+ }
+ const_cast<LiquidStyle*>( this ) ->paintWidget = 0L;
+ break;
+ }
+ case CC_ToolButton:
+ {
+ const QToolButton *toolbutton = ( const QToolButton * ) widget;
+ const_cast<LiquidStyle*>( this ) ->paintWidget = const_cast<QWidget*>( widget );
+ const KAccessToolBarButton *toolbutton2 = 0L;
+ QRect button, menuarea;
+ button = querySubControlMetrics( control, widget, SC_ToolButton, opt );
+ menuarea = querySubControlMetrics( control, widget, SC_ToolButtonMenu, opt );
+ if (::qt_cast<KToolBarButton*>(toolbutton))
+ {
+ toolbutton2 = (const KAccessToolBarButton*)toolbutton;
+#if GCC_VERSION < 40000
+ if (toolbutton2->iconTextMode() == 3)
+ button.setBottom(button.bottom() - p->fontMetrics().height() - 1);
+#endif
+ }
+ else if (toolbutton->usesTextLabel() && toolbutton->textPosition() == QToolButton::BelowIcon)
+ button.setBottom(button.bottom() - p->fontMetrics().height());
+ menuarea.setX(menuarea.x() - 1);
+ SFlags bflags = flags, mflags = flags;
+
+ if ( active & SC_ToolButton )
+ bflags |= Style_Down;
+ if ( active & SC_ToolButtonMenu )
+ mflags |= Style_Down;
+
+ if ( widget == highlightWidget )
+ bflags |= Style_MouseOver;
+ if ( controls & SC_ToolButton )
+ {
+ bool sunken = mflags & ( Style_Down /*| Style_On*/ );
+ bool hover = bflags & (Style_MouseOver | Style_On );
+
+ if ( !optionHandler->useToolButtonFrame())// || !(toolbutton->parentWidget() && ( ::qt_cast<QToolBar*>(toolbutton->parentWidget()) || toolbutton->parentWidget()->inherits("KonqFrameTabs"))))
+ {
+ if ((!(hover || sunken) || (toolbutton->usesTextLabel() && toolbutton->textPosition() == QToolButton::BelowIcon)) && toolbutton->parentWidget() && !::qt_cast<QToolBar*>(toolbutton->parent()) && toolbutton->parentWidget()->paletteBackgroundPixmap() && !toolbutton->parentWidget()->paletteBackgroundPixmap()->isNull())
+ {
+ QPixmap pixmap = *(toolbutton->parentWidget()->paletteBackgroundPixmap());
+ if (hover || sunken)
+ p->drawTiledPixmap( r.x(), button.bottom()+1, r.width(), p->fontMetrics().height(), pixmap, toolbutton->x(), toolbutton->y()+button.height() );
+ else
+ p->drawTiledPixmap( r, pixmap, toolbutton->pos() );
+ }
+ if (hover || sunken)
+ {
+ const_cast<LiquidStyle*>( this ) ->paintWidget = const_cast<QWidget*>( widget );
+ if (optionHandler->toolbuttonStyle() != Brushed)
+ drawCombo( p, cg, sunken ? cg.button().light( 110 ) :
+ (hover || (cg.button() != qApp->palette().active().button())) ? cg.button() :
+ optionHandler->InactiveButtonColor(), button.x(), button.y(), button.width(),
+ button.height(), sunken, hover, false, full );
+ else
+ drawRectangularButton( p, cg, sunken ? cg.button().light( 110 ) : cg.button(),
+ button.x(), button.y(), button.width(), button.height(),
+ sunken, hover, false);
+ const_cast<LiquidStyle*>( this ) ->paintWidget = 0L;
+ }
+ }
+ else
+ {
+ myPosition pos = full;
+ KToolBar *bar = NULL;
+
+ if (toolbutton2 && toolbutton2->parentWidget() && ::qt_cast<KToolBar*>(toolbutton2->parentWidget()) )
+ { //position calculation - would be nice if ktoolbarbutton provided this as flag
+ bar = (KToolBar*)toolbutton2->parentWidget();
+ int buttonId = toolbutton2->id();
+ int buttonIndex = bar->itemIndex(buttonId);
+
+ // ok, this is a very hackish heck of a hack...
+ // kbookmarkbar (e.g. used by konqueror) accesses the iterator of the toolbar
+ // this confuses the iterator of the toolbar a bit, as it is used from the bookmark stuff and my function at the same time (seems, as if kbookmarkbar acts on shown toolbars)
+ // unfortunately, there's no way to figure out if it does for this specific toolbar
+ // so i check for the toolbars name, knowing this will work for current konqueror - but may fail on further versions
+ // even worse - the stuff is hardcoded (assuming first item to be left aligned, last one right and the rest centered)
+ // this is crap at all - so if the best thing would be to patch qtoolbutton to provide conjuncted buttons - i'll ask them (maybe qt4)
+ if (bar && ( qstrcmp( bar->name(), "bookmarkToolBar" ) == 0 ))
+ {
+ return;
+ buttonIndex == 0 ?
+ pos = left :
+ buttonIndex == bar->count() - 1 ?
+ pos = right :
+ pos = center;
+ }
+ else if (bar->orientation() == Qt::Horizontal)
+ {
+ if (buttonIndex == 0)
+ {
+ KToolBarButton *tmpButton = bar->getButton(bar->idAt(buttonIndex+1));
+ (tmpButton && tmpButton->x() == toolbutton2->x()+toolbutton2->width()) ? pos = left : pos = full;
+ }
+ else if (buttonIndex == bar->count() - 1)
+ {
+ KToolBarButton *tmpButton = NULL;
+ tmpButton = bar->getButton(bar->idAt(buttonIndex-1));
+ (tmpButton && tmpButton->x() + tmpButton->width() == toolbutton2->x()) ? pos = right : pos = full;
+ }
+ else
+ {
+ KToolBarButton *tmpButton1 = bar->getButton(bar->idAt(buttonIndex-1));
+ KToolBarButton *tmpButton2 = bar->getButton(bar->idAt(buttonIndex+1));
+ tmpButton1 && tmpButton1->x() + tmpButton1->width() == toolbutton2->x() ?
+ pos = center : pos = left;
+ if (!(tmpButton2 && tmpButton2->x() == toolbutton2->x()+toolbutton2->width()))
+ pos == left ? pos = full : pos = right;
+ }
+ }
+ else
+ {
+ if (buttonIndex == 0)
+ {
+ KToolBarButton *tmpButton = bar->getButton(bar->idAt(buttonIndex+1));
+ (tmpButton && tmpButton->y() == toolbutton2->y()+toolbutton2->height()) ?
+ pos = left : pos = full;
+ }
+ else if (buttonIndex == bar->count() - 1)
+ {
+ KToolBarButton *tmpButton = NULL;
+ tmpButton = bar->getButton(bar->idAt(buttonIndex-1));
+ (tmpButton && tmpButton->y() + tmpButton->height() == toolbutton2->y()) ?
+ pos = right : pos = full;
+ }
+ else
+ {
+ KToolBarButton *tmpButton1 = bar->getButton(bar->idAt(buttonIndex-1));
+ KToolBarButton *tmpButton2 = bar->getButton(bar->idAt(buttonIndex+1));
+ tmpButton1 && tmpButton1->y() + tmpButton1->height() == toolbutton2->y() ?
+ pos = center : pos = left;
+ if (!(tmpButton2 && tmpButton2->y() == toolbutton2->y()+toolbutton2->height()))
+ pos == left ? pos = full : pos = right;
+ }
+ }
+ }
+
+ if (optionHandler->toolbuttonStyle() != Brushed)
+ {
+ (bar && bar->orientation() == Qt::Vertical) ?
+ drawCombo( p, cg, sunken ? cg.button().light( 110 ) : (hover || (cg.button() != qApp->palette().active().button())) ? cg.button() : optionHandler->InactiveButtonColor(), button.x(), (pos == full || pos == left) ? button.y() : button.y() - 7, button.width(), (pos == full) ? button.height()+2 : (pos == center) ? button.height()+16 : button.height()+9, sunken, hover, false, center ) :
+ drawCombo( p, cg, sunken ? cg.button().light( 110 ) : (hover || (cg.button() != qApp->palette().active().button())) ? cg.button() : optionHandler->InactiveButtonColor(), button.x(), button.y(), button.width(), button.height()/*+2*/, sunken, hover, false, pos );
+ }
+ else
+ {
+ (bar && bar->orientation() == Qt::Vertical) ?
+ drawRectangularButton( p, cg, sunken ? cg.button().light( 110 ) : (hover || (cg.button() != qApp->palette().active().button())) ? cg.button() : optionHandler->InactiveButtonColor(), button.x(), (pos == full || pos == left) ? button.y() : button.y()-4, button.width(), (pos == full) ? button.height() : (pos == center) ? button.height()+8 : button.height()+4, sunken, hover, false) :
+ drawRectangularButton( p, cg, sunken ? cg.button().light( 110 ) : (hover || (cg.button() != qApp->palette().active().button())) ? cg.button() : optionHandler->InactiveButtonColor(), button.x(), button.y(), button.width(), button.height(), sunken, hover, false, pos);
+ }
+ }
+ }
+ // Draw a toolbutton menu indicator if required
+ if ( controls & SC_ToolButtonMenu )
+ {
+ if ( mflags & ( Style_Down | Style_On | Style_Raised ) )
+ drawPrimitive( PE_ButtonDropDown, p, menuarea, cg, mflags, opt );
+ drawPrimitive( PE_ArrowDown, p, menuarea, cg, mflags, opt );
+ }
+#if 0
+ if ( toolbutton->hasFocus() && !toolbutton->focusProxy() )
+ {
+ QRect fr = toolbutton->rect();
+ fr.addCoords( 3, 3, -3, -3 );
+ drawPrimitive( PE_FocusRect, p, fr, cg );
+ }
+#endif
+ const_cast<LiquidStyle*>( this ) ->paintWidget = 0L;
+ break;
+ }
+ case CC_ScrollBar:
+ {
+ const_cast<LiquidStyle*>( this ) ->currentScrollBar = ( QScrollBar * ) widget;
+ KStyle::drawComplexControl( control, p, widget, r, cg, flags, controls, active, opt );
+ break;
+ }
+ case CC_SpinWidget: {
+ const QSpinWidget * sw = (const QSpinWidget *) widget;
+ SFlags flags;
+ PrimitiveElement pe;
+
+ if ( controls & SC_SpinWidgetFrame )
+ drawEditFrame( p, r, cg, false, sw->hasFocus());
+
+ if ( controls & SC_SpinWidgetUp ) {
+ flags = Style_Default | Style_Enabled;
+ if (active == SC_SpinWidgetUp ) {
+ flags |= Style_On;
+ flags |= Style_Sunken;
+ } else
+ flags |= Style_Raised;
+ pe = PE_SpinWidgetUp;
+
+ QRect re = sw->upRect();
+ QColorGroup ucg = sw->isUpEnabled() ? cg : sw->palette().disabled();
+ p->fillRect(re, ucg.base());
+ drawPrimitive(pe, p, re, ucg, flags);
+ }
+
+ if ( controls & SC_SpinWidgetDown ) {
+ flags = Style_Default | Style_Enabled;
+ if (active == SC_SpinWidgetDown ) {
+ flags |= Style_On;
+ flags |= Style_Sunken;
+ } else
+ flags |= Style_Raised;
+ pe = PE_SpinWidgetDown;
+
+ QRect re = sw->downRect();
+ QColorGroup dcg = sw->isDownEnabled() ? cg : sw->palette().disabled();
+ p->fillRect(re, dcg.base());
+ drawPrimitive(pe, p, re, dcg, flags);
+ }
+ break; }
+
+ // SLIDER - KDE code for double buffering
+ // -------------------------------------------------------------------
+ case CC_Slider: {
+ const QSlider* slider = (const QSlider*)widget;
+ QRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove, opt);
+ QRect handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle, opt);
+
+ // Double-buffer slider for no flicker
+ QPixmap pix(widget->size());
+ QPainter p2;
+ p2.begin(&pix);
+ if ( slider->parentWidget() &&
+ (slider->parentWidget()->paletteBackgroundPixmap() && !slider->parentWidget()->paletteBackgroundPixmap()->isNull() )) {
+ QPixmap pixmap = *(slider->parentWidget()->backgroundPixmap());
+ if (QWidget *topDaddy = slider->topLevelWidget()){
+ QPoint zero = QPoint(0,0);
+#if 0
+ zero = slider->mapTo(topDaddy, zero);
+ int zxmpw = zero.x()%pixmap.width();
+ int zymph;
+#endif
+ // probably due to argb mismatches in drawpixmap, this fails on kompmgr startups
+ p2.drawTiledPixmap(r, pixmap, slider->mapTo(topDaddy, zero));
+#if 0
+ for (int dx = 0; dx < pix.width(); dx += pixmap.width())
+ {
+ zymph = zero.y()%pixmap.height();
+ for (int dy = 0; dy < pix.height(); dy += pixmap.height())
+ {
+ copyBlt (&pix, dx, dy, &pixmap,
+ zxmpw, zymph,
+ pix.width()-dx>pixmap.width()-zxmpw?pixmap.width()-zxmpw:pix.width()-dx, pix.height()-dy>pixmap.height()-zymph?pixmap.height()-zymph:pix.height()-dy);
+ zymph=0;
+ }
+ zxmpw=0;
+ }
+#endif
+ } else
+ {
+ // probably due to argb mismatches in drawpixmap, this fails on kompmgr startups
+ p2.drawTiledPixmap(r, pixmap, slider->pos());
+#if 0
+ for (int dx = 0; dx < pix.width(); dx += pixmap.width())
+ for (int dy = 0; dy < pix.height(); dy += pixmap.height())
+ copyBlt (&pix, dx, dy, &pixmap, 0, 0,
+ pix.width()-dx>pixmap.width()?pixmap.width():pix.width()-dx, pix.height()-dy>pixmap.height()?pixmap.height():pix.height()-dy);
+#endif
+ }
+ // p2.begin(&pix);
+ } else{
+ // p2.begin(&pix);
+ pix.fill(cg.background());
+ }
+
+ // Draw slider groove
+ if ((controls & SC_SliderGroove) && groove.isValid()) {
+ drawKStylePrimitive( KPE_SliderGroove, &p2, widget, groove, cg, flags, opt );
+
+ // Draw the focus rect around the groove
+ /* if (slider->hasFocus())
+ drawPrimitive(PE_FocusRect, &p2, groove, cg);*/
+ }
+
+ // Draw the tickmarks
+ if (controls & SC_SliderTickmarks)
+ QCommonStyle::drawComplexControl(control, &p2, widget,
+ r, cg, flags, SC_SliderTickmarks, active, opt);
+
+ // Draw the slider handle
+ if ((controls & SC_SliderHandle) && handle.isValid()) {
+ if (active == SC_SliderHandle)
+ flags |= Style_Active;
+ drawKStylePrimitive( KPE_SliderHandle, &p2, widget, handle, cg, flags, opt );
+ }
+
+ p2.end();
+ bitBlt((QWidget*)widget, r.x(), r.y(), &pix);
+ break;
+ }
+
+#ifndef QT_NO_LISTVIEW
+ case CC_ListView: {
+ if ( controls & SC_ListView ) {
+ QCommonStyle::drawComplexControl( control, p, widget, r, cg, flags, controls, active, opt );
+ }
+ if ( controls & ( SC_ListViewBranch | SC_ListViewExpand ) ) {
+ if ( opt.isDefault() )
+ break;
+
+ QListViewItem *item = opt.listViewItem();
+ QListViewItem *child = item->firstChild();
+ QListView* v = item->listView();
+ bool drawDotlines = optionHandler->DrawDotlines();
+ static QBitmap *verticalLine = 0, *horizontalLine = 0;
+ static QCleanupHandler<QBitmap> qlv_cleanup_bitmap;
+ int dotoffset = 0;
+
+ if (drawDotlines && (optionHandler->DotlineStyle() == Dots)){
+ if ( !verticalLine ) {
+ // make 128*1 and 1*128 bitmaps that can be used for
+ // drawing the right sort of lines.
+ verticalLine = new QBitmap( 1, 128, TRUE );
+ horizontalLine = new QBitmap( 128, 1, TRUE );
+ QPointArray a( 64 );
+ QPainter p;
+ p.begin( verticalLine );
+ int i;
+ for( i=0; i<64; i++ )
+ a.setPoint( i, 0, i*2+1 );
+ p.setPen( optionHandler->DotlineColor() );
+ p.drawPoints( a );
+ p.end();
+ QApplication::flushX();
+ verticalLine->setMask( *verticalLine );
+ p.begin( horizontalLine );
+ for( i=0; i<64; i++ )
+ a.setPoint( i, i*2+1, 0 );
+ p.setPen( optionHandler->DotlineColor() );
+ p.drawPoints( a );
+ p.end();
+ QApplication::flushX();
+ horizontalLine->setMask( *horizontalLine );
+ qlv_cleanup_bitmap.add( &verticalLine );
+ qlv_cleanup_bitmap.add( &horizontalLine );
+ }
+ }
+
+
+ int y = r.y();
+ int c;
+ QPointArray dotlines;
+ if ( drawDotlines && active == SC_All && controls == SC_ListViewExpand ) {
+ c = 2;
+ dotlines.resize( 2 );
+ dotlines[ 0 ] = QPoint( r.right(), r.top() );
+ dotlines[ 1 ] = QPoint( r.right(), r.bottom() );
+ }
+ else {
+ int linetop = 0, linebot = 0;
+ // each branch needs at most two lines, ie. four end points
+ dotoffset = (item->itemPos() + item->height() - y) %2;
+ dotlines.resize( item->childCount() * 4 );
+ c = 0;
+
+ // skip the stuff above the exposed rectangle
+ while ( child && y + child->height() <= 0 ) {
+ y += child->totalHeight();
+ child = child->nextSibling();
+ }
+
+ int bx = r.width() / 2;
+
+ // paint stuff in the magical area
+ while ( child && y < r.height() ) {
+ int lh;
+ if ( !item->multiLinesEnabled() )
+ lh = child ? child->height() : 0;
+ else
+ lh = p->fontMetrics().height() + 2 * v->itemMargin();
+ lh = QMAX( lh, QApplication::globalStrut().height() );
+ if ( lh % 2 > 0 )
+ lh++;
+ linebot = y + lh / 2;
+ if ( ( child->isExpandable() || child->childCount() ) && ( child->height() > 0 ) ) {
+ if ( optionHandler->ExpanderStyle() == MS ) { // f****** M$ +/- style :-(
+ // needs a box
+ p->setPen( optionHandler->DotlineColor() );
+ p->drawRect( bx - 4, linebot - 4, 9, 9 );
+ // plus or minus
+ p->setPen( optionHandler->UseCustomExpanderColor() ? optionHandler->CustomExpanderColor() : cg.text() );
+ p->drawLine( bx - 2, linebot, bx + 2, linebot );
+ if ( !child->isOpen() )
+ p->drawLine( bx, linebot - 2, bx, linebot + 2 );
+ } else { // ultracool triangles ;-)
+ QPointArray a;
+ p->setPen( optionHandler->UseCustomExpanderColor() ? optionHandler->CustomExpanderColor() : cg.text() );
+ if ( child->isOpen() ) {
+ a.setPoints( 3, bx - 4, linebot - 2,
+ bx, linebot + 2,
+ bx + 4, linebot - 2 );
+ } //DownArrow
+ else {
+ a.setPoints( 3, bx - 2, linebot - 4,
+ bx + 2, linebot,
+ bx - 2, linebot + 4 );
+ } //RightArrow
+ p->setBrush( optionHandler->UseCustomExpanderColor() ? optionHandler->CustomExpanderColor() : cg.text() );
+ p->drawPolygon( a );
+
+ p->setBrush( NoBrush );
+ }
+ // dotlinery
+ if ( drawDotlines ) {
+ dotlines[ c++ ] = QPoint( bx, linetop );
+ dotlines[ c++ ] = QPoint( bx, linebot - (/* optionHandler->plusMinus() ? 4 : */5 ) );
+ dotlines[ c++ ] = QPoint( bx + 5, linebot );
+ dotlines[ c++ ] = QPoint( r.width(), linebot );
+ linetop = linebot + 5;
+ }
+ } else {
+ // just dotlinery
+ if ( drawDotlines ) {
+ dotlines[ c++ ] = QPoint( bx + 2, linebot );
+ dotlines[ c++ ] = QPoint( r.width(), linebot );
+ }
+ }
+
+ y += child->totalHeight();
+ child = child->nextSibling();
+ }
+
+ // Expand line height to edge of rectangle if there's a
+ // child, and it's visible
+ if ( child && ( child->height() > 0 ) ) {
+ linebot = r.height();
+ }
+
+ if ( drawDotlines ) {
+ if ( linetop < linebot ) {
+ dotlines[ c++ ] = QPoint( bx, linetop );
+ dotlines[ c++ ] = QPoint( bx, linebot );
+ }
+ }
+ }
+
+ if ( drawDotlines && optionHandler->DotlineStyle() == Line) {
+ int line; // index into dotlines
+ p->setPen( optionHandler->DotlineColor() );
+
+ if ( controls & SC_ListViewBranch )
+ for ( line = 0; line < c; line += 2 ) {
+ p->drawLine( dotlines[ line ].x(), dotlines[ line ].y(),
+ dotlines[ line + 1 ].x(), dotlines[ line + 1 ].y() );
+ }
+
+ }
+ else if (drawDotlines && (optionHandler->DotlineStyle() == Dots)) {
+ int line; // index into dotlines
+ if ( controls & SC_ListViewBranch ){
+ p->setPen( optionHandler->DotlineColor() );
+ for( line = 0; line < c; line += 2 ) {
+ // assumptions here: lines are horizontal or vertical.
+ // lines always start with the numerically lowest
+ // coordinate.
+
+ // point ... relevant coordinate of current point
+ // end ..... same coordinate of the end of the current line
+ // other ... the other coordinate of the current point/line
+ if ( dotlines[line].y() == dotlines[line+1].y() ) {
+ int end = dotlines[line+1].x();
+ int point = dotlines[line].x();
+ int other = dotlines[line].y();
+ while( point < end ) {
+ int i = 128;
+ if ( i+point > end )
+ i = end-point;
+ p->drawPixmap( point, other, *horizontalLine, 0, 0, i, 1 );
+ point += i;
+ }
+ }
+ else {
+ int end = dotlines[line+1].y();
+ int point = dotlines[line].y();
+ int other = dotlines[line].x();
+ int pixmapoffset = ((point & 1) != dotoffset ) ? 1 : 0;
+ while( point < end ) {
+ int i = 128;
+ if ( i+point > end )
+ i = end-point;
+ p->drawPixmap( other, point, *verticalLine, 0, pixmapoffset, 1, i );
+ point += i;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ break;
+ }
+#endif // QT_NO_LISTVIEW
+
+#ifndef QT_NO_TITLEBAR
+ case CC_TitleBar:
+ {
+ switch (optionHandler->style())
+ {
+ case Jaguar:
+ if (!widget->isActiveWindow()) p->drawTiledPixmap(r, *getPixmap( TitleBar ));
+ p->setPen(optionHandler->titleColor(1).dark(180));
+ p->drawLine(r.left(), r.bottom(), r.right(), r.bottom());
+ break;
+ case Panther:
+ case Tiger:
+ case Milk:
+ {
+ if (widget->isActiveWindow()) p->drawTiledPixmap(r, *getPixmap( TitleBar ));
+ p->setPen(optionHandler->titleColor(1).dark(180));
+ p->drawLine(r.left(), r.bottom(), r.right(), r.bottom());
+ break;
+ }
+ case Brushed:
+ break;
+ }
+ if ( controls & SC_TitleBarLabel )
+ {
+ QRect ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarLabel ), widget );
+ p->setPen( cg.text() );
+ p->drawText(ir.x()+2, ir.y(), ir.width()-2, ir.height(), AlignCenter | AlignVCenter | SingleLine, widget->caption() );
+ }
+
+ QRect ir;
+ bool down = FALSE;
+ QPixmap pm;
+
+ if ( controls & SC_TitleBarCloseButton )
+ {
+ ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarCloseButton ), widget );
+ down = active & SC_TitleBarCloseButton;
+ if (optionHandler->buttonStyle() == Brushed)
+ drawRectangularButton( p, cg, down ? optionHandler->titleButtonColor(0).dark(120) : optionHandler->titleButtonColor(0), ir.x(), ir.y(), ir.width(), ir.height(), down, false, false, full);
+ else
+ drawCombo( p, cg, down ? optionHandler->titleButtonColor(0).dark(120) : optionHandler->titleButtonColor(0), ir.x(), ir.y(), ir.width(), ir.height()+2, down, false, false, full );
+ }
+ if ( controls & SC_TitleBarSysMenu )
+ {
+ ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarSysMenu ), widget );
+ down = active & SC_TitleBarSysMenu;
+ if (optionHandler->buttonStyle() == Brushed)
+ drawRectangularButton( p, cg, down ? cg.button().dark(120) : cg.button(), ir.x(), ir.y(), ir.width(), ir.height(), down, false, false, full);
+ else
+ drawCombo( p, cg, down ? cg.button().dark(120) : cg.button(), ir.x(), ir.y(), ir.width(), ir.height()+2, down, false, false, full );
+ }
+
+ if ( controls & SC_TitleBarMaxButton )
+ {
+ ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarMaxButton ), widget );
+ down = active & SC_TitleBarMaxButton;
+ if (optionHandler->buttonStyle() == Brushed)
+ drawRectangularButton( p, cg, down ? optionHandler->titleButtonColor(2).dark(120) : optionHandler->titleButtonColor(2), ir.x(), ir.y(), ir.width(), ir.height(), down, false, false, full);
+ else
+ drawCombo( p, cg, down ? optionHandler->titleButtonColor(2).dark(120) : optionHandler->titleButtonColor(2), ir.x(), ir.y(), ir.width(), ir.height()+2, down, false, false, full );
+ }
+
+ if ( controls & SC_TitleBarMinButton )
+ {
+ ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarMinButton ), widget );
+ down = active & SC_TitleBarMinButton;
+ if (optionHandler->buttonStyle() == Brushed)
+ drawRectangularButton( p, cg, down ? optionHandler->titleButtonColor(1).dark(120) : optionHandler->titleButtonColor(1), ir.x(), ir.y(), ir.width(), ir.height(), down, false, false, full);
+ else
+ drawCombo( p, cg, down ? optionHandler->titleButtonColor(1).dark(120) : optionHandler->titleButtonColor(1), ir.x(), ir.y(), ir.width(), ir.height()+2, down, false, false, full );
+ }
+ if ( controls & SC_TitleBarNormalButton )
+ {
+ ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarNormalButton ), widget );
+ down = active & SC_TitleBarNormalButton;
+ if (optionHandler->buttonStyle() == Brushed)
+ drawRectangularButton( p, cg, down ? optionHandler->titleButtonColor(1).dark(120) : optionHandler->titleButtonColor(1), ir.x(), ir.y(), ir.width(), ir.height(), down, false, false, full);
+ else
+ drawCombo( p, cg, down ? optionHandler->titleButtonColor(1).dark(120) : optionHandler->titleButtonColor(1), ir.x(), ir.y(), ir.width(), ir.height()+2, down, false, false, full );
+ }
+
+ if ( controls & SC_TitleBarShadeButton )
+ {
+ ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarShadeButton ), widget );
+ down = active & SC_TitleBarShadeButton;
+ if (optionHandler->buttonStyle() == Brushed)
+ drawRectangularButton( p, cg, down ? cg.button().dark(120) : cg.button(), ir.x(), ir.y(), ir.width(), ir.height(), down, false, false, full);
+ else
+ drawCombo( p, cg, down ? cg.button().dark(120) : cg.button(), ir.x(), ir.y(), ir.width(), ir.height()+2, down, false, false, full );
+ }
+
+ if ( controls & SC_TitleBarUnshadeButton )
+ {
+ ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarUnshadeButton ), widget );
+ down = active & SC_TitleBarUnshadeButton;
+ if (optionHandler->buttonStyle() == Brushed)
+ drawRectangularButton( p, cg, down ? cg.button().dark(120) : cg.button(), ir.x(), ir.y(), ir.width(), ir.height(), down, false, false, full);
+ else
+ drawCombo( p, cg, down ? cg.button().dark(120) : cg.button(), ir.x(), ir.y(), ir.width(), ir.height()+2, down, false, false, full );
+ }
+ break;
+ }
+#endif //QT_NO_TITLEBAR
+
+ default:
+ KStyle::drawComplexControl( control, p, widget,
+ r, cg, flags, controls, active, opt );
+ break;
+ }
+}
+
+int LiquidStyle::styleHint(StyleHint sh, const QWidget * w, const QStyleOption & opt, QStyleHintReturn * shr) const
+{
+ switch (sh)
+ {
+ case QStyle::SH_GUIStyle:
+ // if (w && ::qt_cast<QMenuBar*>(w))
+ // return WindowsStyle;
+ return MacStyle;
+ case QStyle::SH_TabBar_Alignment:
+ if (optionHandler->CenterTabs() && !QApplication::reverseLayout())
+ return AlignHCenter;
+ else
+ return KStyle::styleHint(sh, w, opt, shr);
+ default:
+ return KStyle::styleHint(sh, w, opt, shr);
+ }
+}
+
+QRect LiquidStyle::subRect( SubRect r, const QWidget *widget ) const {
+ if (r == SR_ComboBoxFocusRect){
+ return querySubControlMetrics( CC_ComboBox, widget, SC_ComboBoxEditField );
+ }
+ return ( KStyle::subRect( r, widget ) );
+}
+
+int LiquidStyle::pixelMetric( PixelMetric m, const QWidget *widget ) const
+{
+ switch ( m )
+ {
+ case PM_ButtonMargin:
+ return ( 5 );
+ case PM_ButtonDefaultIndicator:
+ return ( 0 );
+ case PM_ExclusiveIndicatorWidth:
+ case PM_ExclusiveIndicatorHeight:
+ return ( 16 );
+ case PM_IndicatorWidth:
+ case PM_IndicatorHeight:
+ return ( 16 );
+ case PM_ScrollBarExtent:
+ return ( 15 );
+ case PM_ScrollBarSliderMin:
+ if (isOOO) return 10; return ( 40 );
+ case PM_SplitterWidth:
+ return 6;
+ case PM_SliderControlThickness:
+ return(15);
+ case PM_SliderThickness:
+ return ( 22 );
+ /* if (widget && (widget->width() < widget->height() && widget->width() < 17) || (widget->width() > widget->height() && widget->height() < 17))
+ return (16);*/
+ case PM_SliderLength:
+ return ( optionHandler->style() == Milk ? 15 : 13 );
+ case PM_TabBarTabOverlap:
+ return 0;
+ case PM_DefaultFrameWidth:
+ {
+ /*
+ if (widget && ::qt_cast<QFrame*>(widget) && ((QFrame*)widget)->frameShape() == QFrame::LineEditPanel)
+ return 6;*/
+ if (widget && widget->parentWidget() && ::qt_cast<QTabWidget*>(widget->parentWidget()) && widget->parentWidget()->parentWidget() && (widget->parentWidget()->parentWidget()->inherits("KonqMainWindow") || widget->parentWidget()->parentWidget()->inherits("KonqFrameContainer"))) //for the konqueror statusbar offset, thanks konqueror team... ... ... f***f***f***!!!
+ return 0;
+ return 2;
+ }
+ case PM_TabBarBaseOverlap:
+ case PM_TabBarBaseHeight:
+ {
+ if (!widget || !::qt_cast<QTabWidget*>(widget) || !widget->children())
+ return 0;
+ QObjectListIt it( *widget->children() ); // iterate over the buttons
+ QObject *obj;
+ QTabBar *tabBar = 0L;
+ while ( (obj = it.current()) != 0 )
+ {
+ ++it;
+ if (::qt_cast<QTabBar*>(obj))
+ {
+ tabBar = (QTabBar*)obj;
+ break;
+ }
+ }
+ if (!tabBar || !tabBar->isVisible())
+ return 0;
+ if (optionHandler->TabStyle() == Chooser || (optionHandler->TabStyle() == Clever && widget && widget->topLevelWidget()->inherits("QDialog")))
+ return 12;
+ if (m == PM_TabBarBaseOverlap)
+ return 2;
+ return 7;
+ }
+ case PM_TabBarTabHSpace:
+ if (optionHandler->TabStyle() == Chooser || (optionHandler->TabStyle() == Clever && widget && widget->topLevelWidget()->inherits("QDialog"))) return 18;
+ return 24;
+ case PM_TabBarTabVSpace:
+ {
+ if (optionHandler->TabStyle() == Chooser || (optionHandler->TabStyle() == Clever && widget && widget->topLevelWidget()->inherits("QDialog"))) return 6;
+ return 10;
+ }
+ case PM_TabBarTabShiftHorizontal:
+ return 0;
+ case PM_TabBarTabShiftVertical:
+ if (optionHandler->TabStyle() == Chooser || (optionHandler->TabStyle() == Clever && widget && widget->topLevelWidget()->inherits("QDialog"))) return 0;
+ return 2;
+ case PM_ButtonShiftHorizontal:
+ return 0;
+ case PM_ButtonShiftVertical:
+ return 0;
+ default:
+ return KStyle::pixelMetric( m, widget );
+ }
+}
+
+QSize LiquidStyle::sizeFromContents( ContentsType contents,
+ const QWidget *widget,
+ const QSize &contentSize,
+ const QStyleOption& opt ) const {
+ switch ( contents ) {
+ case CT_PushButton: {
+ // this is a little funky - we give values not based on pixelMetric
+ // because we want a custom width/height and we can only give one
+ // value in pixelMetric (used in sizeHint). Odd but works well
+ const QPushButton * button = ( const QPushButton* ) widget;
+
+ int w = contentSize.width() + 26 > 80 ? contentSize.width() + 26 : 80;
+ int h = contentSize.height() > 24 ? contentSize.height() : 25;
+
+ if ( button->text().isEmpty() )
+ return ( QSize( contentSize.width() + 2 * pixelMetric( PM_ButtonMargin, widget ), h ) );
+
+ return ( QSize( w, h ) );
+ }
+
+ case CT_ToolButton: {
+ if (widget->parentWidget() && ::qt_cast<QTabWidget*>(widget->parentWidget())){
+ return QSize(contentSize.width() + 6, contentSize.height() + 5);
+ }
+ else{
+ int w = contentSize.width() + 6;
+ int sh = contentSize.height() + 5;
+ int sw = (int)(1.3*sh);
+ if (w < sw)
+ return QSize(sw, sh);
+ else
+ return QSize(w, sh);
+ }
+ }
+
+ case CT_Slider: {
+ int h = contentSize.height() > 24 ? contentSize.height() : 24;
+ return ( QSize( contentSize.width(), h ) );
+ }
+
+ case CT_ComboBox: {
+ // QSize sz = KStyle::sizeFromContents( contents, widget, contentSize, opt );
+ // return ( QSize( sz.width()+3, sz.height() > 25 ? sz.height() : 25 ) );
+ if ( ::qt_cast<const QComboBox *>(widget) && ((const QComboBox *)widget)->editable())
+ return ( QSize( contentSize.width()+27, contentSize.height() + 4 > 22 ? contentSize.height() + 4 : 26 ) );
+ else
+ return ( QSize( contentSize.width()+27, contentSize.height() + 2 > 24 ? contentSize.height() + 2 : 24 ) );
+ }
+ case CT_PopupMenuItem: {
+ if ( ! widget || opt.isDefault() )
+ break;
+
+ const QPopupMenu *popup = ( const QPopupMenu * ) widget;
+ bool checkable = popup->isCheckable();
+ QMenuItem *mi = opt.menuItem();
+ int maxpmw = opt.maxIconWidth();
+ int w = contentSize.width();
+ int h = contentSize.height();
+
+ if ( mi->custom() ) {
+ w = mi->custom() ->sizeHint().width();
+ h = mi->custom() ->sizeHint().height();
+ if ( !mi->custom() ->fullSpan() )
+ h += 2 * windowsItemVMargin + 2 * windowsItemFrame;
+ } else if ( mi->widget() ) {}
+ else if ( mi->isSeparator() ) {
+ w = 10;
+ h = windowsSepHeight;
+ } else {
+ if ( mi->pixmap() )
+ h = QMAX( h, mi->pixmap() ->height() + 2 * windowsItemFrame );
+ else if ( ! mi->text().isNull() )
+ h = QMAX( h, popup->fontMetrics().height() + 2 * windowsItemVMargin +
+ 2 * windowsItemFrame );
+ if ( mi->iconSet() != 0 )
+ h = QMAX( h, mi->iconSet() ->pixmap( QIconSet::Small,
+ QIconSet::Normal ).height() +
+ 2 * windowsItemFrame );
+ }
+ if ( !mi->text().isNull() && mi->text().find( '\t' ) >= 0 )
+ w += windowsTabSpacing;
+ else if ( mi->popup() )
+ w += 2 * windowsArrowHMargin;
+ if ( checkable && maxpmw < 20 )
+ w += 20 - maxpmw;
+ if ( maxpmw )
+ w += maxpmw + 6;
+ if ( checkable || maxpmw > 0 )
+ w += windowsCheckMarkHMargin;
+ w += 20;
+ return ( QSize( w, h ) );
+ }
+ default:
+ break;
+ }
+ return KStyle::sizeFromContents( contents, widget, contentSize, opt );
+}
+
+
+QPixmap LiquidStyle::stylePixmap( StylePixmap stylepixmap,
+ const QWidget* widget,
+ const QStyleOption& opt ) const {
+ return KStyle::stylePixmap( stylepixmap, widget, opt );
+}
+
+#include "eventfilter.cpp"
+
+QRect LiquidStyle::querySubControlMetrics( ComplexControl control, const QWidget *widget, SubControl subcontrol, const QStyleOption &opt ) const
+{
+ if ( control == CC_ComboBox && subcontrol == SC_ComboBoxEditField )
+ return QRect( 8, 3, widget->width() - 32, widget->height() - 7 );
+ if (control == CC_TitleBar)
+ {
+ switch (subcontrol)
+ {
+ case SC_TitleBarSysMenu:
+ return QRect( widget->width() - 24, 1, 16, 16 );
+ case SC_TitleBarMinButton:
+ return QRect( 26, 1, 16, 16 );
+ case SC_TitleBarMaxButton:
+ return QRect( 47, 1, 16, 16 );
+ case SC_TitleBarCloseButton:
+ return QRect( 5, 1, 16, 16 );
+ case SC_TitleBarLabel:
+ return QRect( 68, 1, widget->width() - 107, 16 );
+ case SC_TitleBarNormalButton:
+ return QRect( 26, 1, 16, 16 );
+ case SC_TitleBarShadeButton:
+ return QRect( widget->width() - 29, 1, 24, 16 );
+ case SC_TitleBarUnshadeButton:
+ return QRect( widget->width() - 29, 1, 24, 16 );
+ default:
+ return ( KStyle::querySubControlMetrics( control, widget, subcontrol, opt ) );
+ }
+ }
+ else
+ return ( KStyle::querySubControlMetrics( control, widget, subcontrol, opt ) );
+}
+
+QImage LiquidStyle::fetchImage( const char *name ){
+ return uic_findImage( name );
+}
+
+QColor LiquidStyle::mapFadeColor(QColor &color, int index) const
+{
+ QRgb **rgb = fadeColorMap.find(color.rgb());
+ if (rgb)
+ return QColor((*rgb)[index]);
+ // no color map found, create one and return the queried value
+ rgb = new QRgb*;
+ *rgb = new QRgb[10];
+ int iRed = optionHandler->InactiveButtonColor().red();
+ int iGreen = optionHandler->InactiveButtonColor().green();
+ int iBlue = optionHandler->InactiveButtonColor().blue();
+ int cRed = color.red();
+ int cGreen = color.green();
+ int cBlue = color.blue();
+ for (int i = 10; i < 20; i++)
+ {
+ (*rgb)[i-10] = qRgb( iRed + (cRed-iRed)*(i)/20, iGreen + (cGreen-iGreen)*(i)/20, iBlue + (cBlue-iBlue)*(i)/20);
+ }
+ LiquidStyle *ptr = const_cast<LiquidStyle*>( this );
+ ptr->fadeColorMap.insert(color.rgb(), rgb);
+ return QColor((*rgb)[index]);
+}
+
+QPixmap* LiquidStyle::processEmbedded( const char *label, const QColor &c, bool blend, const QColor *bg ) const {
+ QImage img( uic_findImage( label ) );
+ img.detach();
+ if ( img.isNull() ) { // shouldn't happen, been tested
+ qWarning( "Invalid embedded label %s", label );
+ return ( NULL );
+ }
+ return ( adjustHSV( img, c, bg ) );
+}
+
+QPixmap* LiquidStyle::getPixmap( BitmapData item ) const
+{
+ if ( pixmaps[ item ] )
+ return ( pixmaps[ item ] );
+ QColor bgColor( optionHandler->InactiveButtonColor() );
+ QColor btnColor( isOOO ? optionHandler->CustomButtonColor() : qApp->palette().active().button() );
+ QColor btnHoverColor( isOOO ? optionHandler->CustomButtonColor().light(120) : btnColor.light( 120 ) );
+ QColor sbGrooveColor( optionHandler->useCustomColors() ?
+ optionHandler->customColor( CustomSBGroove ) : bgColor );
+ QColor sbSliderColor( optionHandler->useCustomColors() ?
+ optionHandler->customColor( CustomSBSlider ) : bgColor );
+ QColor sbSliderHoverColor( optionHandler->useCustomColors() ?
+ optionHandler->customColor( CustomSBSliderHover ) : isOOO?optionHandler->CustomButtonColor():btnColor );
+ QColor sbSliderPressedColor( optionHandler->useCustomColors() ?
+ optionHandler->customColor( CustomSBSliderPressed ) : btnColor.dark(110) );
+ LiquidStyle *ptr = const_cast<LiquidStyle*>( this );
+ switch ( item )
+ {
+ case RadioOn:
+ ptr->pixmaps[ RadioOn ] = processEmbedded( (optionHandler->style() == Milk) ? "radio_down-milk" : "radio_down", optionHandler->useCustomColors() ? optionHandler->customColor( CustomRadioOn ) : btnColor, true );
+ break;
+ case RadioOff:
+ ptr->pixmaps[ RadioOff ] = processEmbedded( (optionHandler->style() == Milk) ? "radio-milk" : "radio", optionHandler->useCustomColors() ? optionHandler->customColor( CustomRadioOff ) : bgColor, true );
+ break;
+ case RadioOnHover:
+ ptr->pixmaps[ RadioOnHover ] = processEmbedded( (optionHandler->style() == Milk) ? "radio_down-milk" : "radio_down", optionHandler->useCustomColors() ? optionHandler->customColor( CustomRadioOn ).light( 110 ) : btnHoverColor, true );
+ break;
+ case RadioOffHover:
+ ptr->pixmaps[ RadioOffHover ] = processEmbedded( (optionHandler->style() == Milk) ? "radio-milk" : "radio", optionHandler->useCustomColors() ? optionHandler->customColor( CustomRadioOn ) : btnColor, true );
+ case RadioOnPressed:
+ ptr->pixmaps[ RadioOnPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "radio_down-milk" : "radio_down", optionHandler->useCustomColors() ? optionHandler->customColor( CustomRadioOn ).dark( 120 ) : btnHoverColor.dark( 120 ), true );
+ break;
+ case RadioOffPressed:
+ ptr->pixmaps[ RadioOffPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "radio-milk" : "radio", optionHandler->useCustomColors() ? optionHandler->customColor( CustomRadioOn ).dark( 120 ) : btnColor.dark( 120 ), true );
+ break;
+ case Tab:
+ ptr->pixmaps[ Tab ] = processEmbedded( (optionHandler->style() == Jaguar) ? "tab-jaguar" : (optionHandler->style() == Milk) ? "tab-milk" : "tab", optionHandler->useCustomColors() ? optionHandler->customColor( CustomTabOff ) : optionHandler->InactiveButtonColor(), true );
+ break;
+ case belowTab:
+ ptr->pixmaps[ belowTab ] = processEmbedded( (optionHandler->style() == Jaguar) ? "tab-jaguar" : (optionHandler->style() == Milk) ? "tab-milk" : "tab", optionHandler->useCustomColors() ? optionHandler->customColor( CustomTabOff ) : optionHandler->InactiveButtonColor(), true );
+ *ptr->pixmaps[ belowTab ] = ptr->pixmaps[ belowTab ] ->xForm( iMatrix );
+ break;
+ case TabDown:
+ ptr->pixmaps[ TabDown ] = processEmbedded( (optionHandler->style() == Jaguar) ? "tab-jaguar" : (optionHandler->style() == Milk) ? "tab-milk" : "tab", optionHandler->useCustomColors() ? optionHandler->customColor( CustomTabOn ) : btnColor, true );
+ break;
+ case belowTabDown:
+ ptr->pixmaps[ belowTabDown ] = processEmbedded( (optionHandler->style() == Jaguar) ? "tab-jaguar" : (optionHandler->style() == Milk) ? "tab-milk" : "tab", optionHandler->useCustomColors() ? optionHandler->customColor( CustomTabOn ) : btnColor, true );
+ *ptr->pixmaps[ belowTabDown ] = ptr->pixmaps[ belowTabDown ] ->xForm( iMatrix );
+ break;
+ case TabFocus:
+ ptr->pixmaps[ TabFocus ] = processEmbedded( (optionHandler->style() == Jaguar) ? "tab-jaguar" : (optionHandler->style() == Milk) ? "tab-milk" : "tab", optionHandler->useCustomColors() ? optionHandler->customColor( CustomTabOn ).light( 120 ) : btnHoverColor, true );
+ break;
+ case CB:
+ ptr->pixmaps[ CB ] = processEmbedded( (optionHandler->style() == Milk) ? "checkbox-milk" : "checkbox", optionHandler->useCustomColors() ? optionHandler->customColor( CustomCBOff ) : bgColor, true );
+ break;
+ case CBDown:
+ ptr->pixmaps[ CBDown ] = processEmbedded( (optionHandler->style() == Milk) ? "checkboxdown-milk" : "checkboxdown", optionHandler->useCustomColors() ? optionHandler->customColor( CustomCBOn ) : btnColor, true );
+ break;
+ case CBDownHover:
+ ptr->pixmaps[ CBDownHover ] = processEmbedded( (optionHandler->style() == Milk) ? "checkboxdown-milk" : "checkboxdown", optionHandler->useCustomColors() ? optionHandler->customColor( CustomCBOn ).light( 110 ) : btnHoverColor, true );
+ break;
+ case CBTri:
+ ptr->pixmaps[ CBTri ] = processEmbedded( (optionHandler->style() == Milk) ? "checkboxdown-milk" : "checkboxdown", optionHandler->useCustomColors() ? optionHandler->customColor( CustomCBOn ) : btnColor, true );
+ *ptr->pixmaps[ CBTri ] = ptr->pixmaps[ CBTri ] ->xForm( mMatrix );
+ break;
+ case CBTriHover:
+ ptr->pixmaps[ CBTriHover ] = processEmbedded( (optionHandler->style() == Milk) ? "checkboxdown-milk" : "checkboxdown", optionHandler->useCustomColors() ? optionHandler->customColor( CustomCBOn ).light( 110 ) : btnHoverColor, true );
+ *ptr->pixmaps[ CBTriHover ] = ptr->pixmaps[ CBTriHover ] ->xForm( mMatrix );
+ break;
+ case CBHover:
+ ptr->pixmaps[ CBHover ] = processEmbedded( (optionHandler->style() == Milk) ? "checkbox-milk" : "checkbox", optionHandler->useCustomColors() ? optionHandler->customColor( CustomCBOn ) : btnColor, true );
+ break;
+ case CBDownPressed:
+ ptr->pixmaps[ CBDownPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "checkboxdown-milk" : "checkboxdown", optionHandler->useCustomColors() ? optionHandler->customColor( CustomCBOn ).dark( 120 ) : btnHoverColor.dark( 120 ), true );
+ break;
+ case CBTriPressed:
+ ptr->pixmaps[ CBTriPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "checkboxdown-milk" : "checkboxdown", optionHandler->useCustomColors() ? optionHandler->customColor( CustomCBOn ).dark( 120 ) : btnHoverColor.dark( 120 ), true );
+ *ptr->pixmaps[ CBTriPressed ] = ptr->pixmaps[ CBTriPressed ] ->xForm( mMatrix );
+ break;
+ case CBPressed:
+ ptr->pixmaps[ CBPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "checkbox-milk" : "checkbox", optionHandler->useCustomColors() ? optionHandler->customColor( CustomCBOn ).dark( 120 ) : btnColor.dark( 120 ), true );
+ break;
+ case HSlider:
+ ptr->pixmaps[ HSlider ] = processEmbedded( (optionHandler->style() == Milk) ? "sliderarrow-milk" : "sliderarrow", btnColor, true );
+ break;
+ case VSlider:
+ ptr->pixmaps[ VSlider ] = processEmbedded( (optionHandler->style() == Milk) ? "sliderarrow-milk" : "sliderarrow", btnColor, true );
+ *ptr->pixmaps[ VSlider ] = ptr->pixmaps[ VSlider ] ->xForm( lMatrix );
+ break;
+ case VSliderAbove:
+ ptr->pixmaps[ VSliderAbove ] = processEmbedded( (optionHandler->style() == Milk) ? "sliderarrow-milk" : "sliderarrow", btnColor, true );
+ *ptr->pixmaps[ VSliderAbove ] = ptr->pixmaps[ VSliderAbove ] ->xForm( rMatrix );
+ break;
+ case HSliderInactive:
+ ptr->pixmaps[ HSliderInactive ] = processEmbedded( (optionHandler->style() == Milk) ? "sliderarrow-milk" : "sliderarrow", bgColor, true );
+ break;
+ case VSliderInactive:
+ ptr->pixmaps[ VSliderInactive ] = processEmbedded( (optionHandler->style() == Milk) ? "sliderarrow-milk" : "sliderarrow", bgColor, true );
+ *ptr->pixmaps[ VSliderInactive ] = ptr->pixmaps[ VSliderInactive ] ->xForm( lMatrix );
+ break;
+ case VSliderAboveInactive:
+ ptr->pixmaps[ VSliderAboveInactive ] = processEmbedded( (optionHandler->style() == Milk) ? "sliderarrow-milk" : "sliderarrow", bgColor, true );
+ *ptr->pixmaps[ VSliderAboveInactive ] = ptr->pixmaps[ VSliderAboveInactive ] ->xForm( rMatrix );
+ break;
+ case VSBSliderTop:
+ ptr->pixmaps[ VSBSliderTop ] = optionHandler->shadowSbSlider() ? createSliderEnd( sbSliderColor, sbGrooveColor.dark( 120 ), true) : processEmbedded( (optionHandler->style() == Milk) ? "sbslider_top-milk" : "sbslider_top", sbSliderColor, true, &sbGrooveColor );
+ break;
+ case VSBSliderBtm:
+ ptr->pixmaps[ VSBSliderBtm ] = optionHandler->shadowSbSlider() ? createSliderEnd( sbSliderColor, sbGrooveColor.dark( 120 ), false) : processEmbedded( (optionHandler->style() == Milk) ? "sbslider_btm-milk" : "sbslider_btm", sbSliderColor, true, &sbGrooveColor );
+ break;
+ case VSBSliderMid:
+ ptr->pixmaps[ VSBSliderMid ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_mid-milk" : "sbIslider_mid", sbSliderColor, &sbGrooveColor );
+ break;
+ case VSBSliderTopActive:
+ ptr->pixmaps[ VSBSliderTopActive ] = optionHandler->shadowSbSlider() ? createSliderEnd( sbSliderHoverColor, sbGrooveColor.dark( 120 ), true) : processEmbedded( (optionHandler->style() == Milk) ? "sbslider_top-milk" : "sbslider_top", sbSliderHoverColor, true, &sbGrooveColor );
+ break;
+ case VSBSliderBtmActive:
+ ptr->pixmaps[ VSBSliderBtmActive ] = optionHandler->shadowSbSlider() ? createSliderEnd( sbSliderHoverColor, sbGrooveColor.dark( 120 ), false) : processEmbedded( (optionHandler->style() == Milk) ? "sbslider_btm-milk" : "sbslider_btm", sbSliderHoverColor, true, &sbGrooveColor );
+ break;
+ case VSBSliderMidActive:
+ ptr->pixmaps[ VSBSliderMidActive ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_mid-milk" : "sbslider_mid", sbSliderHoverColor, false, &sbGrooveColor );
+ break;
+ case VSBSliderTopPressed:
+ ptr->pixmaps[ VSBSliderTopPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_top-milk" : "sbslider_top", sbSliderPressedColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ VSBSliderTopPressed ] = ptr->pixmaps[ VSBSliderTopPressed ] ->xForm( mMatrix );
+ break;
+ case VSBSliderBtmPressed:
+ ptr->pixmaps[ VSBSliderBtmPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_btm-milk" : "sbslider_btm", sbSliderPressedColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ VSBSliderBtmPressed ] = ptr->pixmaps[ VSBSliderBtmPressed ] ->xForm( mMatrix );
+ break;
+ case VSBSliderMidPressed:
+ ptr->pixmaps[ VSBSliderMidPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_mid-milk" : "sbslider_mid", sbSliderPressedColor, false, &sbGrooveColor );
+ if (optionHandler->style() == Milk)
+ *ptr->pixmaps[ VSBSliderMidPressed ] = ptr->pixmaps[ VSBSliderMidPressed ] ->xForm( iMatrix );
+ break;
+
+ case HSBSliderTop:
+ ptr->pixmaps[ HSBSliderTop ] = optionHandler->shadowSbSlider() ? createSliderEnd( sbSliderColor, sbGrooveColor.dark( 120 ), true) : processEmbedded( (optionHandler->style() == Milk) ? "sbslider_top-milk" : "sbslider_top", sbSliderColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderTop ] = ptr->pixmaps[ HSBSliderTop ]->xForm( rMatrix );
+ break;
+ case HSBSliderBtm:
+ ptr->pixmaps[ HSBSliderBtm ] = optionHandler->shadowSbSlider() ? createSliderEnd( sbSliderColor, sbGrooveColor.dark( 120 ), false) : processEmbedded( (optionHandler->style() == Milk) ? "sbslider_btm-milk" : "sbslider_btm", sbSliderColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderBtm ] = ptr->pixmaps[ HSBSliderBtm ] ->xForm( rMatrix );
+ break;
+ case HSBSliderMid:
+ ptr->pixmaps[ HSBSliderMid ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_mid-milk" : "sbIslider_mid", sbSliderColor, false, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderMid ] = ptr->pixmaps[ HSBSliderMid ]->xForm( rMatrix );
+ break;
+ case HSBSliderTopActive:
+ ptr->pixmaps[ HSBSliderTopActive ] = optionHandler->shadowSbSlider() ? createSliderEnd( sbSliderHoverColor, sbGrooveColor.dark( 120 ), true) : processEmbedded( (optionHandler->style() == Milk) ? "sbslider_top-milk" : "sbslider_top", sbSliderHoverColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderTopActive ] = ptr->pixmaps[ HSBSliderTopActive ] ->xForm( rMatrix );
+ break;
+ case HSBSliderBtmActive:
+ ptr->pixmaps[ HSBSliderBtmActive ] = optionHandler->shadowSbSlider() ? createSliderEnd( sbSliderHoverColor, sbGrooveColor.dark( 120 ), false) : processEmbedded( (optionHandler->style() == Milk) ? "sbslider_btm-milk" : "sbslider_btm", sbSliderHoverColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderBtmActive ] = ptr->pixmaps[ HSBSliderBtmActive ] ->xForm( rMatrix );
+ break;
+ case HSBSliderMidActive:
+ ptr->pixmaps[ HSBSliderMidActive ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_mid-milk" : "sbslider_mid", sbSliderHoverColor, false, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderMidActive ] = ptr->pixmaps[ HSBSliderMidActive ] ->xForm( rMatrix );
+ break;
+ case HSBSliderTopPressed:
+ ptr->pixmaps[ HSBSliderTopPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_top-milk" : "sbslider_top", sbSliderPressedColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderTopPressed ] = ptr->pixmaps[ HSBSliderTopPressed ] ->xForm( mMatrix );
+ *ptr->pixmaps[ HSBSliderTopPressed ] = ptr->pixmaps[ HSBSliderTopPressed ] ->xForm( rMatrix );
+ break;
+ case HSBSliderBtmPressed:
+ ptr->pixmaps[ HSBSliderBtmPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_btm-milk" : "sbslider_btm", sbSliderPressedColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderBtmPressed ] = ptr->pixmaps[ HSBSliderBtmPressed ] ->xForm( mMatrix );
+ *ptr->pixmaps[ HSBSliderBtmPressed ] = ptr->pixmaps[ HSBSliderBtmPressed ] ->xForm( rMatrix );
+ break;
+ case HSBSliderMidPressed:
+ ptr->pixmaps[ HSBSliderMidPressed ] = processEmbedded( (optionHandler->style() == Milk) ? "sbslider_mid-milk" : "sbslider_mid", sbSliderPressedColor, false, &sbGrooveColor );
+ if (optionHandler->style() == Milk)
+ *ptr->pixmaps[ HSBSliderMidPressed ] = ptr->pixmaps[ HSBSliderMidPressed ] ->xForm( lMatrix );
+ else
+ *ptr->pixmaps[ HSBSliderMidPressed ] = ptr->pixmaps[ HSBSliderMidPressed ] ->xForm( rMatrix );
+ break;
+ case VSBSliderTopBg:
+ ptr->pixmaps[ VSBSliderTopBg ] = processEmbedded( (optionHandler->style() == Milk) ? "sbgroove_top-milk" : "sbgroove_top", sbGrooveColor, true, &sbGrooveColor );
+ break;
+ case VSBSliderBtmBg:
+ ptr->pixmaps[ VSBSliderBtmBg ] = processEmbedded( (optionHandler->style() == Milk) ? "sbgroove_btm-milk" : "sbgroove_btm", sbGrooveColor, true, &sbGrooveColor );
+ break;
+ case VSBSliderMidBg:
+ ptr->pixmaps[ VSBSliderMidBg ] = processEmbedded( (optionHandler->style() == Milk) ? "sbgroove_mid-milk" : "sbgroove_mid", sbGrooveColor, false, &sbGrooveColor );
+ break;
+ case VSBSliderMidBgI:
+ ptr->pixmaps[ VSBSliderMidBgI ] = processEmbedded( (optionHandler->style() == Milk) ? "sb_subadd-milk" : "sb_subadd", sbGrooveColor, false, &sbGrooveColor );
+ break;
+ case HSBSliderTopBg:
+ ptr->pixmaps[ HSBSliderTopBg ] = processEmbedded( (optionHandler->style() == Milk) ? "sbgroove_top-milk" : "sbgroove_top", sbGrooveColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderTopBg ] = ptr->pixmaps[ HSBSliderTopBg ] ->xForm( rMatrix );
+ break;
+ case HSBSliderBtmBg:
+ ptr->pixmaps[ HSBSliderBtmBg ] = processEmbedded( (optionHandler->style() == Milk) ? "sbgroove_btm-milk" : "sbgroove_btm", sbGrooveColor, true, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderBtmBg ] = ptr->pixmaps[ HSBSliderBtmBg ] ->xForm( rMatrix );
+ break;
+ case HSBSliderMidBg:
+ ptr->pixmaps[ HSBSliderMidBg ] = processEmbedded( (optionHandler->style() == Milk) ? "sbgroove_mid-milk" : "sbgroove_mid", sbGrooveColor, false, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderMidBg ] = ptr->pixmaps[ HSBSliderMidBg ] ->xForm( rMatrix );
+ break;
+ case HSBSliderMidBgI:
+ ptr->pixmaps[ HSBSliderMidBgI ] = processEmbedded( (optionHandler->style() == Milk) ? "sb_subadd-milk" : "sb_subadd", sbGrooveColor, false, &sbGrooveColor );
+ *ptr->pixmaps[ HSBSliderMidBgI ] = ptr->pixmaps[ HSBSliderMidBgI ] ->xForm( rMatrix );
+ break;
+
+ case Progress:
+ ptr->pixmaps[ Progress ] = processEmbedded( "progress", btnColor );
+ break;
+ case progress2:
+ ptr->pixmaps[ progress2 ] = processEmbedded( "progress2", btnColor );
+ break;
+
+ case TitleBar:
+ {
+ if (optionHandler->style() == Jaguar)
+ {
+ ptr->pixmaps[ TitleBar ] = new QPixmap(32,22);
+ ptr->pixmaps[ TitleBar ]->fill( optionHandler->titleColor(0) );
+ QPainter p;
+ p.begin( ptr->pixmaps[ TitleBar ] );
+ p.setPen( QColor(
+ (optionHandler->titleColor(0).red()+optionHandler->titleColor(1).red())/2,
+ (optionHandler->titleColor(0).green()+optionHandler->titleColor(1).green())/2,
+ (optionHandler->titleColor(0).blue()+optionHandler->titleColor(1).blue())/2 ));
+ for ( int i = 1; i < 22; i += 4 )
+ {
+ p.drawLine( 0, i, 31, i );
+ p.drawLine( 0, i+2, 31, i+2 );
+ }
+ p.setPen( optionHandler->titleColor(1));
+ for ( int i = 2; i < 22; i += 4 )
+ p.drawLine( 0, i, 31, i );
+ p.end();
+ }
+ else
+ ptr->pixmaps[ TitleBar ] = &KPixmapEffect::gradient (*((KPixmap*)(new QPixmap(32,22))), optionHandler->titleColor(0), optionHandler->titleColor(1), KPixmapEffect::VerticalGradient, 22);
+ break;
+ }
+ default:
+ break;
+ }
+ return ( pixmaps[ item ] );
+}
+
+
+#include "baghira.moc"
diff --git a/style/baghira.h b/style/baghira.h
new file mode 100644
index 0000000..1336ac2
--- /dev/null
+++ b/style/baghira.h
@@ -0,0 +1,627 @@
+#ifndef __LIQUID_STYLE_H
+#define __LIQUID_STYLE_H
+
+#include <qcstring.h>
+#include <qdir.h>
+#include <qintdict.h>
+#include <qprogressbar.h>
+#include <qtimer.h>
+#include <qwmatrix.h>
+#include <kpixmap.h>
+#include <qwidget.h>
+#include <kstyle.h>
+
+// #define BITMAP_ITEMS 75 // Don't worry, they're demand loaded ;-)
+#define LIQUID_MENU_CHANGE 667
+#define MOSFET_BUTTON_CHANGE 661
+
+class QColor;
+class QHeader;
+class QImage;
+class QMenuBar;
+class QPalette;
+class QPoint;
+class QPushButton;
+class QRect;
+class QScrollBar;
+class QSize;
+class QString;
+class QTabBar;
+class LiquidStyle;
+
+enum BitmapData{RadioOn = 0, RadioOff, RadioOnHover, RadioOffHover, RadioOnPressed, RadioOffPressed,
+ VSBSliderTop, VSBSliderMid, VSBSliderBtm,
+ VSBSliderTopActive, VSBSliderMidActive, VSBSliderBtmActive,
+ VSBSliderTopPressed, VSBSliderMidPressed, VSBSliderBtmPressed,
+ VSBSliderTopBg, VSBSliderMidBg, VSBSliderMidBgI, VSBSliderBtmBg,
+ HSBSliderTop, HSBSliderMid, HSBSliderBtm,
+ HSBSliderTopActive, HSBSliderMidActive, HSBSliderBtmActive,
+ HSBSliderTopPressed, HSBSliderMidPressed, HSBSliderBtmPressed,
+ HSBSliderTopBg, HSBSliderMidBg, HSBSliderMidBgI, HSBSliderBtmBg,
+ Tab, TabDown, TabFocus, belowTab, belowTabDown,
+ ButtonShadow, CB, CBDown, CBTri, CBHover, CBDownHover, CBTriHover, CBPressed, CBDownPressed, CBTriPressed,
+ HSlider, VSlider, VSliderAbove, HSliderInactive, VSliderInactive, VSliderAboveInactive,
+ Progress, rectbutton, combo, comboShadow, progress2, TitleBar, BITMAP_ITEMS};
+
+enum CustomColor{CustomCBOn = 0, CustomCBOff, CustomRadioOn, CustomRadioOff,
+ CustomTabOn, CustomTabOff, CustomSBSlider, CustomSBSliderHover, CustomSBSliderPressed, CustomSBGroove};
+
+enum PulseType{PushButton, ComboBox, AppletHandle, Splitter, ToolButton};
+
+enum MenuBackground{Standard=0, Plain, Stipples, Gradient};
+
+enum InactiveButtonColor{Original=0, Background, Active, Custom};
+
+enum myExpanderStyle{Apple=0, MS};
+
+enum progressStyle{mac=0, liquid, baghira};
+
+enum DotlineStyle{Line=0, Dots};
+
+enum Tile{TileTopLeft = 0, TileTop, TileTopRight,
+ TileLeft, TileMiddle, TileRight, TileBtmLeft, TileBtm, TileBtmRight};
+
+enum myPosition{left = 0, center, right, full};
+
+enum tabStyle {TrueTab = 0, Clever, Chooser};
+
+enum Style {Jaguar = 0, Panther, Brushed, Tiger, Milk, NUMSTYLES };
+
+class ButtonTile
+ {
+ public:
+ ButtonTile()
+ {
+ for ( int i = 0;i < 9;++i )
+ pixmaps[ i ] = 0;
+ }
+ ~ButtonTile()
+ {
+ for ( int i = 0;i < 9;++i )
+ if ( pixmaps[ i ] ) delete pixmaps[ i ];
+ }
+ QPixmap* pixmap( Tile pos )
+ {
+ return ( pixmaps[ ( int ) pos ] );
+ }
+ void setPixmap( Tile pos, QPixmap *pix )
+ {
+ pixmaps[ ( int ) pos ] = pix;
+ }
+ protected:
+ QPixmap *pixmaps[ 9 ];
+ };
+
+
+class OptionHandler : public QObject
+{
+ Q_OBJECT
+public:
+ OptionHandler( QObject *parent );
+ void reloadSettings();
+ inline static bool useShadowText()
+ {
+ return ( shadowText );
+ }
+ const QColor& textColor();
+ const QColor& bgColor();
+ const QColor& buttonColor();
+ static int custCols[8];
+
+ inline void reset()
+ {
+ menusProcessed = false;
+ }
+
+ inline static bool glossyMenus()
+ {
+ return glossyMenus_;
+ }
+
+ inline static bool drawMenuStripe()
+ {
+ return (drawMenuStripe_);
+ }
+
+ inline static QColor menuStripeColor()
+ {
+ return menuStripeColor_;
+ }
+
+ inline static QColor textColorHigh()
+ {
+ return fgColorHigh;
+ }
+
+ inline static QColor menuColorHigh()
+ {
+ return colorHigh;
+ }
+
+ inline static bool bevelHighlights()
+ {
+ return (bevelHighlights_);
+ }
+ inline static bool useBgStipple()
+ {
+ return ( bgStipple );
+ }
+ inline static Style style()
+ {
+ return (style_);
+ }
+ inline static int stippleContrast()
+ {
+ return ( contrast );
+ }
+ inline static bool useReverseBtnColor()
+ {
+ return ( reverseBtnColor );
+ }
+ inline static bool useToolButtonFrame()
+ {
+ return ( tbFrame );
+ }
+
+ inline static bool useCustomColors()
+ {
+ return ( customWidgetColor );
+ }
+ inline static const QColor& customColor( int idx )
+ {
+ return ( customColors[ idx ] );
+ }
+
+ inline static bool DrawDotlines()
+ {
+ return ( drawDotlines );
+ }
+ inline static bool squeezeSbSlider()
+ {
+ return ( squeezesbslider );
+ }
+ inline static bool shadowSbSlider()
+ {
+ return (shadowsbslider);
+ }
+ inline static bool drawGroupBoxShadow()
+ {
+ return ( groupboxshadow );
+ }
+ inline static int ShadowDarkness()
+ {
+ return ( shadowDarkness );
+ }
+ inline static int InactiveButtonColorType()
+ {
+ return ( inactiveButtonColor );
+ }
+ inline static int MenuBackground()
+ {
+ return (menuBackground);
+ }
+ inline static int MenuOpacity()
+ {
+ return (menuOpacity);
+ }
+ inline static bool UseCustomMenuColor()
+ {
+ return (useCustomMenuColor);
+ }
+ inline static int DotlineStyle()
+ {
+ return (dotlineStyle);
+ }
+ inline static bool MenuColorButton()
+ {
+ return (menuColorButton);
+ }
+ inline static int ExpanderStyle()
+ {
+ return (expanderStyle);
+ }
+ inline static bool UseCustomExpanderColor()
+ {
+ return (useCustomExpanderColor);
+ }
+ inline static QColor CustomExpanderColor()
+ {
+ return (expanderColor);
+ }
+ inline static QColor DotlineColor()
+ {
+ return (dotlineColor);
+ }
+ inline QColor InactiveButtonColor()
+ {
+ switch (inactiveButtonColor)
+ {
+ case 0 : return (QColor(232,232,232));
+ case 1 : return (bgColor());
+ case 2 : return (buttonColor());
+ case 3 : return (customInactiveButtonColor);
+ }
+ }
+ inline static bool CenterTabs()
+ {
+ return centerTabs;
+ }
+
+ inline static bool SmoothListViewHeaders()
+ {
+ return smoothListViewHeaders;
+ }
+
+ inline static bool SmootherLVH()
+ {
+ return smootherLVH;
+ }
+
+ inline static bool IcyButtons()
+ {
+ return icyButtons;
+ }
+
+ inline static Style buttonStyle()
+ {
+ return _buttonStyle;
+ }
+
+ inline static int ProgressBar()
+ {
+ return progressBar;
+ }
+
+ inline static bool RemoveKickerBevel()
+ {
+ return removeKickerBevel;
+ }
+
+ inline static Style toolbuttonStyle()
+ {
+ return _toolbuttonStyle;
+ }
+
+ inline void setGroupShadowButton()
+ {
+ groupShadowButton = true;
+ }
+ inline void setNotGroupShadowButton()
+ {
+ groupShadowButton = false;
+ }
+ inline bool GroupShadowButton()
+ {
+ return groupShadowButton;
+ }
+
+ inline void setScrollerActive()
+ {
+ scrollerActive = true;
+ }
+
+ inline void setScrollerInactive()
+ {
+ scrollerActive = false;
+ }
+
+ inline bool ScrollerActive()
+ {
+ return scrollerActive;
+ }
+
+ inline static QColor Color()
+ {
+ return color;
+ }
+
+ inline static QColor Color2()
+ {
+ return color2;
+ }
+
+ inline static bool DrawProgressLabel()
+ {
+ return drawProgressLabel;
+ }
+
+ inline static tabStyle TabStyle()
+ {
+ return tabStyle_;
+ }
+
+ inline static QColor & BrushTint()
+ {
+ return brushTint;
+ }
+
+ inline static bool TintBrush()
+ {
+ return tintBrush;
+ }
+
+ inline static bool AnimateSlider()
+ {
+ return animateSlider;
+ }
+ inline static bool AnimateProgress()
+ {
+ return animateProgress;
+ }
+ inline static QColor CustomButtonColor()
+ {
+ return customButtonColor;
+ }
+
+ inline static bool AnimateButton()
+ {
+ return animateButton;
+ }
+
+ inline static QColor aDecoColor1()
+ {
+ return aDecoColor1_;
+ }
+ inline static QColor aDecoColor2()
+ {
+ return aDecoColor2_;
+ }
+ inline static QColor titleColor( int i )
+ {
+ return titleColor_[i];
+ }
+ inline static QColor titleButtonColor( int i )
+ {
+ return titleButtonColor_[i];
+ }
+
+ QMenuBar *currentMenu;
+ QPixmap *indicatedMenuItemPix;
+ QRect *indicatedMenuItemRect;
+ QPixmap *lastIndicatedMenuItemPix;
+ QRect *lastIndicatedMenuItemRect;
+ bool mouseOverMenu;
+ WId lastIndicatedMenuItemID;
+ static unsigned long wmDesign;
+
+
+public slots:
+ inline void warningSlot()
+ {
+ qWarning("widget destroyed");
+ }
+
+protected:
+ static QColor titleColor_[2];
+ static QColor titleButtonColor_[3];
+
+ // menu
+ static int menuBackground;
+ static int menuOpacity;
+ static bool menuColorButton;
+ static bool animateButton;
+ static bool shadowText;
+ static bool drawMenuStripe_;
+ static QColor menuStripeColor_;
+ static bool glossyMenus_;
+ //color
+ static QColor customButtonColor;
+ //widgets
+ static bool customWidgetColor;
+ static QColor customColors[ 10 ];
+ //menu
+ static bool useCustomMenuColor;
+ static QColor color, color2, colorHigh, fgColor, fgColorHigh;
+ //incativeButton
+ static int inactiveButtonColor;
+ static QColor customInactiveButtonColor;
+
+ //Design
+ //stipples
+ static bool bgStipple, bevelHighlights_;
+ static Style style_;
+ static int contrast;
+ //shadows
+ static bool groupboxshadow;
+ static int shadowDarkness;
+ //istviews;
+ static bool drawDotlines, useCustomExpanderColor;
+ static int expanderStyle;
+ static QColor expanderColor, dotlineColor;
+ static int dotlineStyle;
+ //slider
+ static bool squeezesbslider;
+ static bool shadowsbslider;
+ //toolbar
+ static bool reverseBtnColor, tbFrame;
+ //tweaks
+ static bool centerTabs;
+ static bool smoothListViewHeaders;
+ static bool smootherLVH;
+ static bool icyButtons;
+ static Style _buttonStyle;
+ bool menusProcessed;
+ bool scrollerActive;
+ int menuLevelCounter;
+ bool groupShadowButton;
+ static int progressBar;
+ static bool removeKickerBevel;
+ static Style _toolbuttonStyle;
+ static bool drawProgressLabel;
+ static tabStyle tabStyle_;
+
+ QString colorStr, fgColorStr/*, panelColorStr*/;
+ static QColor brushTint;
+ static QColor aDecoColor1_;
+ static QColor aDecoColor2_;
+ static bool tintBrush;
+ static bool animateSlider;
+ static bool animateProgress;
+};
+
+class EventKiller : public QObject
+{
+ Q_OBJECT
+public:
+ bool eventFilter( QObject *, QEvent *)
+ {
+ return TRUE;
+ }
+};
+
+class BMShower : public QObject
+{
+ Q_OBJECT
+public:
+ BMShower(QObject *parent);
+ bool eventFilter( QObject *object, QEvent *event );
+};
+
+class ButtonFadeInfo
+{
+public:
+ ButtonFadeInfo()
+ {
+ timerId=0; index=0; fadeIn=TRUE;
+ }
+public:
+ int timerId;
+ int index;
+ bool fadeIn;
+};
+
+class LiquidStyle : public KStyle
+{
+ Q_OBJECT
+public:
+ friend class OptionHandler;
+ LiquidStyle();
+ virtual ~LiquidStyle();
+ bool isPlain() const;
+
+ virtual void polish( QWidget *w );
+// virtual void polishPopupMenu( QPopupMenu *w );
+ virtual void unPolish( QWidget *w );
+ virtual void polish( QPalette &p );
+ virtual void unPolish( QApplication *a );
+ int styleHint(StyleHint sh, const QWidget * w, const QStyleOption & opt, QStyleHintReturn * shr) const;
+ void drawKStylePrimitive( KStylePrimitive kpe, QPainter* p, const QWidget* widget, const QRect &r, const QColorGroup &cg, SFlags flags = Style_Default, const QStyleOption& = QStyleOption::Default ) const;
+ void drawPrimitive( PrimitiveElement pe, QPainter* p, const QRect &r, const QColorGroup &cg, SFlags flags = Style_Default, const QStyleOption& = QStyleOption::Default ) const;
+ void drawControl( ControlElement element, QPainter *p, const QWidget *widget, const QRect &r, const QColorGroup &cg, SFlags flags = Style_Default, const QStyleOption& = QStyleOption::Default ) const;
+// void drawControlMask( ControlElement element, QPainter *p, const QWidget *widget, const QRect &r, const QStyleOption& = QStyleOption::Default ) const;
+ void drawComplexControl( ComplexControl control, QPainter *p, const QWidget *widget, const QRect &r, const QColorGroup &cg, SFlags flags = Style_Default, SCFlags controls = SC_All, SCFlags active = SC_None, const QStyleOption& = QStyleOption::Default ) const;
+// void drawComplexControlMask( ComplexControl control, QPainter *p, const QWidget *widget, const QRect &r, const QStyleOption& = QStyleOption::Default ) const;
+
+ int pixelMetric( PixelMetric m, const QWidget *widget = 0 ) const;
+
+ QSize sizeFromContents( ContentsType contents, const QWidget *widget, const QSize &contentSize, const QStyleOption& opt ) const;
+ QRect subRect( SubRect r, const QWidget *widget ) const;
+ QRect querySubControlMetrics( ComplexControl control, const QWidget *widget, SubControl subcontrol, const QStyleOption &opt = QStyleOption::Default ) const;
+ // Fix Qt3's wacky image positions
+ QPixmap stylePixmap( StylePixmap stylepixmap, const QWidget *widget = 0, const QStyleOption& = QStyleOption::Default ) const;
+ bool eventFilter( QObject *object, QEvent *event );
+
+private slots:
+ void updateProgressPos();
+ void updateSliderPos();
+ void progressBarDestroyed(QObject*);
+ void fakeMouse();
+
+protected:
+ void clearImage( QImage &img ) const;
+ ButtonTile* createButtonTile( const QColor &c, const QColor &bgColor, QImage *buttonImage, QImage *shadowImage, QImage *glowImage, QIntDict <ButtonTile>*buttonDict, QIntDict<ButtonTile>*shadowDict, QIntDict<ButtonTile>*glowDict, int w, int h, int xOff, int yOff, int centerW, int centerH, int shadowH, int glowWH, bool sunken) const;
+ ButtonTile* createRoundFrameTile(QImage &img, const QColor &color, const QColor *bg, const QColor &baseColor ) const;
+ QPixmap* createSliderEnd( const QColor &c, const QColor &bgColor, bool top/*, bool vertical*/ ) const;
+ ButtonTile* separateTiles( QPixmap *pix, int xO, int yO, int w, int h, int sh, bool sunken) const;
+
+ QPixmap* getPixmap( BitmapData item ) const;
+ QPixmap* adjustHSV( QImage &img, const QColor &c, const QColor *bg = NULL ) const;
+ QImage* adjustHSVImage( QImage &img, const QColor &c, const QColor *bg = NULL ) const;
+ void adjustHSV( QPixmap &pix, const QColor &c ) const;
+ QImage* tintBrush( const QImage &img, const QColor &c ) const;
+ QPixmap* processEmbedded( const char *label, const QColor &c, bool blend = false, const QColor *bg = NULL ) const;
+ void drawRoundButton( QPainter *p, const QColorGroup &cg, const QColor &c, /*const QColor &bg,*/ int x, int y, int w, int h, bool pushedDown = false, bool hover = false, int bgX = -1, int bgY = -1) const;
+ void drawRectangularButton( QPainter *p, const QColorGroup &cg, const QColor &c, int x, int y, int w, int h, bool sunken = false, bool hover = false, bool isCombo = false, int position = full, bool isHtml = false) const;
+ void drawCombo( QPainter *painter, const QColorGroup &cg, const QColor &c, int x, int y, int w, int h, bool sunken, bool hover, bool isCombo, int position = full, bool isHTML = false ) const;
+ void drawEditFrame( QPainter *p, const QRect &r, const QColorGroup &cg, bool isHTML = false, bool focused = false, bool inverse = false/*, bool round = false*/ ) const;
+ void drawRoundFrame( QPainter *p, const QRect &r, const QColorGroup &cg, bool focused, QPoint offset ) const;
+ void drawHTMLCBBorder( const QPixmap &pix, const QColor &c ) const;
+ bool isHTMLWidget( const QWidget *w ) const;
+
+
+private:
+ LiquidStyle( const LiquidStyle & );
+ LiquidStyle& operator=( const LiquidStyle & );
+ int getBrightness(unsigned int rgb) const;
+ QImage fetchImage( const char *name );
+ QColor mapFadeColor(QColor &color, int index) const;
+ void fadeIn(QPushButton *button);
+ void fadeOut(QPushButton *button);
+ QColor brushedMetalColor(QColor &c) const;
+ QColor originalBgColor;
+
+
+ QBitmap *sbLeft, *sbRight, *sbUp, *sbDown, *checkmark;
+ QImage *btnBorderImg, *btnShadowImg, *slider_top, *slider_btm, *slider_top_shd, *slider_btm_shd, *rectbutton, *combo, *comboShadow, *buttonGlow, *roundFrame;
+ QPixmap *btnBlendPix, *menuPix, *groupShadow ;
+ QPixmap plainBrush, gradBrush;
+ QBrush pagerBrush, pagerHoverBrush;
+
+ QPixmap *pixmaps[ BITMAP_ITEMS ];
+ QPixmap sbBuffer;
+ QScrollBar *currentScrollBar;
+ QWMatrix lMatrix;
+ QWMatrix rMatrix;
+ QWMatrix iMatrix;
+ QWMatrix mMatrix;
+ QWMatrix m2Matrix;
+
+ bool isKicker, isOOO, isHTMLButton, initialPaletteLoaded, inExitPolish;
+
+ QHeader *currentHeader;
+ QTabBar *currentTabBar;
+ int headerHoverID;
+ int headerSortID;
+ QPoint btnOffset;
+ QPoint cursorPos_;
+ QWidget *currentTaskContainer;
+ KPixmap activeToolbarPix;
+ bool isTaskContainer, taskContainerHover;
+
+ QPalette polishedPalette, tooltipPalette;
+ unsigned int qtrcModificationTime;
+
+ int progAnimShift;
+ int prog2AnimShift;
+ int sliderAnimShift;
+ int hoveredTabIndex;
+ bool mouseButtonPressed_;
+
+ OptionHandler *optionHandler;
+
+ QIntDict<ButtonTile>btnDict;
+ QIntDict<ButtonFadeInfo>bfi;
+ QIntDict<QRgb*>fadeColorMap;
+ QIntDict<ButtonTile>btnShadowedDict;
+ QIntDict<ButtonTile>buttonGlowDict;
+ QIntDict<ButtonTile>comboDict;
+ QIntDict<ButtonTile>comboShadowedDict;
+ QIntDict<ButtonTile>tabDict;
+ QIntDict<ButtonTile>inverseTabDict;
+ QIntDict<ButtonTile>rectBtnDict;
+ QIntDict<ButtonTile>progress2Dict;
+ QMap<QWidget*, int> progAnimWidgets;
+
+ QPixmap *tmpBtnPix;
+ ButtonTile *inactiveRoundFrame;
+ ButtonTile *activeRoundFrame;
+
+ QWidget *highlightWidget;
+ QScrollBar *activeScroller;
+ EventKiller *eventKiller;
+ BMShower *bmShower;
+ static QPixmap popupBack;
+ QWidget *paintWidget;
+};
+
+#endif
diff --git a/style/baghira.themerc b/style/baghira.themerc
new file mode 100644
index 0000000..d6bfd1f
--- /dev/null
+++ b/style/baghira.themerc
@@ -0,0 +1,6 @@
+[Misc]
+Name=Baghira
+Comment=The Big Black Cat
+ConfigPage=kstyle_baghira_config
+[KDE]
+WidgetStyle=Baghira
diff --git a/style/bitmaps.h b/style/bitmaps.h
new file mode 100644
index 0000000..a4fafc4
--- /dev/null
+++ b/style/bitmaps.h
@@ -0,0 +1,21 @@
+#ifndef __BITMAPS_H
+#define __BITMAPS_H
+
+static unsigned char sbarrow_down_bits[] = {
+// 0x00, 0x00, 0x7f, 0x7f, 0x3e, 0x1c, 0x08};
+ 0x7f, 0x3e, 0x3e, 0x1c, 0x1c, 0x08 };
+static unsigned char sbarrow_left_bits[] = {
+// 0x18, 0x1c, 0x1e, 0x1f, 0x1e, 0x1c, 0x18};
+ 0x20, 0x38, 0x3e, 0x3f, 0x3e, 0x38, 0x20 };
+static unsigned char sbarrow_right_bits[] = {
+// 0x0c, 0x1c, 0x3c, 0x7c, 0x3c, 0x1c, 0x0c};
+ 0x01, 0x07, 0x1f, 0x3f, 0x1f, 0x07, 0x01 };
+static unsigned char sbarrow_up_bits[] = {
+// 0x08, 0x1c, 0x3e, 0x7f, 0x7f, 0x00, 0x00};
+ 0x08, 0x1c, 0x1c, 0x3e, 0x3e, 0x7f };
+static unsigned char checkmark_bits[] = {
+ 0x40, 0x60, 0x71, 0x3b, 0x1f, 0x0e, 0x04 };
+
+#endif
+
+
diff --git a/style/configure.in.in b/style/configure.in.in
new file mode 100644
index 0000000..b0f4a88
--- /dev/null
+++ b/style/configure.in.in
@@ -0,0 +1,5 @@
+compile_kompmgr=yes
+KDE_CHECK_HEADERS(X11/extensions/Xdamage.h,,compile_kompmgr=no,[#include <X11/Xlib.h>])
+KDE_CHECK_HEADERS(X11/extensions/Xcomposite.h,,compile_kompmgr=no,[#include <X11/Xlib.h>])
+KDE_CHECK_HEADERS(X11/extensions/Xrender.h,,compile_kompmgr=no,[#include <X11/Xlib.h>])
+AM_CONDITIONAL(include_kompmgr, test "$compile_kompmgr" = "yes" )
diff --git a/style/eventfilter.cpp b/style/eventfilter.cpp
new file mode 100644
index 0000000..ada0475
--- /dev/null
+++ b/style/eventfilter.cpp
@@ -0,0 +1,990 @@
+#include <qcursor.h>
+#include <kpixmapeffect.h>
+#include <X11/keysym.h>
+#include <X11/extensions/XTest.h>
+#include <fixx11h.h>
+
+bool LiquidStyle::eventFilter( QObject *obj, QEvent *ev )
+{
+// qWarning("%s, %s <- %s, %s: %d", obj->className(), obj->name(), obj->parent() ? obj->parent()->className() : "none", obj->parent()?obj->parent()->name():"none",ev->type());
+ switch (ev->type())
+ {
+ case QEvent::None:
+ case QEvent::Timer:
+ {
+ // first check if this is one of our fading pushbuttons - return elsewise
+ if (!(optionHandler->AnimateButton() && ::qt_cast<QPushButton*>(obj)))
+ return false;
+ ButtonFadeInfo *bfi_ = bfi[((QPushButton*)obj)->winId()];
+ if (!bfi_ || ((QTimerEvent*)ev)->timerId() != bfi_->timerId)
+ return false;
+ // ok, this is one of our fading buttons asking for repaint
+ ((QPushButton*)obj)->repaint(false);
+ int index = bfi_->fadeIn?bfi_->index + 1:bfi_->index - 1;
+ // handle border cases
+ if (index < 0) // fade-out run has finished, either stop fading stuff, or start fade-in
+ {
+ bfi_->fadeIn=true;
+ if (((QPushButton*)obj)->isDefault())
+ {
+ bfi_->index=0;
+ }
+ else
+ {
+ obj->killTimer(bfi_->timerId);
+ // qWarning("%u: stopped (%d)", ((QPushButton*)obj)->winId(), bfi_->timerId);
+ bfi_->timerId=0;
+ ((QPushButton*)obj)->repaint(false); // must be to clean out button
+ }
+ }
+ else if (index > 9) // fade-in run has finished, either stop fading stuff, or start fade-out
+ {
+ if (((QPushButton*)obj)->isDefault())
+ {
+ bfi_->fadeIn=false;
+ bfi_->index=9;
+ }
+ else
+ {
+ obj->killTimer(bfi_->timerId);
+ // qWarning("%u: stopped (%d)", ((QPushButton*)obj)->winId(), bfi_->timerId);
+ bfi_->timerId=0;
+ }
+ }
+ else
+ bfi_->index = index;
+ }
+ case QEvent::MouseMove:
+ if (::qt_cast<QTabBar*>(obj))
+ {
+ QTabBar *tb = (QTabBar*)obj;
+ QRect tmpRect;
+ bool done = false;
+ QMouseEvent *me = ( QMouseEvent*)ev;
+ int oldTab = hoveredTabIndex;
+ if (hoveredTabIndex == -1)
+ {
+ for (int i = 0; i < tb->count(); i++)
+ {
+ if (tb->tabAt(i))
+ {
+ tmpRect = tb->tabAt(i)->rect();
+ if ( tmpRect.x() < me->x() && me->x() < tmpRect.right())
+ {
+ hoveredTabIndex = i;
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ if ((oldTab > 0) && tb->tabAt(oldTab-1))
+ {
+ tmpRect = tb->tabAt(oldTab-1)->rect();
+ if ((tmpRect.x() < me->x()) && (me->x() < tmpRect.right()))
+ {
+ hoveredTabIndex = oldTab-1;
+ done = true;
+ }
+ }
+ if (!done && (oldTab < tb->count()-1) && tb->tabAt(oldTab+1))
+ {
+ tmpRect = tb->tabAt(oldTab+1)->rect();
+ if ((tmpRect.x() < me->x()) && (me->x() < tmpRect.right()))
+ {
+ hoveredTabIndex = oldTab+1;
+ }
+ }
+ }
+ if ( oldTab != hoveredTabIndex )
+ {
+ // reset old tab
+ if ( oldTab != -1 )
+ if (tb->tabAt(oldTab)) tb->repaint( tb->tabAt(oldTab)->rect(), false );
+ if ( hoveredTabIndex != -1 )
+ tb->repaint( tmpRect, false );
+ }
+ return false;
+ }
+ else if ( ::qt_cast<QHeader*>(obj) )
+ {
+ QHeader *hw = (QHeader*)obj;
+ QMouseEvent * me = ( QMouseEvent * ) ev;
+ int oldHeader = headerHoverID;
+ headerHoverID = hw->orientation() == Qt::Horizontal ? hw->sectionAt( me->x() + hw->offset() ) : hw->sectionAt( me->y() + hw->offset() );
+ if ( oldHeader != headerHoverID )
+ {
+ // reset old header
+ if ( oldHeader != -1 )
+ hw->repaint(hw->sectionRect ( oldHeader ), false);
+// hw->repaint( hw->sectionPos( oldHeader )-hw->offset(), 0, hw->sectionSize( oldHeader ), hw->height(), false );
+ if ( headerHoverID != -1 )
+ hw->repaint(hw->sectionRect ( headerHoverID ), false);
+// hw->repaint( hw->sectionPos( headerHoverID )-hw->offset(), 0, hw->sectionSize( headerHoverID ), hw->height(), false );
+ }
+ return false;
+ }
+ return false;
+ case QEvent::Paint:
+ if ( ::qt_cast<QToolButton*>(obj) )
+ {
+ QToolButton * btn = ( QToolButton * ) obj;
+ if (!obj->inherits( "TaskContainer" ))
+ {
+ if (btn->backgroundOrigin() != QWidget::WindowOrigin)
+ btn->setBackgroundOrigin( QWidget::WindowOrigin );
+ }
+ else
+ {
+ isTaskContainer = true;
+ if ( currentTaskContainer == btn )
+ taskContainerHover = true;
+ else
+ taskContainerHover = false;
+ }
+ return false;
+ }
+ else if (::qt_cast<QMenuBar*>(obj))
+ {
+ QWidget *w = (QWidget *)obj;
+ if(w->backgroundMode() != Qt::PaletteBackground)
+ {
+ w->setBackgroundMode(PaletteBackground);
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ }
+ return false;
+ }
+ else if ( ::qt_cast<QHeader*>(obj) )
+ {
+ QHeader *hw = (QHeader*)obj;
+ if (hw->parentWidget() && ::qt_cast<QListView*>(hw->parentWidget()))
+ headerSortID = ((QListView*)hw->parentWidget())->sortColumn();
+ return false;
+ }
+ else if ( obj->inherits( "QDockWindow" ) )
+ {
+ if (KStyle::eventFilter( obj, ev ))
+ return true;
+ QWidget * w = ( QWidget * ) obj;
+ if ( w->backgroundMode() != Qt::PaletteBackground )
+ {
+ w->setBackgroundMode( Qt::PaletteBackground );
+ w->setBackgroundOrigin( QWidget::WindowOrigin );
+ }
+ return false;
+ }
+ else if ( obj->inherits( "QRadioButton" ) || obj->inherits( "QCheckBox" ) )
+ {
+ QButton * btn = ( QButton * ) obj;
+ bool isStatusChild = btn->parent() && ( btn->parent() ->inherits( "QStatusBar" ) || btn->parent() ->inherits( "KonqFrameStatusBar" ) );
+ bool isRadio = obj->inherits( "QRadioButton" );
+ btn->erase();
+ QPainter p;
+ p.begin( btn );
+ QFontMetrics fm = btn->fontMetrics();
+ QSize lsz = fm.size( ShowPrefix, btn->text() );
+ QSize sz = isRadio ?
+ QSize( pixelMetric( PM_ExclusiveIndicatorWidth ), pixelMetric( PM_ExclusiveIndicatorHeight ) ) :
+ QSize( pixelMetric( PM_IndicatorWidth ), pixelMetric( PM_IndicatorHeight ) );
+ int x = 0;
+ int y = isStatusChild ? 0 : ( btn->height() - lsz.height() + fm.height() - sz.height() ) / 2;
+ SFlags flags = Style_Default;
+ if ( btn->isEnabled() )
+ flags |= Style_Enabled;
+ if ( btn->hasFocus() )
+ flags |= Style_HasFocus;
+ if ( btn->isDown() )
+ flags |= Style_Down;
+ if ( highlightWidget == btn )
+ flags |= Style_MouseOver;
+ if ( btn->state() == QButton::On )
+ flags |= Style_On;
+ else if ( btn->state() == QButton::Off )
+ flags |= Style_Off;
+ if ( isRadio )
+ drawControl( CE_RadioButton, &p, btn, QRect( x, y, sz.width(), sz.height() ), btn->colorGroup(), flags );
+ else
+ drawControl( CE_CheckBox, &p, btn, QRect( x, y, sz.width(), sz.height() ), btn->colorGroup(), flags );
+ x = sz.width() + 6;
+ y = 0;
+ if ( btn->hasFocus() )
+ {
+ QColor tmp( btn->colorGroup().background().dark( 130 ) );
+ drawItem( &p, QRect( sz.width() + 6 + 2, 1, btn->width() - ( sz.width() + 6 + 1 ), btn->height() ), AlignLeft | AlignVCenter | ShowPrefix, btn->colorGroup(), btn->isEnabled(), btn->pixmap(), btn->text(), -1, &tmp );
+ drawItem( &p, QRect( sz.width() + 6 + 3, 2, btn->width() - ( sz.width() + 6 + 1 ), btn->height() ), AlignLeft | AlignVCenter | ShowPrefix, btn->colorGroup(), btn->isEnabled(), btn->pixmap(), btn->text(), -1, &tmp );
+ }
+ drawItem( &p, QRect( sz.width() + 6 + 1, 0, btn->width() - ( sz.width() + 6 + 1 ), btn->height() ), AlignLeft | AlignVCenter | ShowPrefix, btn->colorGroup(), btn->isEnabled(), btn->pixmap(), btn->text() );
+ p.end();
+ return true;
+ }
+ else if (obj->inherits("KColorGrid") && !(((QWidget*)obj)->width() && ((QWidget*)obj)->height()))
+ return true;
+ return false;
+ case QEvent::KeyPress:
+ case QEvent::KeyRelease:
+ return false;
+ case QEvent::Wheel:
+ if ( ::qt_cast<QScrollView*>(obj) )
+ {
+ optionHandler->setScrollerActive();
+ return false;
+ }
+ return false;
+ case QEvent::Enter:
+ if ( ::qt_cast<QToolButton*>(obj) )
+ {
+ bool isTask = obj->inherits( "TaskContainer" );
+ QToolButton * btn = ( QToolButton * ) obj;
+ if (isTask)
+ {
+ currentTaskContainer = btn;
+ btn->repaint( false );
+ return false;
+ }
+ else if ( btn->isEnabled() )
+ {
+ highlightWidget = btn;
+ btn->repaint( false );
+ return false;
+ }
+ }
+ else if ( ::qt_cast<QPushButton*>(obj) || ::qt_cast<QComboBox*>(obj) || obj->inherits( "QSplitterHandle" ) || obj->inherits( "AppletHandleDrag" ) )
+ {
+ QWidget * btn = ( QWidget * ) obj;
+ if ( btn->isEnabled() )
+ {
+ highlightWidget = btn;
+ btn->repaint( false );
+ if (optionHandler->AnimateButton() && ::qt_cast<QPushButton*>(obj))
+ fadeIn((QPushButton*)obj);
+ }
+ return false;
+ }
+ else if (::qt_cast<KToolBar*>(obj))
+ {
+ QObjectList *handlerList = obj->queryList( "QDockWindowHandle" );
+ for (uint i= 0; i < handlerList->count(); i++)
+ ((QWidget*)(handlerList->at(i)))->repaint(false);
+ return false;
+ }
+ if ( ::qt_cast<QScrollBar*>(obj) )
+ {
+ QScrollBar * sb = ( QScrollBar * ) obj;
+ if ( !sb->draggingSlider() )
+ {
+ if ( sb->isEnabled() )
+ {
+ activeScroller = sb;
+ highlightWidget = sb;
+ sb->repaint( false );
+ }
+ }
+ return false;
+ }
+ else if ( ::qt_cast<QScrollView*>(obj) )
+ {
+ QScrollView *sv = ( QScrollView * ) obj;
+ if (sv->vScrollBarMode() == QScrollView::AlwaysOff && sv->hScrollBarMode() == QScrollView::AlwaysOff)
+ return false;
+ optionHandler->setScrollerActive();
+ if (!(highlightWidget == sv->verticalScrollBar()))
+ sv->verticalScrollBar()->repaint(false);
+ if (!(highlightWidget == sv->horizontalScrollBar()))
+ sv->horizontalScrollBar()->repaint(false);
+ return false;
+ }
+ else if ( ::qt_cast<QHeader*>(obj) )
+ {
+ currentHeader = (QHeader*)obj;
+ headerHoverID = -1;
+ return false;
+ }
+ else if (::qt_cast<QTabBar*>(obj))
+ {
+ currentTabBar = (QTabBar*)obj;
+ hoveredTabIndex = -1;
+ return false;
+ }
+ else if ( obj->inherits( "KateView" ) || obj->inherits( "TEWidget") || obj->inherits("CHexViewWidget"))
+ {
+ QObjectList *scrollerList = obj->queryList( "QScrollBar" );
+ optionHandler->setScrollerActive();
+ for (uint i= 0; i < scrollerList->count(); i++)
+ ((QWidget*)(scrollerList->at(i)))->repaint(false);
+ return false;
+ }
+ else if (obj->inherits("KDockWidgetAbstractHeaderDrag"))
+ {
+ ((QWidget *)obj)->repaint();
+ return false;
+ }
+ else if (obj->inherits( "KAnimWidget" ))
+ {
+ return true;
+ }
+ else if ( obj->inherits( "QLineEdit" ) && obj->parent() && ::qt_cast<QComboBox*>(obj->parent()))
+ {
+ QWidget * btn = ( QWidget * ) obj->parent();
+ if ( btn->isEnabled() )
+ {
+ highlightWidget = btn;
+ btn->repaint( false );
+ }
+ return false;
+ }
+ else if ( obj->inherits( "QRadioButton" ) || obj->inherits( "QCheckBox" ) )
+ {
+ QButton * btn = ( QButton * ) obj;
+ if (btn->isEnabled())
+ {
+ bool isStatusChild = btn->parent() && ( btn->parent() ->inherits( "QStatusBar" ) || btn->parent() ->inherits( "KonqFrameStatusBar" ) );
+ bool isRadio = obj->inherits( "QRadioButton" );
+ highlightWidget = btn;
+ QFontMetrics fm = btn->fontMetrics();
+ QSize lsz = fm.size( ShowPrefix, btn->text() );
+ QSize sz = isRadio ?
+ QSize( pixelMetric( PM_ExclusiveIndicatorWidth ), pixelMetric( PM_ExclusiveIndicatorHeight ) ) :
+ QSize( pixelMetric( PM_IndicatorWidth ), pixelMetric( PM_IndicatorHeight ) );
+ int x = 0;
+ int y = isStatusChild ? 0 : ( btn->height() - lsz.height() + fm.height() - sz.height() ) / 2;
+ QPainter p;
+ p.begin( btn );
+ SFlags flags = Style_Default;
+ if ( btn->isEnabled() )
+ flags |= Style_Enabled;
+ if ( btn->hasFocus() )
+ flags |= Style_HasFocus;
+ if ( btn->isDown() )
+ flags |= Style_Down;
+ if ( highlightWidget == btn )
+ flags |= Style_MouseOver;
+ if ( btn->state() == QButton::On )
+ flags |= Style_On;
+ else if ( btn->state() == QButton::Off )
+ flags |= Style_Off;
+ if ( isRadio )
+ drawControl( CE_RadioButton, &p, btn, QRect( x, y, sz.width(), sz.height() ), btn->colorGroup(), flags );
+ else
+ drawControl( CE_CheckBox, &p, btn, QRect( x, y, sz.width(), sz.height() ), btn->colorGroup(), flags );
+ p.end();
+ }
+ return false;
+ }
+ return false;
+ case QEvent::Leave:
+ if ( ::qt_cast<QToolButton*>(obj) )
+ {
+ QToolButton * btn = ( QToolButton * ) obj;
+ if (obj->inherits( "TaskContainer" ))
+ {
+ currentTaskContainer = NULL;
+ btn->repaint( false );
+ return false;
+ }
+ else if ( btn == highlightWidget )
+ {
+ highlightWidget = NULL;
+ btn->repaint( false );
+ return false;
+ }
+ }
+ else if ( ::qt_cast<QPushButton*>(obj) || ::qt_cast<QComboBox*>(obj) || obj->inherits( "QSplitterHandle" ) || obj->inherits( "AppletHandleDrag" ) )
+ {
+ QWidget * btn = ( QWidget * ) obj;
+ if ( btn == highlightWidget )
+ {
+ highlightWidget = NULL;
+ if (optionHandler->AnimateButton() && ::qt_cast<QPushButton*>(obj))
+ fadeOut((QPushButton*)obj);
+ else
+ btn->repaint( false );
+ }
+ return false;
+ }
+ else if (::qt_cast<KToolBar*>(obj))
+ {
+ QObjectList *handlerList = obj->queryList( "QDockWindowHandle" );
+ for (uint i= 0; i < handlerList->count(); i++)
+ ((QWidget*)(handlerList->at(i)))->repaint(false);
+ return false;
+ }
+ if ( ::qt_cast<QScrollBar*>(obj) )
+ {
+ QScrollBar * sb = ( QScrollBar * ) obj;
+ if ( sb == highlightWidget && !sb->draggingSlider() )
+ {
+ activeScroller = NULL;
+ highlightWidget = NULL;
+ sb->repaint( false );
+ }
+ return false;
+ }
+ else if ( ::qt_cast<QScrollView*>(obj) )
+ {
+ QScrollView *sv = (QScrollView*)obj;
+// if (sv->clipRegion().boundingRect().contains(sv->mapFromGlobal(QCursor::pos())))
+// return false; // mouse is still in the scrollview
+ if (sv->vScrollBarMode() == QScrollView::AlwaysOff && sv->hScrollBarMode() == QScrollView::AlwaysOff)
+ return false; // no sliders available - don't mess up things
+ optionHandler->setScrollerInactive();
+ if (!(highlightWidget == sv->verticalScrollBar()))
+ sv->verticalScrollBar()->repaint(false);
+ if (!(highlightWidget == sv->horizontalScrollBar()))
+ sv->horizontalScrollBar()->repaint(false);
+ return false;
+ }
+ else if ( ::qt_cast<QHeader*>(obj) )
+ {
+ QHeader *hw = (QHeader*)obj;
+ currentHeader = NULL;
+ if ( headerHoverID != -1 )
+ hw->repaint( hw->sectionPos( headerHoverID )-hw->offset(), 0, hw->sectionSize( headerHoverID ), hw->height(), false );
+ headerHoverID = -1;
+ return false;
+ }
+ else if (::qt_cast<QTabBar*>(obj))
+ {
+ QTabBar *tb = (QTabBar*)obj;
+ currentTabBar = NULL;
+ if ( hoveredTabIndex != -1 )
+ {
+ QTab *tmpTab = tb->tabAt(hoveredTabIndex);
+ if (tmpTab) tb->repaint( tmpTab->rect(), false );
+ }
+ hoveredTabIndex = -1;
+ return false;
+ }
+ else if ( obj->inherits( "KateView" ) || obj->inherits( "TEWidget") || obj->inherits("CHexViewWidget"))
+ {
+ QObjectList *scrollerList = obj->queryList( "QScrollBar" );
+ optionHandler->setScrollerInactive();
+ for (uint i= 0; i < scrollerList->count(); i++)
+ ((QWidget*)(scrollerList->at(i)))->repaint(false);
+ return false;
+ }
+ else if (obj->inherits("KDockWidgetAbstractHeaderDrag"))
+ {
+ ((QWidget *)obj)->repaint();
+ return false;
+ }
+ else if (obj->inherits( "KAnimWidget" )){
+ return true;
+ }
+ else if ( obj->inherits( "QLineEdit" ) && obj->parent() && ::qt_cast<QComboBox*>(obj->parent())) {
+ QWidget *btn = (QWidget*)obj->parent();
+ if ( btn == highlightWidget )
+ highlightWidget = NULL;
+ btn->repaint( false );
+ return false;
+ }
+ else if ( obj->inherits( "QRadioButton" ) || obj->inherits( "QCheckBox" ) )
+ {
+ QButton * btn = ( QButton * ) obj;
+ if (btn == highlightWidget)
+ {
+ bool isRadio = obj->inherits( "QRadioButton" );
+ bool isStatusChild = btn->parent() && ( btn->parent() ->inherits( "QStatusBar" ) || btn->parent() ->inherits( "KonqFrameStatusBar" ) );
+ highlightWidget = NULL;
+ QFontMetrics fm = btn->fontMetrics();
+ QSize lsz = fm.size( ShowPrefix, btn->text() );
+ QSize sz = isRadio ?
+ QSize( pixelMetric( PM_ExclusiveIndicatorWidth ), pixelMetric( PM_ExclusiveIndicatorHeight ) ) :
+ QSize( pixelMetric( PM_IndicatorWidth ), pixelMetric( PM_IndicatorHeight ) );
+ int x = 0;
+ int y = isStatusChild ? 0 : ( btn->height() - lsz.height() + fm.height() - sz.height() ) / 2;
+ QPainter p;
+ p.begin( btn );
+ SFlags flags = Style_Default;
+ if ( btn->isEnabled() )
+ flags |= Style_Enabled;
+ if ( btn->hasFocus() )
+ flags |= Style_HasFocus;
+ if ( btn->isDown() )
+ flags |= Style_Down;
+ if ( highlightWidget == btn )
+ flags |= Style_MouseOver;
+ if ( btn->state() == QButton::On )
+ flags |= Style_On;
+ else if ( btn->state() == QButton::Off )
+ flags |= Style_Off;
+ if ( isRadio )
+ drawControl( CE_RadioButton, &p, btn, QRect( x, y, sz.width(), sz.height() ), btn->colorGroup(), flags );
+ else
+ drawControl( CE_CheckBox, &p, btn, QRect( x, y, sz.width(), sz.height() ), btn->colorGroup(), flags );
+ p.end();
+ }
+ return false;
+ }
+ return false;
+ case QEvent::MouseButtonPress:
+// qWarning("class: %s, name: %s",obj->className(), obj->name());
+ if ( optionHandler->style() > Panther && ::qt_cast<QToolBar*>(obj))
+ {
+ QMouseEvent *mev = (QMouseEvent *) ev;
+ if (mev->button() != Qt::LeftButton)
+ return false;
+ mouseButtonPressed_ = true;
+ cursorPos_ = mev->globalPos();
+ QTimer::singleShot(50,this,SLOT(fakeMouse()));
+ return true; // fire this event
+ }
+ if ( ::qt_cast<QScrollBar*>(obj) && ((QMouseEvent*)ev)->button() != Qt::RightButton)
+ {
+ QScrollBar * sb = ( QScrollBar * ) obj;
+ activeScroller = NULL;
+ sb->repaint( false );
+ return false;
+ }
+ else if (obj->inherits( "KAnimWidget" ))
+ {
+ ((QFrame *)obj)->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
+ return false;
+ }
+ return false;
+ case QEvent::MouseButtonRelease:
+ if ( mouseButtonPressed_ )
+ {
+ mouseButtonPressed_= false;
+ }
+ if ( ::qt_cast<QScrollBar*>(obj) )
+ {
+ QScrollBar * sb = ( QScrollBar * ) obj;
+ QMouseEvent * me = ( QMouseEvent * ) ev;
+ if ( sb == highlightWidget)
+ {
+ if ( sb->rect().contains( me->pos() ) )
+ {
+ activeScroller = sb;
+ sb->repaint( false );
+ }
+ else
+ {
+ // this assumes, scrollers are right/bottom to scrollview
+ if ( ((sb->orientation() == Vertical) && (me->pos().x() < 0)) || ((sb->orientation() == Horizontal) && (me->pos().y() < 0)) )
+ {
+ optionHandler->setScrollerActive();
+ sb->repaint( false );
+ }
+ }
+ }
+ return false;
+ }
+ else if ( ::qt_cast<QHeader*>(obj) && obj->parent() && ::qt_cast<QListView*>(obj->parent()))
+ {
+ QMouseEvent * me = ( QMouseEvent * ) ev;
+ headerSortID = ((QHeader*)obj)->sectionAt( me->x() + ((QHeader*)obj)->offset());
+ return false;
+ }
+ else if (obj->inherits( "KAnimWidget" )){
+ ((QFrame *)obj)->setFrameShape(QFrame::NoFrame);
+ return false;
+ }
+ return false;
+ case QEvent::FocusIn:
+ if (optionHandler->AnimateButton() && ::qt_cast<QPushButton*>(obj))
+ {
+ fadeIn((QPushButton*)obj);
+ return false;
+ }
+ if ( obj->inherits( "QLineEdit" ) )
+ {
+ QObject *daddy = obj->parent();
+ if ( daddy && daddy->inherits( "QSpinWidget" ))
+ ((QWidget*)daddy)->repaint(false);
+ else
+ ((QWidget*)obj)->repaint(false);
+ return false;
+ }
+ return false;
+ case QEvent::FocusOut:
+ if (optionHandler->AnimateButton() && ::qt_cast<QPushButton*>(obj))
+ {
+ fadeOut((QPushButton*)obj);
+ return false;
+ }
+ if ( obj->inherits( "QLineEdit" ) )
+ {
+ if ( obj->parent() && obj->parent()->inherits( "QSpinWidget" ))
+ ((QWidget*)obj->parent())->repaint(false);
+ else
+ ((QWidget*)obj)->repaint(false);
+ return false;
+ }
+ return false;
+ case QEvent::Move:
+ if ( !(::qt_cast<QToolBar*>(obj) || obj->inherits( "KActiveLabel" )))
+ return false;
+ case QEvent::Show:
+ if (optionHandler->style() == Tiger && ::qt_cast<QToolBar*>(obj))
+ {
+ QToolBar *tb = (QToolBar*)obj;
+ QPoint pt = tb->mapTo(tb->topLevelWidget(), QPoint(0,0));
+ if (pt.y() == 0)
+ {
+ activeToolbarPix = QPixmap(32,tb->height());
+ KPixmapEffect::gradient(activeToolbarPix, optionHandler->aDecoColor1(), optionHandler->aDecoColor2(), KPixmapEffect::VerticalGradient, 0);
+ QPainter painter(&activeToolbarPix);
+ painter.setPen( optionHandler->aDecoColor2().dark(130) );
+ painter.drawLine ( 0, tb->height()-1, 31, tb->height()-1 );
+ painter.end();
+ tb->installEventFilter(eventKiller);
+ if (tb->isActiveWindow())
+ {
+ tb->setPaletteBackgroundColor(optionHandler->aDecoColor2());
+ tb->setPaletteBackgroundPixmap(activeToolbarPix);
+ }
+ else
+ {
+ QPalette pal( tb->palette() );
+ pal.setColor( QColorGroup::Background, qApp->palette().color(QPalette::Active, QColorGroup::Background) );
+ pal.setBrush ( QColorGroup::Background, qApp->palette().brush(QPalette::Active, QColorGroup::Background) );
+ tb->setPalette( pal );
+ }
+ tb->removeEventFilter(eventKiller);
+ }
+ else
+ {
+ QPalette pal( tb->palette() );
+ pal.setBrush ( QColorGroup::Background, qApp->palette().brush(QPalette::Active, QColorGroup::Background) );
+ tb->installEventFilter(eventKiller);
+ tb->setPalette( pal );
+ tb->removeEventFilter(eventKiller);
+ }
+ }
+ if (optionHandler->AnimateButton() && ::qt_cast<QPushButton*>(obj))
+ {
+ ButtonFadeInfo *bfi_ = bfi[((QPushButton*)obj)->winId()];
+ if (bfi_)
+ return false;
+ bfi_ = new ButtonFadeInfo();
+ bfi.insert(((QPushButton*)obj)->winId(),bfi_);
+ if (((QPushButton*)obj)->isDefault())
+ fadeIn((QPushButton*)obj);
+ return false;
+ }
+ if (::qt_cast<QProgressBar*>(obj))
+ {
+ progAnimWidgets[(QWidget*)obj] = 0;
+ return false;
+ }
+ if ( !qstrcmp(obj->name(), "kde toolbar widget") )
+ {
+ QWidget* lb = static_cast<QWidget*>(obj);
+ if (lb->backgroundMode() == Qt::PaletteButton)
+ lb->setBackgroundMode(Qt::PaletteBackground);
+ lb->removeEventFilter(this);
+ return false;
+ }
+ else if ( !obj->inherits( "KActiveLabel" ))
+ return false;
+ case QEvent::Resize:{
+ QResizeEvent* rev = (QResizeEvent*) ev;
+ if (::qt_cast<QPopupMenu*>(obj) && optionHandler->MenuBackground() == Gradient)
+ {
+ KPixmap tmpPix = QPixmap(rev->size().width(),32);
+ ((QWidget *)obj)->setPaletteBackgroundPixmap(KPixmapEffect::unbalancedGradient(tmpPix, optionHandler->Color(), optionHandler->Color2(), KPixmapEffect::HorizontalGradient, 100, 100));
+ }
+ else if (optionHandler->style() == Tiger && ::qt_cast<QToolBar*>(obj) && rev->size().height() != rev->oldSize().height())
+ {
+ QToolBar *tb = (QToolBar*)obj;
+ QPoint pt = tb->mapTo(tb->topLevelWidget(), QPoint(0,0));
+ if (pt.y() == 0)
+ {
+ activeToolbarPix = QPixmap(32,rev->size().height());
+ KPixmapEffect::gradient(activeToolbarPix, optionHandler->aDecoColor1(), optionHandler->aDecoColor2(), KPixmapEffect::VerticalGradient, 0);
+ QPainter painter(&activeToolbarPix);
+ painter.setPen( optionHandler->aDecoColor2().dark(130) );
+ painter.drawLine ( 0, rev->size().height()-1, 31, rev->size().height()-1 );
+ painter.end();
+ tb->installEventFilter(eventKiller);
+ if (tb->isActiveWindow())
+ {
+ tb->setPaletteBackgroundColor(optionHandler->aDecoColor2());
+ tb->setPaletteBackgroundPixmap(activeToolbarPix);
+ }
+ else
+ {
+ QPalette pal( tb->palette() );
+ pal.setColor( QColorGroup::Background, qApp->palette().color(QPalette::Active, QColorGroup::Background) );
+ pal.setBrush ( QColorGroup::Background, qApp->palette().brush(QPalette::Active, QColorGroup::Background) );
+ tb->setPalette( pal );
+ }
+ tb->removeEventFilter(eventKiller);
+ }
+ else
+ {
+ QPalette pal( tb->palette() );
+ pal.setBrush ( QColorGroup::Background, qApp->palette().brush(QPalette::Active, QColorGroup::Background) );
+ tb->installEventFilter(eventKiller);
+ tb->setPalette( pal );
+ tb->removeEventFilter(eventKiller);
+ }
+ }
+ /*hmhmhmm... this may break qgroupbox children?!?*/
+ else if (::qt_cast<QGroupBox*>(obj))
+ {
+ QGroupBox* gb = (QGroupBox*)(obj);
+ if(gb->title().isEmpty()) return false;
+ QResizeEvent * e = (QResizeEvent*)ev;
+ int fm = gb->fontMetrics().height()+(gb->isCheckable()?4:1);
+ gb->setFrameRect(QRect(gb->rect().x(), gb->rect().y()+fm, e->size().width(), e->size().height()-fm/*-gb->frameWidth()*/));
+ if(gb->layout())
+ gb->layout()->setGeometry(QRect(gb->rect().x(), gb->rect().y(), e->size().width(), e->size().height()));
+ return true;
+ }
+ else if ( obj->inherits( "KActiveLabel" ))
+ {
+ QWidget * w = ( QWidget * ) obj;
+ QPalette pal( w->palette() );
+ QPixmap *tile = pal.brush( QPalette::Active, QColorGroup::Background ).pixmap();
+ if ( tile )
+ {
+ QSize sz( ev->type() == QEvent::Resize ? rev->size() : w->size() );
+ QPixmap pix( sz.width(), sz.height() );
+ QPainter p;
+ if (optionHandler->style() == Brushed)
+ {
+ p.begin( &pix );
+ // calc brush offsets
+ QWidget *window = w->topLevelWidget();
+ int leftWidth;
+ int rightWidth;
+ if (window)
+ {
+ QPoint zero = w->mapTo(window, QPoint(0,0));
+ leftWidth = (window->width()-1024)/2 - zero.x();
+ rightWidth = pix.width() - (1024 + leftWidth);
+ if (leftWidth > 0)
+ p.drawTiledPixmap(0, 0, leftWidth, sz.height(), plainBrush);
+ p.drawTiledPixmap(leftWidth>0?leftWidth:0, 0,
+ pix.width()-(leftWidth>0?leftWidth:0)-(rightWidth>0?rightWidth:0), sz.height(),
+ gradBrush,leftWidth>0?0:(zero.x()-(window->width()-1024)/2));
+ if (rightWidth > 0)
+ p.drawTiledPixmap(pix.width()-rightWidth, 0, rightWidth, sz.height(), plainBrush);
+ }
+ else if (pix.width() > 1024)
+ {
+ leftWidth = (pix.width()-1024)/2;
+ rightWidth = pix.width() - leftWidth;
+ p.drawTiledPixmap(0, 0, leftWidth, sz.height(), plainBrush);
+ p.drawTiledPixmap(leftWidth, 0, 1024, sz.height(), gradBrush);
+ p.drawTiledPixmap(leftWidth + 1024, 0, rightWidth, sz.height(), plainBrush);
+ }
+ else
+ p.drawTiledPixmap(0, 0, pix.width(), sz.height(), gradBrush, (1024-pix.width())/2, 0);
+ p.end();
+ QBrush brush( pal.active().background(), pix );
+ pal.setBrush( QColorGroup::Base, brush );
+ w->setPalette( pal );
+ }
+ else
+ {
+ p.begin(w);
+ p.drawTiledPixmap(QRect(0,0,sz.width(),sz.height()), *tile, w->backgroundOffset());
+ }
+ }
+ return false;
+ }
+ else if ((optionHandler->style() == Brushed) && obj->isWidgetType() && ((QWidget*)obj)->isTopLevel() &&
+ !(::qt_cast<QPopupMenu*>(obj) || ::qt_cast<QMenuBar*>(obj) || ((QWidget*)obj)->isDesktop () || ::qt_cast<QListBox*>(obj) ||
+ obj->inherits("QTipLabel") || obj->inherits("AlphaWidget") || obj->inherits("ScrollWidget") ) && (ev->type() == QEvent::Show ||
+ rev->size().width() != rev->oldSize().width()))
+ {
+ QWidget* widget = (QWidget*)obj;
+ // create new brushpix
+ QPixmap tmpBrushPix(ev->type() == QEvent::Show?widget->width():rev->size().width(), plainBrush.height());
+ QPainter lightMe(&tmpBrushPix);
+ // calc brush offsets
+ int tmpWidth;
+ if ((tmpWidth = tmpBrushPix.width()) > 1024)
+ {
+ int leftWidth = (tmpWidth-1024)/2;
+ int rightWidth = tmpWidth - leftWidth;
+ lightMe.drawTiledPixmap(0, 0, leftWidth, plainBrush.height(), plainBrush,256-leftWidth,0);
+ lightMe.drawPixmap(leftWidth, 0, gradBrush);
+ lightMe.drawTiledPixmap(leftWidth + 1024, 0, rightWidth, plainBrush.height(), plainBrush);
+ }
+ else
+ lightMe.drawPixmap(0, 0, gradBrush, (1024-tmpWidth)/2, 0, tmpWidth);
+ lightMe.end();
+ //update palette
+ QPalette pal( qApp->palette());
+ QBrush brush( pal.active().background(), tmpBrushPix );
+ pal.setBrush ( QColorGroup::Background, brush );
+ //reset apps palette
+ qApp->installEventFilter(eventKiller); // pssst... don't let anyone know...
+ qApp->setPalette(pal);
+ pal = QPalette(widget->palette());
+ pal.setBrush ( QColorGroup::Background, brush );
+ widget->installEventFilter(eventKiller); // pssst... don't let anyone know...
+ widget->setPalette(pal);
+ widget->removeEventFilter(eventKiller); // ...that we just replaced the palette
+ QObjectList *kids = widget->queryList("QWidget"); //TODO: implement a faster version, depending on ::qt_cast<QWidget*>()
+ for (uint i= 0; i < kids->count(); i++)
+ {
+ QWidget *kid = (QWidget*)kids->at(i);
+ if (kid && kid->paletteBackgroundPixmap() && !(kid->isTopLevel() || kid->inherits( "KonqIconViewWidget" ) || kid->inherits( "khtml") || kid->inherits( "KActiveLabel") || qstrcmp( kid->name(), "_B_ALI_HEADER" ) == 0 || (kid->parentWidget() && kid->parentWidget()->inherits("Thumbnail") || kid->parentWidget()->inherits("MarkListItem")) ))
+ {
+ //we can loose those kids anytime - especially if the user plays on konqueror...
+ if (::qt_cast<KToolBarButton*>(kid))
+ kid->setErasePixmap(tmpBrushPix);
+ else
+ {
+ pal = QPalette(kid->palette());
+ pal.setBrush ( QColorGroup::Background, brush );
+ kid->installEventFilter(eventKiller); // pssst... don't let anyone know...
+ kid->setPalette(pal);
+ kid->removeEventFilter(eventKiller); // ...that we just replaced the palette
+ }
+ }
+ }
+ delete kids;
+ qApp->removeEventFilter(eventKiller); // ...that we just replaced the palette
+ return false;
+ }
+ return false;
+ }
+ case QEvent::Hide:
+ if (optionHandler->AnimateButton() && ::qt_cast<QPushButton*>(obj))
+ {
+ ButtonFadeInfo *bfi_ = bfi[((QPushButton*)obj)->winId()];
+ if (bfi_)
+ {
+ obj->killTimer(bfi_->timerId);
+ // qWarning("%u: stopped (%d)", ((QPushButton*)obj)->winId(), bfi_->timerId);
+ bfi_->index=0;
+ bfi_->timerId=0;
+ }
+ }
+ case QEvent::ApplicationPaletteChange:
+ if ( obj->inherits( "QTipLabel" ) )
+ {
+ ( ( QWidget* ) obj ) ->setPalette( tooltipPalette );
+ return true;
+ }
+ return false;
+ case QEvent::PaletteChange:
+ if (obj->inherits("QStatusBar"))
+ {
+ obj->installEventFilter(eventKiller);
+ ((QWidget*)obj)->setPalette(qApp->palette());
+ obj->removeEventFilter(eventKiller);
+ return true;
+ }
+ if ( obj->inherits( "QTipLabel" ) )
+ {
+ ( ( QWidget* ) obj ) ->setPalette( tooltipPalette );
+ return true;
+ }
+ if (obj->inherits("KCalcButton"))
+ {
+ QWidget *w = (QWidget*)obj;
+ QPalette pal( w->palette() );
+ pal.setBrush( QColorGroup::Background, qApp->palette().brush(QPalette::Active, QColorGroup::Background));
+ w->installEventFilter(eventKiller);
+ w->setPalette( pal );
+ w->removeEventFilter(eventKiller);
+ w->setBackgroundOrigin( QWidget::WindowOrigin );
+ return true;
+ }
+ return false;
+ case QEvent::WindowActivate:
+ if (optionHandler->style() == Tiger && ::qt_cast<QToolBar*>(obj))
+ {
+ QToolBar *tb = (QToolBar*)obj;
+ QPoint pt = tb->mapTo(tb->topLevelWidget(), QPoint(0,0));
+ if (pt.y() == 0)
+ {
+ tb->installEventFilter(eventKiller);
+ tb->setPaletteBackgroundColor(optionHandler->aDecoColor2());
+ tb->setPaletteBackgroundPixmap(activeToolbarPix);
+ tb->removeEventFilter(eventKiller);
+ }
+ }
+ return false;
+ case QEvent::WindowDeactivate:
+ if (optionHandler->style() == Tiger && ::qt_cast<QToolBar*>(obj))
+ {
+ QToolBar *tb = (QToolBar*)obj;
+ QPoint pt = tb->mapTo(tb->topLevelWidget(), QPoint(0,0));
+ if (pt.y() == 0)
+ {
+ QPalette pal( tb->palette() );
+ pal.setColor( QColorGroup::Background, qApp->palette().color(QPalette::Active, QColorGroup::Background) );
+ pal.setBrush ( QColorGroup::Background, qApp->palette().brush(QPalette::Active, QColorGroup::Background) );
+ tb->installEventFilter(eventKiller);
+ tb->setPalette( pal );
+ obj->removeEventFilter(eventKiller);
+ }
+ }
+ return false;
+ default:
+ return false;
+ }
+}
+
+void LiquidStyle::fakeMouse()
+{
+ if (mouseButtonPressed_) // delayed mousepress for move event
+ {
+ QCursor::setPos ( cursorPos_ );
+ XTestFakeButtonEvent(qt_xdisplay(),1, false, 0);
+ XTestFakeKeyEvent(qt_xdisplay(),XKeysymToKeycode(qt_xdisplay(), XK_Alt_L), true, 0);
+ XTestFakeButtonEvent(qt_xdisplay(),1, true, 0);
+ XTestFakeKeyEvent(qt_xdisplay(),XKeysymToKeycode(qt_xdisplay(), XK_Alt_L), false, 0);
+ XFlush(qt_xdisplay());
+ }
+}
+
+void LiquidStyle::fadeIn(QPushButton *button)
+{
+ ButtonFadeInfo *bfi_ = bfi[button->winId()];
+ if (!bfi_)
+ {
+ bfi_ = new ButtonFadeInfo();
+ bfi.insert(button->winId(),bfi_);
+ }
+ bfi_->fadeIn = true;
+ if (bfi_->timerId == 0)
+ {
+ bfi_->index = 0;
+ bfi_->timerId = button->startTimer(button->isDefault()?100:50);
+ // qWarning("%u: started (%d)", button->winId(), bfi_->timerId);
+ }
+}
+
+void LiquidStyle::fadeOut(QPushButton *button)
+{
+ ButtonFadeInfo *bfi_ = bfi[button->winId()];
+ if (!bfi_)
+ {
+ bfi_ = new ButtonFadeInfo();
+ bfi.insert(button->winId(),bfi_);
+ }
+ bfi_->fadeIn = false;
+ if (bfi_->timerId == 0)
+ {
+ bfi_->index = 9;
+ bfi_->timerId = button->startTimer(50);
+ // qWarning("%u: started (%d)", button->winId(), bfi_->timerId);
+ }
+}
+
+BMShower::BMShower(QObject *parent) : QObject(parent)
+{
+}
+
+bool BMShower::eventFilter( QObject *obj, QEvent *ev )
+{
+ if (ev->type() == QEvent::Show && (obj->isWidgetType() && ((QWidget*)obj)->isTopLevel() &&
+ !(::qt_cast<QPopupMenu*>(obj) || ::qt_cast<QMenuBar*>(obj) || ((QWidget*)obj)->isDesktop () || ::qt_cast<QListBox*>(obj) ||
+ obj->inherits("QTipLabel") || obj->inherits("AlphaWidget") || obj->inherits("ScrollWidget") )))
+ {
+ QResizeEvent* rev = new QResizeEvent(((QWidget*)obj)->size(), QSize(0,0));
+ parent()->eventFilter( obj, rev );
+ obj->removeEventFilter(this);
+ delete rev;
+ }
+ return false;
+}
diff --git a/style/fracts.h b/style/fracts.h
new file mode 100644
index 0000000..1774e93
--- /dev/null
+++ b/style/fracts.h
@@ -0,0 +1,74 @@
+#ifndef FRACTS_H
+#define FRACTS_H
+
+/*
+If you wish to replace the button or combo Images, you may end up with very querky results.
+The reason is, that the style internally fracts those images into 9 tiles.
+
+To get valid results, you need to adjust the values below, so they fit your images.
+the format is:
+w, h, xOff, yOff, centerW, centerH, shadowH, glowWH
+
+- w, h are width and height of the whole button.
+- xOff (yOff) is the distance of the central fraction from left (upper) button side.
+- centerW (centerH) is the width (height) of the central button fraction.
+- shadowH is the height of the buttons shadow
+- glowWH is the size of the frame the glow draws around the button
+
+an image may be helpful (make sure your editor uses a monospace font)
+
+[- - - - - - - - - - - - - - - w - - - - - - - - - - - - -]---
+|----------------|--------------------------|-----------------| |
+| | | |
+| yOff | | |
+| | | |
+|----- xOff----->o--------- centerW --------|-----------------| |
+| | | |
+| | centerH | h
+| | | |
+|----------------|--------------------------|-----------------| |
+| | | |
+| | | | |
+| | | |
+| | | | |
+|----------------|--------------------------|-----------------| |
+. ---
+
+Also please notice, that the Button tiles are treated different from the rectangualr ones, namely, (S: static, T: tiled, TH: tiled horizontally, TV: tiled vertically)
+
+Round Button, Combo:
+|----------------|--------------------------|-----------------|
+| | | |
+| S | TH | S |
+| | | |
+|----------------|--------------------------|-----------------|
+| | | |
+| TV | T | TV |
+| | | |
+|----------------|--------------------------|-----------------|
+| | | |
+| | | |
+| S | TH | S |
+| | | |
+|----------------|--------------------------|-----------------|
+
+Rectangular Button:
+|----------------|--------------------------|-----------------|
+| | | |
+| TV | TH | TV |
+| | | |
+|----------------|--------------------------|-----------------|
+| | | |
+| S | TH | S |
+| | | |
+|----------------|--------------------------|-----------------|
+| | | |
+| | | |
+| TV | TH | TV |
+| | | |
+|----------------|--------------------------|-----------------|
+
+*/
+
+
+#endif
diff --git a/style/generatePixmaps.sh b/style/generatePixmaps.sh
new file mode 100755
index 0000000..388b002
--- /dev/null
+++ b/style/generatePixmaps.sh
@@ -0,0 +1,54 @@
+#!/bin/sh
+top_srcdir="${1:-../..}"
+imagebase="$top_srcdir/imagebase"
+UIC=$(grep "UIC = " ../Makefile | cut -f3- -d" ")
+echo -e "#ifndef SPIXMAPS_H\n#define SPIXMAPS_H\n" > pixmaps.h
+$UIC -embed baghira \
+$imagebase/brushed-gradient \
+$imagebase/brushed-tile \
+$imagebase/button-base \
+$imagebase/button-milk \
+$imagebase/button-glow \
+$imagebase/button-jaguar \
+$imagebase/button-shadow \
+$imagebase/checkbox \
+$imagebase/checkboxdown \
+$imagebase/checkbox-milk \
+$imagebase/checkboxdown-milk \
+$imagebase/combo \
+$imagebase/combo-milk \
+$imagebase/combo-jaguar \
+$imagebase/combo-shadow \
+$imagebase/htmlradio \
+$imagebase/htmlradio_down \
+$imagebase/progress \
+$imagebase/progress2 \
+$imagebase/radio \
+$imagebase/radio_down \
+$imagebase/radio-milk \
+$imagebase/radio_down-milk \
+$imagebase/rectbutton \
+$imagebase/roundFrame \
+$imagebase/sbgroove_btm \
+$imagebase/sbgroove_mid \
+$imagebase/sbgroove_top \
+$imagebase/sbIslider_mid \
+$imagebase/sbslider_btm \
+$imagebase/sbslider_btm_shd \
+$imagebase/sbslider_mid \
+$imagebase/sbslider_top \
+$imagebase/sbslider_top_shd \
+$imagebase/sb_subadd \
+$imagebase/sliderarrow \
+$imagebase/sbgroove_btm-milk \
+$imagebase/sbgroove_mid-milk \
+$imagebase/sbgroove_top-milk \
+$imagebase/sbslider_btm-milk \
+$imagebase/sbslider_mid-milk \
+$imagebase/sbslider_top-milk \
+$imagebase/sb_subadd-milk \
+$imagebase/sliderarrow-milk \
+$imagebase/tab \
+$imagebase/tab-milk \
+$imagebase/tab-jaguar >> pixmaps.h
+echo -e "#endif //SPIXMAPS_H\n" >> pixmaps.h
diff --git a/style/optionHandler.cpp b/style/optionHandler.cpp
new file mode 100644
index 0000000..d96b700
--- /dev/null
+++ b/style/optionHandler.cpp
@@ -0,0 +1,251 @@
+#include "baghira.h"
+#include <qapplication.h>
+#include <qbrush.h>
+#include <qcolor.h>
+#include <qevent.h>
+#include <qimage.h>
+#include <qobject.h>
+#include <qpainter.h>
+#include <qpalette.h>
+#include <qpopupmenu.h>
+#include <qrect.h>
+#include <qsettings.h>
+#include <qsize.h>
+#include <qstring.h>
+// #include <kconfig.h>
+#include <kpixmapeffect.h>
+#include <stdio.h>
+#include <cmath>
+
+#define _SCALE_ 65536
+#define _NORMALIZE_ >>16
+
+#define CLAMP(x,l,u) x < l ? l :\
+x > u ? u :\
+x
+
+OptionHandler::OptionHandler( QObject *parent ) : QObject( parent ) {
+ scrollerActive = false;
+ groupShadowButton = false;
+ reloadSettings();
+ }
+
+
+const QColor& OptionHandler::textColor() {
+ return ( useCustomMenuColor ? fgColor : qApp->palette().active().text() );
+ }
+
+const QColor& OptionHandler::bgColor() {
+ return qApp->palette().active().background();
+ }
+
+const QColor& OptionHandler::buttonColor() {
+ LiquidStyle * style = ( LiquidStyle* ) parent();
+ /*if (style->isKicker) return style->origPanelBrush.color();
+ else */if (style->isOOO) return CustomButtonColor();
+ else return qApp->palette().active().button();
+ }
+
+void OptionHandler::reloadSettings() {
+ // gather options...
+ QSettings config;
+ config.beginGroup("/baghira/Style");
+ //we need that first to make sure we use some proper settings ;)
+ customButtonColor = QColor(config.readNumEntry("Design_ButtonColor",(int)qApp->palette().active().button().rgb()));
+ // design handling:
+ // first try file:
+ QString tmpString;
+ FILE *file = NULL;
+ wmDesign = 5;
+ for (int i = 0; i < 8; i++)
+ custCols[i] = -1;
+ if (qstrcmp( qApp->argv() [ 0 ], "ksplash" ) == 0)
+ {
+ style_ = Panther;
+ _toolbuttonStyle = Panther;
+ _buttonStyle = Panther;
+ tabStyle_ = Clever;
+ bgStipple = false;
+ inactiveButtonColor = Background;
+ }
+ else
+ {
+ // first try for a tmp file from bab starter
+ int tmpFile = 0;
+ tmpString = QDir::homeDirPath() + "/.baghira/.bab/" + qApp->argv() [ 0 ];
+ file = fopen(tmpString.latin1(), "r");
+ if( file == NULL )
+ {
+ tmpFile = 1;
+ tmpString = QDir::homeDirPath() + "/.baghira/" + qApp->argv() [ 0 ];
+ file = fopen(tmpString.latin1(), "r");
+ if( file == NULL )
+ {
+ tmpFile = 2;
+ tmpString = QDir::homeDirPath() + "/.baghira/.bab/.style";
+ file = fopen(tmpString.latin1(), "r");
+ }
+ }
+ if (file != NULL)
+ {
+ style_ = _buttonStyle = _toolbuttonStyle = Panther; int i3 = inactiveButtonColor = -1; tabStyle_ = (tabStyle)-1;
+ fscanf(file,"%u\n%u\n%u\n%u\n%u\n%u\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n%d\n",&style_, &wmDesign, &_buttonStyle, &_toolbuttonStyle, &tabStyle_, &i3, &custCols[0], &custCols[1], &custCols[2], &custCols[3], &custCols[4], &custCols[5], &custCols[6], &custCols[7], &inactiveButtonColor);
+ fclose(file);
+ if (_toolbuttonStyle < 0 || _toolbuttonStyle >= NUMSTYLES)
+ _toolbuttonStyle = (Style)config.readNumEntry( "Special_ToolbuttonStyle", style_);
+ if (_buttonStyle < 0 || _buttonStyle >= NUMSTYLES)
+ _buttonStyle = (Style)config.readNumEntry( "Special_ButtonStyle", style_);
+ if (tabStyle_ < 0 || tabStyle_ > 2)
+ tabStyle_ = (tabStyle) config.readNumEntry( (style_ == Brushed)?"Design_TabStyleBrushed":"Design_TabStyleAqua", Clever);
+ if (inactiveButtonColor < 0 || inactiveButtonColor > 3)
+ inactiveButtonColor = config.readNumEntry( "Design_InactiveButtonStyle", Background);
+ if (style_ == Brushed)
+ bgStipple = TRUE;
+ else if (i3 == 0)
+ bgStipple = FALSE;
+ else
+ bgStipple = config.readBoolEntry( "Design_StippleBackground", true );
+ // inactive Button
+ if (tmpFile == 0)
+ remove(tmpString.latin1()); // remove TEMPORARY file
+ else if (tmpFile == 2)
+ {
+ tmpString = QDir::homeDirPath() + "/.baghira/.bab/.deco";
+ if ((file = fopen(tmpString.latin1(), "r")) != NULL)
+ {
+ fscanf(file,"%u\n%u\n",&i3, &wmDesign);
+ fclose(file);
+ }
+ }
+ }
+ else
+ {
+ style_ = (Style)config.readNumEntry( "Design_Default", Panther );
+ _toolbuttonStyle = (Style)config.readNumEntry( "Special_ToolbuttonStyle", style_);
+ _buttonStyle = (Style)config.readNumEntry( "Special_ButtonStyle", style_);
+ tabStyle_ = (tabStyle) config.readNumEntry( (style_ == Brushed)?"Design_TabStyleBrushed":"Design_TabStyleAqua", Clever);
+ bgStipple = (style_ == Brushed) ? true : config.readBoolEntry( "Design_StippleBackground", true );
+ inactiveButtonColor = config.readNumEntry( "Design_InactiveButtonStyle", Background);
+ }
+ }
+ contrast = 0;
+ if (wmDesign > 4)
+ wmDesign = style_;
+ if (style_ == Jaguar)
+ contrast = 4;
+ else if (style_ == Brushed)
+ {
+ tintBrush = config.readBoolEntry( "Colors_TintBrushedMetal", false );
+ if (tintBrush)
+ brushTint.setRgb( config.readNumEntry( "Colors_BrushTint", ( int ) bgColor().rgb()));
+ }
+ // menu stuff
+ glossyMenus_ = config.readBoolEntry( "Menu_Glossy", true );
+ menuBackground = config.readNumEntry( "Menu_Background", Standard);
+ menuOpacity = config.readNumEntry( "Menu_Opacity", 70);
+ int menuColorStyle = config.readNumEntry( "Menu_ColorStyle", 0);
+ menuColorButton = (menuColorStyle == 1);
+ useCustomMenuColor = (menuColorStyle == 2);
+ shadowText = config.readBoolEntry( "Menu_ShadowText", false);
+ if (useCustomMenuColor){
+ color = QColor( config.readNumEntry( "Menu_Color1", 0 ) );
+ color2 = QColor( config.readNumEntry( "Menu_Color2", 0 ) );
+ colorHigh = QColor( config.readNumEntry( "Menu_ColorHighlight", 0 ) );
+ fgColor = QColor( config.readNumEntry( "Menu_TextColor", 0 ) );
+ fgColorHigh = QColor( config.readNumEntry( "Menu_TextColorHighlight", 0 ) );
+ }
+ else if (menuColorButton){
+ color = customButtonColor;
+ color2 = customButtonColor.dark(130);
+ }
+ else {
+ color = qApp->palette().active().background();
+ color2 = qApp->palette().active().background().dark(130);
+ }
+ drawMenuStripe_ = config.readBoolEntry("Menu_DrawMenuStripe", false);
+ if (drawMenuStripe_)
+ menuStripeColor_ = QColor(config.readNumEntry("Menu_StripeColor"),(int)Qt::white.rgb());
+ // color stuff
+ // widgets
+ customWidgetColor = config.readBoolEntry( "Colors_UseCustomColors", false);
+ if ( customWidgetColor ) {
+ customColors[ CustomRadioOn ].setRgb( config.readNumEntry( "Colors_RadioOn", ( int ) buttonColor().rgb() ) );
+ customColors[ CustomRadioOff ].setRgb( config.readNumEntry( "Colors_RadioOff", ( int ) bgColor().rgb() ) );
+ customColors[ CustomCBOn ].setRgb( config.readNumEntry( "Colors_CheckOn", ( int ) buttonColor().rgb() ) );
+ customColors[ CustomCBOff ].setRgb( config.readNumEntry( "Colors_CheckOff", ( int ) bgColor().rgb() ) );
+ customColors[ CustomTabOn ].setRgb( config.readNumEntry( "Colors_TabActive", ( int ) buttonColor().rgb() ) );
+ customColors[ CustomTabOff ].setRgb( config.readNumEntry( "Colors_TabInactive", ( int ) bgColor().rgb() ) );
+ customColors[ CustomSBSlider ].setRgb( config.readNumEntry( "Colors_Slider", ( int ) bgColor().rgb() ) );
+ customColors[ CustomSBSliderHover ].setRgb( config.readNumEntry( "Colors_SliderHovered", ( int ) buttonColor().rgb() ) );
+ customColors[ CustomSBSliderPressed ].setRgb( config.readNumEntry( "Colors_SliderPressed", ( int ) buttonColor().dark(110).rgb() ) );
+ customColors[ CustomSBGroove ].setRgb( config.readNumEntry( "Colors_SliderGroove", ( int ) bgColor().rgb() ) );
+ }
+ if (inactiveButtonColor == Custom)
+ customInactiveButtonColor = QColor( config.readNumEntry( "Design_InactiveButtonColor", (int) bgColor().rgb()));
+ contrast += config.readNumEntry( "Design_StippleContrast", 3);
+ bevelHighlights_ = config.readBoolEntry( "Design_BevelAsHighlight", true);
+ //shadows
+groupboxshadow = (style_ == Brushed) ? false : config.readBoolEntry( "Design_ShadowGroupBoxes", true );
+ shadowDarkness = config.readNumEntry( "Design_GroupBoxeShadowDarkness", 6);
+ //ListViews
+ expanderStyle = config.readNumEntry( "Special_ExpanderStyle", Apple);
+ useCustomExpanderColor = config.readBoolEntry( "Special_CustomExpanderColor", false);
+ if (useCustomExpanderColor)
+ expanderColor = QColor( config.readNumEntry( "Special_ExpanderColor", (int) qApp->palette().active().text().rgb()));
+ drawDotlines = config.readBoolEntry( "Special_DrawTreeLines", true);
+ if (drawDotlines){
+ dotlineStyle = config.readNumEntry( "Special_TreelineStyle", Line);
+ dotlineColor = QColor( config.readNumEntry( "Special_TreelineColor", (int) qApp->palette().active().mid().rgb()));
+ }
+ //slider
+ squeezesbslider = config.readBoolEntry( "Special_SqueezeSlider", false );
+ shadowsbslider = config.readBoolEntry( "Special_ShadowSlider", false );
+ animateSlider = config.readBoolEntry( "Special_AnimateSlider", true );
+ // toolbar
+ int utb = config.readNumEntry( "Special_UnhoveredToolButtons", 2 );
+ tbFrame = (utb == 2) || ((style_ == Brushed) && (utb == 1)) || ((style_ != Brushed) && (utb == 0));
+
+ // tweaks
+ centerTabs = config.readBoolEntry( "Design_CenterTabs", true);
+ smoothListViewHeaders = (style_ == Milk) ? true : !config.readBoolEntry( "Special_UseFlatLVH", false);
+ smootherLVH = config.readBoolEntry( "Special_RoundTaskbuttons", false);
+ icyButtons = config.readNumEntry( "Design_ButtonStyle", 0) == 0;
+ progressBar = config.readNumEntry( "Special_ProgressStyle", baghira);
+ removeKickerBevel = config.readBoolEntry( "Special_RemoveKickerBevel", false);
+ animateButton = config.readBoolEntry( "Design_AnimateButtons", true);
+ animateProgress = config.readBoolEntry( "Design_AnimateProgress", true);
+ drawProgressLabel = config.readBoolEntry( "Special_ShowProgressValue", false);
+ config.endGroup();
+
+ config.beginGroup("/baghira/Deco");
+ titleButtonColor_[0] = QColor((unsigned int)config.readNumEntry( "CloseButtonColor", QColor(200,85,70).rgb()));
+ titleButtonColor_[1] = QColor((unsigned int)config.readNumEntry( "MinButtonColor", QColor(230,155,40).rgb()));
+ titleButtonColor_[2] = QColor((unsigned int)config.readNumEntry( "MaxButtonColor", QColor(121,180,54).rgb()));
+ if (style_ == Jaguar)
+ {
+ titleColor_[0] = QColor((unsigned int)config.readNumEntry( "inactiveColor1_1", QColor(204,214,230).rgb()));
+ titleColor_[1] = QColor((unsigned int)config.readNumEntry( "inactiveColor2_1", QColor(194,196,211).rgb()));
+ }
+ else if (style_ != Brushed)
+ {
+ titleColor_[0] = QColor((unsigned int)config.readNumEntry( "activeColor1_2", QColor(238,238,238).rgb()));
+ titleColor_[1] = QColor((unsigned int)config.readNumEntry( "activeColor2_2", QColor(205,202,205).rgb()));
+ }
+ if (style_ == Tiger)
+ {
+ int r,g,b;
+ aDecoColor1_ = QColor((unsigned int)config.readNumEntry( "activeColor2_4", (unsigned int) QColor(205,202,205).rgb()));
+ aDecoColor2_ = QColor((unsigned int)config.readNumEntry( "activeColor1_4", (unsigned int) QColor(238,238,238).rgb()));
+ r = (int)CLAMP(aDecoColor1_.red() * pow((double)aDecoColor1_.red() / (double)aDecoColor2_.red(),2.0),0,255);
+ g = (int)CLAMP(aDecoColor1_.green() * pow((double)aDecoColor1_.green() / (double)aDecoColor2_.green(),2.0),0,255);
+ b = (int)CLAMP(aDecoColor1_.blue() * pow((double)aDecoColor1_.blue() / (double)aDecoColor2_.blue(),2.0),0,255);
+ aDecoColor2_.setRgb(r,g,b);
+ }
+ else
+ {
+ aDecoColor1_ = Qt::black;
+ aDecoColor2_ = Qt::black;
+ }
+ config.endGroup();
+ // Option gathered
+ }
diff --git a/style/polish.cpp b/style/polish.cpp
new file mode 100644
index 0000000..f845d2b
--- /dev/null
+++ b/style/polish.cpp
@@ -0,0 +1,878 @@
+//#include <qdir.h>
+#include "baghira.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <qapplication.h>
+#include <qbrush.h>
+#include <qcolor.h>
+#include <qcombobox.h>
+#include <qcursor.h>
+#include <qdialog.h>
+#include <qframe.h>
+#include <qfile.h>
+#include <qheader.h>
+#include <qgroupbox.h>
+//#include <qiconview.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qlistbox.h>
+#include <klistview.h>
+#include <kmenubar.h>
+#include <qpalette.h>
+#include <qpainter.h>
+#include <qpopupmenu.h>
+#include <qpushbutton.h>
+#include <qscrollbar.h>
+#include <qscrollview.h>
+#include <qsizepolicy.h>
+#include <qslider.h>
+#include <qtabbar.h>
+#include <qtoolbar.h>
+#include <qtoolbutton.h>
+#include <kdeversion.h>
+#include <kpixmapeffect.h>
+#include <kglobalsettings.h>
+#include <kwin.h>
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+#include <fixx11h.h>
+#define OPAQUE 0xffffffff
+#define OPACITY "_KDE_WM_WINDOW_OPACITY"
+#define _FORCE_SCROLLBARS_ 0
+
+#ifndef CLAMP
+#define CLAMP(x,l,u) x < l ? l :\
+x > u ? u :\
+x
+#endif
+
+
+void LiquidStyle::polish( QPalette &pal )
+{
+ if ( inExitPolish )
+ return ;
+ // clear out all old colorized pixmaps
+ int i;
+ for ( i = 0; i < BITMAP_ITEMS; ++i )
+ {
+ if ( pixmaps[ i ] )
+ {
+ delete pixmaps[ i ];
+ pixmaps[ i ] = NULL;
+ }
+ }
+ // clear out all dicts
+ btnDict.clear();
+ btnShadowedDict.clear();
+ // reset brushes
+ pagerHoverBrush = QBrush();
+ pagerBrush = QBrush();
+
+ bool newPalette = false;
+ struct stat buffer;
+ if ( stat( QFile::encodeName( QDir::homeDirPath() + "/.qt/qtrc" ), &buffer ) == 0 )
+ {
+ unsigned int lastModTime = ( unsigned int ) buffer.st_mtime;
+ if ( lastModTime > qtrcModificationTime )
+ {
+ qtrcModificationTime = lastModTime;
+ newPalette = true;
+ }
+ }
+ else if ( !initialPaletteLoaded ) // Hack, should always have qtrc in KDE
+ newPalette = true;
+ initialPaletteLoaded = true;
+
+ if ( !newPalette )
+ {
+ pal = polishedPalette;
+ return ;
+ }
+
+ originalBgColor = pal.color(QPalette::Active, QColorGroup::Background);
+ if (optionHandler->style() == Brushed)
+ pal.setColor(QColorGroup::Background, brushedMetalColor(optionHandler->BrushTint()));
+ if (isOOO)
+ pal.setColor( QColorGroup::Button, pal.active().background() );
+ else if (optionHandler->custCols[0] != -1)
+ {
+ pal.setColor(QColorGroup::Background, QColor(optionHandler->custCols[0]));
+ pal.setColor(QColorGroup::Button, QColor(optionHandler->custCols[1]));
+ pal.setColor(QColorGroup::Base, QColor(optionHandler->custCols[2]));
+ pal.setColor(QPalette::Active, QColorGroup::Text, QColor(optionHandler->custCols[3]));
+ pal.setColor(QPalette::Active, QColorGroup::Foreground, QColor(optionHandler->custCols[3]));
+ pal.setColor(QColorGroup::Highlight, QColor(optionHandler->custCols[4]));
+ pal.setColor(QPalette::Active, QColorGroup::HighlightedText, QColor(optionHandler->custCols[5]));
+ pal.setColor(QPalette::Active, QColorGroup::ButtonText, QColor(optionHandler->custCols[6]));
+ pal.setColor(QColorGroup::Mid, QColor((qRed(optionHandler->custCols[2])+qRed(optionHandler->custCols[3]))/2,(qGreen(optionHandler->custCols[2])+qGreen(optionHandler->custCols[3]))/2,(qBlue(optionHandler->custCols[2])+qBlue(optionHandler->custCols[3]))/2));
+
+ pal.setColor(QPalette::Inactive, QColorGroup::Text, QColor(optionHandler->custCols[3]));
+ pal.setColor(QPalette::Inactive, QColorGroup::HighlightedText, QColor(optionHandler->custCols[5]));
+ pal.setColor(QPalette::Inactive, QColorGroup::ButtonText, QColor(optionHandler->custCols[6]));
+ }
+ else
+ pal.setColor( QColorGroup::Button, optionHandler->CustomButtonColor() );
+#if 0
+ if ( isKicker )
+ {
+ origPanelBrush = pal.brush( QPalette::Active, QColorGroup::Background );
+ origPanelPalette = pal;
+ QColor c( pal.active().background() );
+
+ if ( optionHandler->usePanelCustomColor() && optionHandler->panelCustomColor().isValid() )
+ c = optionHandler->panelCustomColor();
+
+ kickerColor = c;
+
+ pal.setColor( QColorGroup::Mid, optionHandler->CustomButtonColor().dark( 110 ) );
+ pal.setColor( QColorGroup::Dark, optionHandler->CustomButtonColor().dark( 130 ) );
+ pal.setColor( QColorGroup::Midlight, optionHandler->CustomButtonColor().light( 110 ) );
+ pal.setColor( QColorGroup::Light, optionHandler->CustomButtonColor().light( 115 ) );
+ pal.setColor( QColorGroup::Button, optionHandler->CustomButtonColor());
+
+ if (optionHandler->style() == Brushed)
+ {
+ QBrush brush( c, gradBrush );
+ pal.setBrush( QColorGroup::Background, brush );
+ }
+ else if ( optionHandler->usePanelStipple() )
+ {
+ QPixmap stipple( 64, 64 );
+ stipple.fill( c.rgb() );
+ QPainter p( &stipple );
+ p.setPen( c.dark( 100 + (int)(optionHandler->stippleContrast()/4) ) );
+ for ( int i = 1; i < 64; i += 4 )
+ {
+ p.drawLine( 0, i, 63, i );
+ p.drawLine( 0, i+2, 63, i+2 );
+ }
+ p.setPen( c.dark( 100 + optionHandler->stippleContrast()) );
+ for ( int i = 2; i < 63; i += 4 )
+ p.drawLine( 0, i, 63, i );
+ p.end();
+ QBrush brush( c, stipple );
+ pal.setBrush( QColorGroup::Background, brush );
+ }
+ else
+ pal.setBrush( QColorGroup::Background, c );
+ }
+#endif
+ /*else*/ if (optionHandler->style() == Brushed)
+ {
+ QColor c( pal.active().background() );
+ QBrush brush( c, gradBrush );
+ pal.setBrush( QColorGroup::Background, brush );
+ }
+ else if ( !isPlain() )
+ {
+ QColor c( pal.active().background() );
+ QPixmap stipple( 64, 64 );
+ stipple.fill( c.rgb() );
+ QPainter p;
+ p.begin( &stipple );
+ p.setPen( c.dark( 100 + (int)(optionHandler->stippleContrast()/2) ) );
+ for ( i = 1; i < 64; i += 4 )
+ {
+ p.drawLine( 0, i, 63, i );
+ p.drawLine( 0, i+2, 63, i+2 );
+ }
+ p.setPen( c.dark( 100 + optionHandler->stippleContrast() ) );
+ for ( i = 2; i < 63; i += 4 )
+ p.drawLine( 0, i, 63, i );
+ p.end();
+ QBrush brush( c, stipple );
+ pal.setBrush( QColorGroup::Background, brush );
+ }
+
+ if (optionHandler->bevelHighlights())
+ {
+ QColor c(pal.active().highlight());
+ QColor c2(c.light(140));
+ QPixmap pix2 = QPixmap(48,48);
+ QPainter coolPainter(&pix2);
+ KPixmap pix = QPixmap(48,24);
+ KPixmapEffect::gradient(pix,c,c2,KPixmapEffect::VerticalGradient,0);
+ coolPainter.drawPixmap(0,0,pix);
+ KPixmapEffect::gradient(pix,c2,c,KPixmapEffect::VerticalGradient,0);
+ coolPainter.drawPixmap(0,24,pix);
+ QBrush brush(c, pix2);
+ pal.setBrush(QColorGroup::Highlight, brush);
+ }
+ polishedPalette = pal;
+ optionHandler->reset();
+}
+
+void LiquidStyle::unPolish( QApplication *app )
+{
+ popupBack.resize(0,0);
+ QPalette pal( app->palette() );
+ inExitPolish = true;
+
+ if ( !isPlain() )
+ {
+ // reset any stipples
+ if ( pal.brush( QPalette::Active, QColorGroup::Background ).pixmap() )
+ pal.setBrush( QColorGroup::Background, pal.active().background() );
+ if ( pal.brush( QPalette::Active, QColorGroup::Button ).pixmap() )
+ pal.setBrush( QColorGroup::Button, pal.active().button() );
+// app->blockSignals( TRUE );
+ app->setPalette( pal );
+// app->blockSignals( FALSE );
+ }
+
+ inExitPolish = false;
+}
+
+Atom baghira_deco_design = XInternAtom(qt_xdisplay(), "BAGHIRA_DECO_DESIGN", False);
+
+void LiquidStyle::polish( QWidget *w )
+{
+// bool testWidget = w->inherits("Splash");
+// int testInt = 0;
+// if (w->sizePolicy().horData() == QSizePolicy::Minimum || w->sizePolicy().horData() == QSizePolicy::MinimumExpanding)
+// qWarning("%s, \"%s\"",w->className(), w->name());
+// w->installEventFilter(this);
+
+ bool tmpBool = false;
+ bool isViewport = qstrcmp( w->name(), "qt_viewport" ) == 0 ||
+ qstrcmp( w->name(), "qt_clipped_viewport" ) == 0;
+ bool isViewportChild = w->parent() &&
+ ( ( qstrcmp( w->parent() ->name(), "qt_viewport" ) == 0 ) ||
+ ( qstrcmp( w->parent() ->name(), "qt_clipped_viewport" ) == 0 ) );
+
+ if (w->isTopLevel())
+ {
+ if ( ::qt_cast<QPopupMenu*>(w)) // popup menu designs
+ {
+ switch (optionHandler->MenuBackground())
+ {
+ case Plain:
+ w->setBackgroundMode( QWidget::PaletteBackground );
+ if (optionHandler->UseCustomMenuColor())
+ w->setPaletteBackgroundColor(optionHandler->Color());
+ else if (optionHandler->MenuColorButton())
+ w->setPaletteBackgroundColor(optionHandler->buttonColor());
+ else
+ w->setPaletteBackgroundColor(optionHandler->bgColor());
+ break;
+ case Stipples:
+ {
+ QColor c;
+ if (optionHandler->UseCustomMenuColor())
+ c = QColor( optionHandler->Color() );
+ else if (optionHandler->MenuColorButton())
+ c = QColor( optionHandler->buttonColor() );
+ else
+ c = QColor( originalBgColor );
+ if (popupBack.isNull())
+ {
+ popupBack = QPixmap(64,64);
+ QPixmap *stipple = &popupBack;
+ stipple->fill( c.rgb() );
+ QPainter p;
+ p.begin( stipple );
+ if (optionHandler->UseCustomMenuColor())
+ {
+ QColor c2 = QColor( optionHandler->Color2() );
+ p.setPen(QColor((3*c.red()+c2.red())/4,
+ (3*c.green()+c2.green())/4,
+ (3*c.blue()+c2.blue())/4));
+ for ( int i = 1; i < 64; i += 4 )
+ {
+ p.drawLine( 0, i, 63, i );
+ p.drawLine( 0, i+2, 63, i+2 );
+ }
+ p.setPen(c2);
+ for ( int i = 2; i < 63; i += 4 )
+ {
+ p.drawLine( 0, i, 63, i );
+ }
+ }
+ else
+ {
+ p.setPen( c.dark( 100 + (int)(optionHandler->stippleContrast()/4) ) );
+ for ( int i = 1; i < 64; i += 4 )
+ {
+ p.drawLine( 0, i, 63, i );
+ p.drawLine( 0, i+2, 63, i+2 );
+ }
+ p.setPen( c.dark( 100 + optionHandler->stippleContrast() ) );
+ for ( int i = 2; i < 63; i += 4 )
+ {
+ p.drawLine( 0, i, 63, i );
+ }
+ }
+ p.end();
+ }
+ w->setBackgroundMode( QWidget::NoBackground );
+ break;
+ }
+ case Gradient:
+ {
+ w->setBackgroundMode( QWidget::PaletteBackground );
+ KPixmap tmpPix = QPixmap(w->width(), 32);
+ w->setPaletteBackgroundPixmap(KPixmapEffect::unbalancedGradient(tmpPix, optionHandler->Color(), optionHandler->Color2(),KPixmapEffect::HorizontalGradient, 100, 100, 16));
+ w->installEventFilter( this );
+ break;
+ }
+ default:
+ w->setBackgroundMode( QWidget::PaletteBackground );
+ break;
+ }
+ //set popup menu opacity for them as they bypass the windowmanager
+ unsigned long opacity = optionHandler->MenuOpacity()/100.0*OPAQUE;
+ XChangeProperty(qt_xdisplay(), w->winId(), XInternAtom(qt_xdisplay(), OPACITY, False), XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &opacity, 1L);
+ goto kstpolish;
+ }
+ else
+ {
+ if (optionHandler->wmDesign < 5) // set deco design X Property
+ {
+ unsigned char *data = 0;
+ Atom actual;
+ int format, result;
+ unsigned long n, left;
+ result = XGetWindowProperty(qt_xdisplay(), w->winId(), baghira_deco_design, 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, &data);
+ if (result != Success || data == None) // not found set design
+ {
+ int tmp = optionHandler->wmDesign != Tiger ? optionHandler->wmDesign : Panther;
+ XChangeProperty(qt_xdisplay(), w->winId(), baghira_deco_design, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &(tmp), 1L);
+ }
+ }
+ if ((optionHandler->style() == Brushed) && !( ::qt_cast<QPopupMenu*>(w) || ::qt_cast<QMenuBar*>(w) || w->isDesktop() || ::qt_cast<QListBox*>(w) || w->inherits("QTipLabel") || w->inherits("AlphaWidget") || w->inherits("ScrollWidget") || w->inherits("PlayerWidget")))
+ // install resize event filter, allowing us to update the b/m gradient on horizontal resizes. some widgets must be excluded though
+ {
+ if (!isKicker)
+ w->installEventFilter( bmShower );
+ w->installEventFilter( this );
+ }
+ }
+ } // TopLevel Widgets
+
+ if (w->inherits("KURLBar")/*ListBox*/)
+ {
+ w->setPaletteBackgroundColor(qApp->palette().color(QPalette::Active, QColorGroup::Base));
+// ((QListBox*)w)->viewport()->setPaletteBackgroundColor(qApp->palette().color(QPalette::Active, QColorGroup::Base));
+ goto kstpolish;
+ }
+
+
+ if (w->inherits("KColorGrid"))
+ {
+ // kiconedit doesn't check for the paintevent rect size, but tries to create a (possibly) NULL Pixmap (after palette change event e.g.)
+ // so we catch it's paint event and destroy it if the size is NULL
+ // remove this after kiconedit corrected its code
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+
+ if (w->inherits("BGMonitor") || w->inherits("mapWidget") || w->isA("MyButton") || (w->parentWidget() && w->parentWidget()->inherits("Thumbnail")))
+ // don't touch these widgets at all - they don't like it
+ {
+ goto kstpolish;
+ }
+
+
+
+ if (qstrcmp( w->name(), "kde toolbar widget" ) == 0 )
+ w->installEventFilter( this );
+
+ if (::qt_cast<QButton*>(w))
+ {
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ if (::qt_cast<QPushButton*>(w))
+ {
+ if (w->inherits("KKeyButton"))
+ {
+ w->setBackgroundMode( QWidget::PaletteBackground);
+ QPalette pal( w->palette() );
+ pal.setBrush( QColorGroup::Background, qApp->palette().active().background() );
+ w->setPalette( pal );
+ }
+ else if (w->inherits("KCalcButton"))
+ {
+ w->setBackgroundMode( QWidget::PaletteBackground);
+ QPalette pal( w->palette() );
+ pal.setBrush( QColorGroup::Background, qApp->palette().brush(QPalette::Active, QColorGroup::Background));
+ w->setPalette( pal );
+ }
+ else
+#if !KDE_IS_VERSION(3,4,3)
+ if (!(w->parent() && w->parent()->inherits("MiniBar")))
+#endif
+ w->setBackgroundMode( QWidget::NoBackground);
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+ else if (w->inherits( "QRadioButton" ) || w->inherits( "QCheckBox" ))
+ {
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+ }
+
+ if ( ::qt_cast<QToolBar*>(w))
+ {
+ if (optionHandler->useToolButtonFrame() && w->inherits("KToolBar"))
+ ((QToolBar*)w)->boxLayout()->setSpacing( 0 );
+ ((QToolBar*)w)->setMargin( 4 );
+ w->setBackgroundMode(PaletteBackground);
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ if (optionHandler->style() > Panther)
+ {
+ w->installEventFilter( this );
+ if (optionHandler->wmDesign == Tiger)
+ {
+ XChangeProperty(qt_xdisplay(), w->topLevelWidget()->winId(), baghira_deco_design, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &(optionHandler->wmDesign), 1L);
+ }
+ }
+
+ goto kstpolish ;
+ }
+ //if (testWidget) qWarning("testwidget stage %d",testInt++);
+
+ if (tmpBool = ::qt_cast<QToolButton*>(w) || w->inherits( "QToolBarSeparator" ) || w->inherits( "KToolBarSeparator" ) )
+ {
+ if (tmpBool && w->parentWidget() && ::qt_cast<QToolBar*>(w->parentWidget()) )
+ {
+ w->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+ }
+ w->setBackgroundMode( QWidget::PaletteBackground );
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+
+ if (::qt_cast<QComboBox*>(w))
+ {
+ w->setBackgroundMode(NoBackground);
+ w->installEventFilter( this );
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ goto kstpolish;
+ }
+
+ if (w->inherits("TaskBar"))
+ {
+ w->setBackgroundOrigin(QWidget::WidgetOrigin);
+ goto kstpolish;
+ }
+
+ if (w->inherits("QSpinWidget") || w->inherits("KDockWidgetAbstractHeaderDrag")){
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+
+ if ( !isPlain () && (w->inherits( "KonqIconViewWidget" ) || w->inherits( "khtml")/* || w->inherits( "QtVisionView")*/))
+ {
+ // if you want custom backgrounds in konqueror, you have to reset pixmap, since Konq animation can't handle it
+ // original liquid did this on khtml, too (at speed loss) so we'll see, if we get errors from this...
+ QPalette pal( w->palette() );
+ pal.setBrush( QColorGroup::Background, pal.active().background() );
+ w->setPalette( pal );
+ }
+
+ if (::qt_cast<QSlider*>(w))
+ {
+ //avoid flicker
+ w->setBackgroundMode( QWidget::NoBackground );
+ goto kstpolish;
+ }
+
+ if ((::qt_cast<QScrollView*>(w) || w->inherits("KateView") || w->inherits("TEWidget") || w->inherits("CHexViewWidget")) && !(w->isA("KOAgenda")))
+ {
+ if (::qt_cast<KListView*>(w) && optionHandler->custCols[7] != -1 && ((KListView*)w)->alternateBackground() == KGlobalSettings::alternateBackgroundColor())
+ {
+ ((KListView*)w)->setAlternateBackground(QColor(optionHandler->custCols[7]));
+ }
+#if _FORCE_SCROLLBARS_
+ if (::qt_cast<QScrollView*>(w) && !w->inherits( "KActiveLabel" ))
+ {
+ ((QScrollView*)w)->setVScrollBarMode(QScrollView::AlwaysOn);
+ }
+#endif
+ if (::qt_cast<QListBox*>(w) && w->isTopLevel())
+ //set opacity for them as they bypass the windowmanager
+ {
+ uint opacity = 0.8*OPAQUE;
+ XChangeProperty(qt_xdisplay(), w->winId(), XInternAtom(qt_xdisplay(), OPACITY, False), XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &opacity, 1L);
+ }
+#if 0
+ // doesn't work properly - best would be to have the items drawn via style()
+ int height = ((QListBox*)w)->itemHeight();
+ if (height > 0)
+ {
+ QPalette pal = w->palette();
+ QColor c(pal.active().highlight());
+ QColor c2(c.light(140));
+ KPixmap pix = QPixmap(48,height);
+ KPixmapEffect::gradient(pix,c2,c,KPixmapEffect::VerticalGradient,0);
+ QBrush brush(c, pix);
+ pal.setBrush(QColorGroup::Highlight, brush);
+ w->setPalette(pal);
+ }
+#endif
+ // listen to enter events - highlightning the scrollbars
+ w->setMouseTracking( true );
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+
+ if (w->inherits("QStatusBar"))
+ {
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ if ( qstrcmp( w->name(), "KonquerorFrameStatusBar" ) == 0 )
+ // konqueror resets the statusbars background to Qt::White as soon as you open a new tab - our eventfilter will block this
+ {
+ w->installEventFilter( this );
+ }
+ goto kstpolish;
+ }
+
+ if (w->inherits( "QLineEdit" ) || w->inherits("QSplitterHandle") || w->isA( "AppletHandleDrag" ) || w->inherits( "KMiniPagerButton" ))
+ {
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+
+ if (w->inherits( "TaskContainer" ))
+ {
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+
+ if (w->inherits( "KickerTip" ))
+ // kickers new tooltip uses backgroundColor() instead of paletteBackgroundColor() - causing Qt::black
+ {
+ w->setPaletteBackgroundColor(qApp->palette().color(QPalette::Active, QColorGroup::Button));
+ w->setBackgroundMode( QWidget::NoBackground );
+ goto kstpolish;
+ }
+
+ if ( !isPlain() )
+ {
+ if ( !isViewport && w->parent() && qstrcmp( w->parent() ->name(), "proxyview" ) == 0 )
+ {
+ w->setBackgroundOrigin( QWidget::WindowOrigin );
+ goto kstpolish ;
+ }
+
+ if ( w->inherits( "PanelButtonBase" ) )
+ goto kstpolish ;
+ if ( !isKicker&& !isViewport && !isViewportChild && !w->testWFlags( WType_Popup ) && !w->inherits( "KDesktop" ) && !w->inherits( "PasswordDlg" ))
+ {
+ if ( w->backgroundMode() == QWidget::PaletteBackground || w->backgroundMode() == QWidget::PaletteButton )
+ {
+ w->setBackgroundOrigin( QWidget::WindowOrigin );
+ }
+ }
+ }
+ if ( ::qt_cast<QPushButton*>(w) || ::qt_cast<QComboBox*>(w)) goto kstpolish;
+ if ( ::qt_cast<QMenuBar*>(w))
+ {
+// if (optionHandler->SupportAppleBar() && w->isTopLevel()){
+// // QPalette pal(w->palette());
+// qWarning("resetting erase pixmap");
+// QColor c( w->palette().active().background() );
+// QPixmap stipple( 64, 64 );
+// stipple.fill( c.rgb() );
+// QPainter p;
+// p.begin( &stipple );
+// p.setPen( c.dark( 100 + (int)(optionHandler->stippleContrast()/2) ) );
+// for (int i = 1; i < 64; i += 4 ) {
+// p.drawLine( 0, i, 63, i );
+// p.drawLine( 0, i+2, 63, i+2 );
+// }
+// p.setPen( c.dark( 100 + optionHandler->stippleContrast()) );
+// for ( int i = 2; i < 63; i += 4 ) {
+// p.drawLine( 0, i, 63, i );
+// }
+// p.end();
+// // QBrush brush( c, stipple );
+// // pal.setBrush( QColorGroup::Background, brush );
+// // w->setPalette( pal );
+// w->setErasePixmap(stipple);
+// }
+ w->setBackgroundMode( QWidget::PaletteBackground );
+ if (optionHandler->UseCustomMenuColor())
+ {
+ QPalette pal( w->palette() );
+ pal.setBrush( QColorGroup::Highlight, optionHandler->menuColorHigh() );
+ pal.setBrush( QColorGroup::HighlightedText, optionHandler->textColorHigh() );
+ w->setPalette( pal );
+ }
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ w->installEventFilter( this );
+#if 0
+ if (!::qt_cast<KMenuBar*>(w))
+ {
+ bool bold = w->font().bold();
+ bool italic = w->font().italic();
+ bool underline = w->font().underline();
+ bool overline = w->font().overline();
+ w->setFont(KGlobalSettings::menuFont());
+ if (bold)
+ (const_cast<QFont*>(&w->font()))->setBold(true);
+ if (italic)
+ (const_cast<QFont*>(&w->font()))->setItalic(true);
+ if (underline)
+ (const_cast<QFont*>(&w->font()))->setUnderline(true);
+ if (overline)
+ (const_cast<QFont*>(&w->font()))->setOverline(true);
+ }
+#endif
+ goto kstpolish ;
+ }
+
+ if (::qt_cast<QFrame*>(w))
+ {
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ if ( ::qt_cast<QLabel*>(w))
+ {
+ if (w->parentWidget() && w->parentWidget()->inherits("Kontact::Splash"))
+ goto kstpolish;
+ else if ( !isPlain() && !(w->inherits( "QTipLabel" ) || w->inherits( "KSystemTray" )))
+ {
+ w->setBackgroundMode( QWidget::PaletteBackground );
+ }
+ else if ( w->inherits( "QTipLabel" ) )
+ {
+ w->setPalette( tooltipPalette );
+ w->setBackgroundOrigin(QWidget::WidgetOrigin);
+ w->installEventFilter( this );
+ }
+ }
+ if (qstrcmp( w->name(), "backdrop" ) == 0) //kscd
+ {
+ ((QFrame *)w)->setFrameShape(QFrame::LineEditPanel);
+ ((QFrame *)w)->setFrameShadow(QFrame::Sunken);
+ goto kstpolish;
+ }
+ if (w->inherits( "KWinInternal::TabBox" ))
+ {
+ uint opacity = 0.8*OPAQUE;
+ XChangeProperty(qt_xdisplay(), w->winId(), XInternAtom(qt_xdisplay(), OPACITY, False), XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &opacity, 1L);
+ goto kstpolish;
+ }
+ else if (w->inherits( "KAnimWidget" ))
+ {
+ ((QFrame *)w)->setFrameShape(QFrame::NoFrame);
+ w->installEventFilter( this ); // the widget resets it's frameshape on mouseevents - looks crap!
+ goto kstpolish ;
+ }
+ else if (((QFrame *)w)->frameShape() >= QFrame::Box && ((QFrame *)w)->frameShape() <= QFrame::WinPanel){
+ ((QFrame *)w)->setFrameShape(QFrame::StyledPanel);
+ goto kstpolish ;
+ }
+ }
+ //if (testWidget) qWarning("testwidget stage %d",testInt++);
+
+
+ if ( w->parentWidget() && ( ( ::qt_cast<QListBox*>(w) && ::qt_cast<QPushButton*>(w->parentWidget())) || w->inherits( "KCompletionBox" ) ) ) {
+ QListBox* listbox = (QListBox*) w;
+ listbox->setBackgroundMode( NoBackground );
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+ //if (testWidget) qWarning("testwidget stage %d",testInt++);
+
+
+ if (::qt_cast<QHeader*>(w)){
+// if (::qt_cast<QListView*>(w->parentWidget()))
+// headerSortID = ((QListView*)w->parentWidget())->sortColumn();
+// if (w->parentWidget()) qWarning(w->parentWidget()->className());
+ w->setBackgroundMode( NoBackground );
+ w->installEventFilter( this );
+ goto kstpolish;
+ }
+ //if (testWidget) qWarning("testwidget stage %d",testInt++);
+
+
+ if (::qt_cast<QTabBar*>(w)){
+// qWarning("installing tab event");
+ w->setMouseTracking( true );
+ w->installEventFilter( this );
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ goto kstpolish;
+ }
+
+ if (::qt_cast<QGroupBox*>(w) && ((QGroupBox*)w)->frameShape() == QFrame::GroupBoxPanel && !((QGroupBox*)w)->isFlat())
+ {
+ if ( optionHandler->drawGroupBoxShadow() )
+ {
+ w->setPaletteBackgroundPixmap ( *groupShadow );
+ if (((QGroupBox*)w)->isCheckable())
+ {
+ QWidget *cb = (QWidget*)w->child("qt_groupbox_checkbox",0,false);
+ cb->setPalette(w->parentWidget() ? w->parentWidget()->palette() : qApp->palette());
+ QFont font( cb->font() );
+ font.setBold( true );
+ cb->setFont( font );
+ }
+ }
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ w->installEventFilter(this);
+ }
+ //if (testWidget) qWarning("testwidget stage %d",testInt++);
+
+
+ if (w->inherits("QProgressBar"))
+ {
+ w->setBackgroundMode( NoBackground );
+ w->installEventFilter(this);
+ connect(w, SIGNAL(destroyed(QObject*)), this, SLOT(progressBarDestroyed(QObject*)));
+ goto kstpolish;
+ }
+
+ if ( w->inherits( "QDockWindow" ) ) {
+ w->setBackgroundMode( QWidget::PaletteBackground );
+ w->setBackgroundOrigin(QWidget::WindowOrigin);
+ w->installEventFilter( this );
+ goto kstpolish ;
+ }
+
+ if ( ::qt_cast<QScrollBar*>(w)) {
+ QCursor tmpCursor(Qt::PointingHandCursor);
+ w->setCursor(tmpCursor);
+ w->installEventFilter( this );
+ w->setBackgroundMode( QWidget::NoBackground );
+ goto kstpolish ;
+ }
+ if ( w->inherits( "KdetvView")) {
+ w->setBackgroundMode( QWidget::NoBackground );
+ }
+ //if (testWidget) qWarning("testwidget stage %d",testInt++);
+ kstpolish: KStyle::polish( w ); // nothing of all above? do default kde stuff
+}
+
+
+
+void LiquidStyle::unPolish( QWidget *w ) {
+
+ bool isViewport;
+ bool isViewportChild;
+
+ // general - better than querying for each and ever widget if it got one...
+ w->removeEventFilter( this );
+
+
+ if (w->inherits("KColorGrid")){
+ goto kstunpolish;
+ }
+
+ if ( w->inherits("QToolBar") || qstrcmp( w->name(), "kde toolbar widget" ) == 0 ) {
+ w->setBackgroundOrigin( QWidget::WidgetOrigin );
+// w->unsetPalette();
+ goto kstunpolish;
+ }
+ if ( w->inherits( "QPopupMenu" ) ) {
+ w->unsetPalette();
+ w->setBackgroundMode( QWidget::PaletteButton );
+ w->removeEventFilter( this );
+ XDeleteProperty (qt_xdisplay(), w->winId(), XInternAtom(qt_xdisplay(), OPACITY, False));
+ goto kstunpolish;
+ }
+ if (::qt_cast<QListBox*>(w) && w->isTopLevel()){
+ XDeleteProperty (qt_xdisplay(), w->winId(), XInternAtom(qt_xdisplay(), OPACITY, False));
+ goto kstunpolish;
+ }
+ if ( !isPlain () && w->inherits( "KonqIconViewWidget" ) ||
+ w->inherits( "KHTMLView" ) ) {
+ w->unsetPalette();
+ goto kstunpolish;
+ }
+ if (w->inherits("KateView") || w->inherits("TEWidget") || w->inherits("CHexViewWidget")){
+// w->setMouseTracking( false );
+ goto kstunpolish;
+ }
+
+ if (w->isA( "QViewportWidget" ) || w->inherits( "QClipperWidget" ) )
+ goto kstunpolish;
+
+ if ( !isPlain() ) {
+ if ( w->inherits( "KActiveLabel" ) || w->inherits( "QTipLabel" ) ) {
+ w->unsetPalette();
+ goto kstunpolish;
+ }
+ /*
+ else if(w->inherits("KdmClock")){
+ ; // Check this!
+ return;
+ }*/
+ }
+ else if ( w->inherits( "QMenuBar" ) ) {
+ w->setBackgroundMode( QWidget::PaletteButton );
+ if ( !isPlain() )
+ w->setBackgroundOrigin( QWidget::WidgetOrigin );
+ goto kstunpolish;
+ }else if ( w->inherits( "QDockWindow" ) ) {
+ w->setBackgroundMode( QWidget::PaletteButton );
+ if ( !isPlain() )
+ w->setBackgroundOrigin( QWidget::WidgetOrigin );
+ goto kstunpolish;
+ } else if ( w->inherits( "QComboBox" ) || w->inherits( "QPushButton" ) ) {
+ if (w->inherits( "QPushButton" ))
+ {
+ ButtonFadeInfo *bfi_ = bfi[w->winId()];
+ if (bfi_){
+ if (bfi_->timerId != 0)
+ w->killTimer(bfi_->timerId);
+ bfi.setAutoDelete(TRUE);
+ bfi.remove(w->winId());
+ }
+ }
+ w->setBackgroundMode( QWidget::PaletteButton );
+ } else if ( w->inherits( "QScrollBar" ) ) {
+// if (!w->isEnabled()) w->setEnabled(true);
+ w->setBackgroundMode( QWidget::PaletteBackground );
+ goto kstunpolish;
+ } else if ( w->inherits( "QHeader" ) ) {
+ w->setMouseTracking( false );
+ }
+
+ if ( w->inherits( "QToolButton" ) ) {
+// w->unsetPalette();
+ w->setBackgroundMode( QWidget::PaletteButton );
+ if ( !isPlain() )
+ w->setBackgroundOrigin( QWidget::WidgetOrigin );
+ goto kstunpolish;
+ }
+
+ isViewport = qstrcmp( w->name(), "qt_viewport" ) == 0 ||
+ qstrcmp( w->name(), "qt_clipped_viewport" ) == 0;
+ isViewportChild = w->parent() &&
+ ( ( qstrcmp( w->parent() ->name(), "qt_viewport" ) == 0 ) ||
+ ( qstrcmp( w->parent() ->name(), "qt_clipped_viewport" ) == 0 ) );
+
+ if ( isViewportChild ) {
+ if ( w->inherits( "QRadioButton" ) || w->inherits( "QComboBox" ) || w->inherits( "QPushButton" ) ) {
+ if ( isHTMLWidget( w ) ) {
+ w->setBackgroundMode( QWidget::PaletteBackground );
+ goto kstunpolish;
+ }
+ }
+ }
+
+ if ( !isPlain() ) {
+ if ( !isViewport && w->parent() && qstrcmp( w->parent() ->name(), "proxyview" ) == 0 ) {
+ w->setBackgroundOrigin( QWidget::WidgetOrigin );
+ goto kstunpolish;
+ }
+ if ( w->ownPalette() && !w->inherits( "QButton" ) && !w->inherits( "QComboBox" ) )
+ goto kstunpolish;
+ if ( w->inherits( "PanelButtonBase" ) )
+ goto kstunpolish;
+
+ if ( !isViewport && !isViewportChild && !w->testWFlags( WType_Popup ) &&
+ !w->inherits( "KDesktop" ) && !w->inherits( "PasswordDlg" ) ) {
+
+ if ( w->backgroundOrigin() == QWidget::WindowOrigin )
+ w->setBackgroundOrigin( QWidget::WidgetOrigin );
+ goto kstunpolish;
+ }
+ }
+kstunpolish: KStyle::unPolish( w );
+ }
diff --git a/style/utils.cpp b/style/utils.cpp
new file mode 100644
index 0000000..dd24986
--- /dev/null
+++ b/style/utils.cpp
@@ -0,0 +1,1418 @@
+#include "baghira.h"
+
+#include <qbitmap.h>
+#include <qimage.h>
+#include <qcolor.h>
+#include <qpalette.h>
+#include <qrect.h>
+#include <qpoint.h>
+#include <qapplication.h>
+#include <qpainter.h>
+#include <qpen.h>
+//#include <kwordwrap.h>
+
+
+#include "config.h"
+
+#ifndef CLAMP
+#define CLAMP(x,l,u) x < l ? l :\
+ x > u ? u :\
+ x
+#endif
+
+#define ALPHA_COLOR(A,R,G,B) \
+ destR = ((A * destR) + (255 - A) * R) / 255; \
+ destG = ((A * destG) + (255 - A) * G) / 255; \
+ destB = ((A * destB) + (255 - A) * B) / 255; \
+ A = 255;
+
+#define ALPHA_COLOR2(A1,A2,R,G,B) \
+ destR = ((A1 * destR) + (255 - A1) * R) / 255; \
+ destG = ((A1 * destG) + (255 - A1) * G) / 255; \
+ destB = ((A1 * destB) + (255 - A1) * B) / 255; \
+ A1 = CLAMP(A1 + A2,0,255);
+
+#define DELTA_COLOR(D,R,G,B) \
+ delta = (255 - qRed(D))/2; \
+ destR = R - delta; \
+ destG = G - delta; \
+ destB = B - delta;
+
+#define SATURATION_COLOR(R,G,B) \
+ grey = (299 * R + 587 * G + 114 * B) / 1000; \
+ delta = 255 - grey; \
+ grey = (grey *(10 - 5)) / 10; \
+ iGrey = 255 - grey;\
+ destR = (iGrey * (srcR - delta) + grey * R) / 255; \
+ destG = (iGrey * (srcG - delta) + grey * G) / 255; \
+ destB = (iGrey * (srcB - delta) + grey * B) / 255;
+
+#define SATURATION_COLOR2(S,R,G,B) \
+ int max = 255+(int)(0.65*(100-S)); \
+ destR = CLAMP((srcR + R - 128), 0, max); \
+ destG = CLAMP((srcG + G - 128), 0, max); \
+ destB = CLAMP((srcB + B - 128), 0, max); \
+ destR = (S*destR + (100-S)*R)/100; \
+ destG = (S*destG + (100-S)*G)/100; \
+ destB = (S*destB + (100-S)*B)/100;
+
+#define TINT_WHITE(S,R,G,B) \
+ int max = 255+(int)(0.65*(100-S)); \
+ destR = CLAMP((128 + R), 0, max); \
+ destG = CLAMP((128 + G), 0, max); \
+ destB = CLAMP((128 + B), 0, max); \
+ destR = (S*destR + (100-S)*R)/100; \
+ destG = (S*destG + (100-S)*G)/100; \
+ destB = (S*destB + (100-S)*B)/100;
+
+
+#define SATURATION_COLOR3(S,R,G,B) \
+ destR = (S*(srcR + R - 128)/100 + R)/2; \
+ destG = (S*(srcG + G - 128)/100 + G)/2; \
+ destB = (S*(srcB + B - 128)/100 + B)/2;
+
+#define GM_COLOR(R,G,B)\
+ destR = CLAMP(destR + R - 128, 0, 255);\
+ destG = CLAMP(destG + G - 128, 0, 255);\
+ destB = CLAMP(destB + B - 128, 0, 255);
+
+
+#define COLOR_SPACE(R,G,B) \
+ if ( R < 0 ) R = 0; else if ( R > 255 ) R = 255; \
+ if ( G < 0 ) G = 0; else if ( G > 255 ) G = 255; \
+ if ( B < 0 ) B = 0; else if ( B > 255 ) B = 255;
+
+#ifndef PRINTDEVICE
+#define PRINTDEVICE(_p_) qWarning("device is %s", (_p_->device()->devType() == QInternal::Widget) ?\
+"Widget": (_p_->device()->devType() == QInternal::Pixmap) ?\
+"Pixmap": (_p_->device()->devType() == QInternal::Printer) ?\
+"Printer": (_p_->device()->devType() == QInternal::Picture) ?\
+"Picture": (_p_->device()->devType() == QInternal::UndefinedDevice) ?\
+"UndefinedDevice": "fuckdevice!" );
+#endif
+
+int LiquidStyle::getBrightness(unsigned int rgb) const {
+ int red = qRed( rgb );
+ int green = qGreen( rgb );
+ int blue = qBlue( rgb );
+ int V = red;
+ if (green > V) V = green;
+ if (blue > V) V = blue;
+ return V;
+}
+
+QPixmap* LiquidStyle::adjustHSV( QImage &img, const QColor &c, const QColor *bg ) const
+{
+ QImage * tmp = adjustHSVImage( img, c, bg );
+
+ QPixmap *pix = new QPixmap;
+ pix->convertFromImage( *tmp );
+ delete tmp;
+ return ( pix );
+}
+
+
+ButtonTile* LiquidStyle::createRoundFrameTile(QImage &img, const QColor &color, const QColor *bg, const QColor &baseColor ) const
+{
+ QColor bgColor( bg ? *bg : qApp->palette().active().background() );
+
+ if ( img.depth() != 32 )
+ img = img.convertDepth( 32 );
+ QImage *dest = new QImage( img.width(), img.height(), 32, 0 );
+ dest->setAlphaBuffer( true );
+ unsigned int *data = ( unsigned int * ) img.bits();
+ unsigned int *destData = ( unsigned int* ) dest->bits();
+ int total = img.width() * img.height();
+ int current;
+ int delta;
+ int red, green, blue, grey, iGrey;
+ int destR, destG, destB, alpha;
+ int x,y;
+
+ int srcR = color.red();
+ int srcG = color.green();
+ int srcB = color.blue();
+
+ if (!optionHandler->IcyButtons())
+ {
+ srcR += 20;
+ srcG += 20;
+ srcB += 20;
+ COLOR_SPACE(srcR, srcG, srcB);
+ }
+
+ for ( current = 0 ; current < total ; ++current )
+ {
+ alpha = qAlpha( data[ current ] );
+ if (alpha)
+ {
+ if (optionHandler->IcyButtons())
+ {
+ red = qRed( data[ current ] );
+ green = qGreen( data[ current ] );
+ blue = qBlue( data[ current ] );
+ SATURATION_COLOR(red, green, blue);
+ }
+ else
+ {
+ // the coloring itself
+ DELTA_COLOR(data[ current ], srcR, srcG, srcB);
+ }
+ }
+#if 1
+ if ( alpha && alpha != 255 )
+ {
+ // only on translucent pixels - alphablending
+ y = (int)(current/img.width());
+ x = current - y*img.width();
+ if (red < 180 || x < 2 || y < 2 || y > img.height() - 2 || x > img.width() - 3)
+ {
+ ALPHA_COLOR(alpha, bgColor.red(), bgColor.green(), bgColor.blue());
+ }
+ else
+ {
+ ALPHA_COLOR(alpha, baseColor.red(), baseColor.green(), baseColor.blue());
+ }
+ }
+#endif
+ // force back to valid colorspace !
+ COLOR_SPACE(destR, destG, destB);
+ destData[ current ] = qRgba( destR, destG, destB, alpha );
+ }
+ QPixmap destPix;
+ destPix = *dest;
+ ButtonTile *ret = separateTiles( &destPix, 11, 10, 6, 1, 0, false);
+ delete dest;
+ return ret;
+}
+
+QImage* LiquidStyle::adjustHSVImage( QImage &img, const QColor &c, const QColor *bg ) const
+{
+ QColor bgColor( bg ? *bg : qApp->palette().active().background() );
+
+ if ( img.depth() != 32 )
+ img = img.convertDepth( 32 );
+ QImage *dest = new QImage( img.width(), img.height(), 32, 0 );
+ dest->setAlphaBuffer( true );
+ unsigned int *data = ( unsigned int * ) img.bits();
+ unsigned int *destData = ( unsigned int* ) dest->bits();
+ int total = img.width() * img.height();
+ int current;
+ int delta;
+ int red, green, blue;
+ int destR, destG, destB, alpha;
+
+ int srcR = c.red();
+ int srcG = c.green();
+ int srcB = c.blue();
+
+ int hue, s, v;
+ c.getHsv( &hue, &s, &v );
+ int sq = CLAMP((int)((45.0/128.0)*s+55),0,100);
+
+
+ if (!optionHandler->IcyButtons())
+ {
+ srcR += 20;
+ srcG += 20;
+ srcB += 20;
+ COLOR_SPACE(srcR, srcG, srcB);
+ }
+
+ // float srcPercent, destPercent;
+ for ( current = 0 ; current < total ; ++current )
+ {
+ alpha = qAlpha( data[ current ] );
+ if (optionHandler->IcyButtons())
+ {
+ red = qRed( data[ current ] );
+ green = qGreen( data[ current ] );
+ blue = qBlue( data[ current ] );
+ SATURATION_COLOR2(sq, red, green, blue);
+ }
+ else
+ {
+ // the coloring itself
+ DELTA_COLOR(data[ current ], srcR, srcG, srcB);
+ }
+ // force back to valid colorspace !
+ COLOR_SPACE(destR, destG, destB);
+ destData[ current ] = qRgba( destR, destG, destB, alpha );
+ }
+ return ( dest );
+}
+
+QImage* LiquidStyle::tintBrush( const QImage &img, const QColor &c ) const
+{
+// if ( img.depth() != 32 )
+// img = img.convertDepth( 32 );
+ QImage *dest = new QImage( img.width(), img.height(), 32, 0 );
+ unsigned int *data = ( unsigned int * ) img.bits();
+ unsigned int *destData = ( unsigned int* ) dest->bits();
+ int total = img.width() * img.height();
+ int current;
+ int delta;
+ int red, green, blue, grey, iGrey;
+ int destR, destG, destB, alpha;
+
+ int srcR = c.red();
+ int srcG = c.green();
+ int srcB = c.blue();
+
+ // float srcPercent, destPercent;
+ for ( current = 0 ; current < total ; ++current )
+ {
+ alpha = qAlpha( data[ current ] );
+ blue = qBlue( data[ current ] );
+ red = qRed( data[ current ] );
+ green = qGreen( data[ current ] );
+ SATURATION_COLOR(red, green, blue);
+ // force back to valid colorspace !
+ COLOR_SPACE(destR, destG, destB);
+ destData[ current ] = qRgba( destR, destG, destB, alpha );
+ }
+ return ( dest );
+}
+
+QColor LiquidStyle::brushedMetalColor(QColor &c) const
+{
+ if (optionHandler->TintBrush())
+ {
+ int srcR = c.red();
+ int srcG = c.green();
+ int srcB = c.blue();
+ int destR, destG, destB, grey, iGrey, delta;
+ SATURATION_COLOR(180, 180, 180);
+ COLOR_SPACE(destR, destG, destB);
+ return QColor(destR, destG, destB);
+ }
+ else
+ return QColor (180,180,180);
+}
+
+
+
+
+void LiquidStyle::clearImage( QImage &img ) const
+{
+ int x, y;
+ int w = img.width();
+ int h = img.height();
+ unsigned int pixel = qRgba( 0, 0, 0, 0 );
+ unsigned int *data;
+
+ for ( y = 0 ; y < h ; ++y )
+ for ( data = (unsigned int *) img.scanLine( y ), x = 0 ; x < w ; data[ x++ ] = pixel ) ;
+ // img.fill( pixel );
+}
+
+void LiquidStyle::adjustHSV( QPixmap &pix, const QColor &c ) const
+{
+ QImage img = pix.convertToImage();
+ QPixmap *result = adjustHSV( img, c);
+ pix = *result;
+ delete result;
+}
+
+
+/* buttons are fractioned to 9 parts.
+w, h are width and height of the whole button.
+xOff (yOff) is the distance of the central fraction from left (upper) button side.
+centerW (centerH) is the width (height) of the central button fraction.
+shadowH is the height of the buttons shadow*/
+ButtonTile* LiquidStyle::createButtonTile( const QColor &c,
+ const QColor &bgColor,
+ QImage *buttonImage,
+ QImage *shadowImage,
+ QImage *glowImage,
+ QIntDict<ButtonTile>*buttonDict,
+ QIntDict<ButtonTile>*shadowDict,
+ QIntDict<ButtonTile>*glowDict,
+ int w, int h, int xOff, int yOff,
+ int centerW, int centerH,
+ int shadowH, int glowWH,
+ bool sunken) const
+{
+ int x, y, delta;
+ int red, green, blue;
+ int destR, destG, destB, alpha;
+ bool rect = (buttonDict == &rectBtnDict);
+
+ int hue, s, v;
+ c.getHsv( &hue, &s, &v );
+ int sq = CLAMP((int)((45.0/128.0)*s+55),0,100);
+
+ int srcR = c.red();
+ int srcG = c.green();
+ int srcB = c.blue();
+
+ if (!optionHandler->IcyButtons())
+ {
+ srcR += 20;
+ srcG += 20;
+ srcB += 20;
+
+ COLOR_SPACE(srcR, srcG, srcB);
+ }
+
+ unsigned int *data, *destData;
+ ButtonTile *tile;
+
+ int shadowOverhead;
+ shadowH > glowWH ? shadowOverhead = shadowH - glowWH : shadowOverhead = 0;
+ QImage img( w + 2*glowWH, h + 2*glowWH + shadowOverhead, 32, 0 );
+ img.setAlphaBuffer( !isPlain() || optionHandler->drawGroupBoxShadow() ? true : false);
+ clearImage( img );
+
+ // For unpressed buttons things are a little more complex. First
+ // we color adjust the shadow with the background color then we
+ // adjust the button to the button color. Finally we overlay the
+ // button on the shadow, (in the same loop as color adjusting).
+ // Technically we probably could of gotten away
+ // with just adjusting both the shadow and the button to the button
+ // color since the shadow is quite dark, but this is more correct and
+ // would allow configurable shadow brightness. If the shadow was
+ // just the button color, if someone configured it to be a rather
+ // light brightness, and they had a dark background color it wouldn't
+ // look right if based off the button color.
+ //
+ // Luckily this is only done once when the button is created for any
+ // given color ;-)
+
+ // first do the shadow
+ if ((!sunken || optionHandler->buttonStyle() == Milk) && shadowImage)
+ for ( y = 0 ; y < h + shadowH ; ++y )
+ {
+ data = ( unsigned int * ) shadowImage->scanLine( y );
+ destData = ( unsigned int * ) img.scanLine( y + glowWH ); // glowWH is the yOffset -> distance of visable button to top of complete button
+ if (optionHandler->buttonStyle() == Jaguar) // has brighter shadows...
+ {
+ for ( x = 0 ; x < w ; ++x )
+ if ((alpha = qAlpha( data[ x ] )))
+ {
+ destData[ x + glowWH ] = qRgba( qRed(data[ x ]), qGreen(data[ x ]), qBlue(data[ x ]), alpha >> 1 );
+ }
+ }
+ else
+ {
+ for ( x = 0 ; x < w ; ++x )
+ if ((alpha = qAlpha( data[ x ] )))
+ {
+ destData[ x + glowWH ] = data[x];
+ }
+ }
+ }
+ // ... or the glow
+ else if (glowImage)
+ for ( y = 0 ; y < h + 2*glowWH ; ++y )
+ {
+ data = ( unsigned int * ) glowImage->scanLine( y );
+ destData = ( unsigned int * ) img.scanLine( y );
+ for ( x = 0 ; x < w + 2*glowWH ; ++x )
+ if ((alpha = qAlpha( data[ x ] )))
+ {
+ DELTA_COLOR(data[ x ], srcR, srcG, srcB);
+ COLOR_SPACE(destR, destG, destB);
+ destData[ x ] = qRgba( destR, destG, destB, alpha );
+ }
+ }
+
+ // then the button and overlay
+ for ( y = 0 ; y < h ; ++y )
+ {
+ data = ( unsigned int * ) buttonImage->scanLine( y );
+ destData = ( unsigned int * ) img.scanLine( y + glowWH );
+ for ( x = 0 ; x < w ; ++x )
+ if ((alpha = qAlpha( data[ x ] )))
+ {
+ if (!rect || (y > 1 && y < h-2 && x > 0 && x < w-1) )
+ {
+ if (optionHandler->IcyButtons())
+ {
+ red = qRed( data[ x ] );
+ green = qGreen( data[ x ] );
+ blue = qBlue( data[ x ] );
+ SATURATION_COLOR2(sq, red, green, blue);
+ }
+ else
+ {
+ DELTA_COLOR(data[ x ], srcR, srcG, srcB);
+ }
+ }
+ else
+ {
+ red = qRed( data[ x ] );
+ green = qGreen( data[ x ] );
+ blue = qBlue( data[ x ] );
+ TINT_WHITE(55, red, green, blue);
+ }
+ if (alpha != 255)
+ {
+ if ( qAlpha( destData[ x + glowWH ] ) )
+ {
+ ALPHA_COLOR2(alpha, qAlpha( destData[ x + glowWH ] ), qRed( destData[ x + glowWH ]), qGreen( destData[ x + glowWH ]), qBlue( destData[ x + glowWH ]));
+ }
+ }
+ COLOR_SPACE(destR, destG, destB);
+ destData[ x + glowWH ] = qRgba( destR, destG, destB, alpha );
+ }
+ }
+
+ QPixmap *pix = new QPixmap;
+ pix->convertFromImage( img );
+ tile = separateTiles( pix, xOff+glowWH, yOff+glowWH, centerW, centerH, shadowH, sunken);
+
+ if ( sunken && glowDict)
+ glowDict->insert(c.rgb(),tile);
+ else if (!sunken && shadowDict)
+ shadowDict->insert( c.rgb(), tile );
+ else
+ buttonDict->insert( c.rgb(), tile );
+
+ delete pix;
+ return ( tile );
+}
+
+QPixmap* LiquidStyle::createSliderEnd( const QColor &c, const QColor &bgColor, bool top) const
+{
+
+ int x, y, delta;
+ int red, green, blue;
+ int destR, destG, destB, alpha;
+
+ int h, s, v;
+ c.getHsv( &h, &s, &v );
+ int sq = CLAMP((int)((45.0/128.0)*s+55),0,100);
+
+ int srcR = bgColor.red();
+ int srcG = bgColor.green();
+ int srcB = bgColor.blue();
+
+ unsigned int *data, *destData;
+
+ QImage img( 13, 9, 32, 0 );
+ img.setAlphaBuffer( true ); // we need this always, as the slider groove is nevernever plain!
+ clearImage( img );
+
+ // just stole that from above...
+ // first do the shadow
+ for ( y = 0 ; y < 9 ; ++y ) {
+ top ? data = ( unsigned int * ) slider_top_shd->scanLine( y ) : data = ( unsigned int * ) slider_btm_shd->scanLine( y );
+ destData = ( unsigned int * ) img.scanLine( y );
+ for ( x = 0; x < 13; ++x )
+ if ((alpha = qAlpha( data[ x ] ))) {
+ DELTA_COLOR(data[ x ], bgColor.red(), bgColor.green(), bgColor.blue());
+ COLOR_SPACE(destR, destG, destB);
+ destData[ x ] = qRgba( destR, destG, destB, alpha );
+ }
+ }
+ // then the button and overlay
+
+ srcR = c.red();
+ srcG = c.green();
+ srcB = c.blue();
+
+ if (!optionHandler->IcyButtons()){
+ srcR +=20;
+ srcG += 20;
+ srcB += 20;
+
+ COLOR_SPACE(srcR, srcG, srcB);
+ }
+
+ for ( y = 0 ; y < 7 ; ++y ) {
+ top ? data = ( unsigned int * ) slider_top->scanLine( y ) : data = ( unsigned int * ) slider_btm->scanLine( y );
+ destData = ( unsigned int * ) img.scanLine( top ? y + 2 : y );
+ for ( x = 0 ; x < 13 ; ++x )
+ if ((alpha = qAlpha( data[ x ] ))) {
+ if (optionHandler->IcyButtons()) {
+ red = qRed( data[ x ] );
+ green = qGreen( data[ x] );
+ blue = qBlue( data[ x] );
+ SATURATION_COLOR2(sq, red, green, blue);
+ }
+ else {
+ DELTA_COLOR(data[ x ], srcR, srcG, srcB);
+ }
+ if (alpha != 255) {
+ if ( qAlpha( destData[ x ] ) ) {
+ ALPHA_COLOR2(alpha, qAlpha( destData[ x ]), qRed( destData[ x ]), qGreen( destData[ x ]), qBlue( destData[ x ]));
+ }
+ }
+ COLOR_SPACE(destR, destG, destB);
+ destData[ x ] = qRgba( destR, destG, destB, alpha );
+ }
+ }
+ QPixmap *pix = new QPixmap;
+ pix->convertFromImage( img );
+ return ( pix );
+}
+
+
+
+// 0 / xO / xO + w
+// -------------------------------------
+// | xO | w | width()-xO-w | : yO / 0
+// -------------------------------------
+// | xO | w | width()-xO-w | : h / yO
+// -------------------------------------
+// | xO | w | width()-xO-w | : height()-yO-h / yO+h
+// -------------------------------------
+// Overload of mosfet's original function, takes 6 more parameters to use the funktion on variable bitmaps (mosfet's function does only work for very special bitmaps)
+// by giving position and dimension of the central tile + the shadow height (panther doesn't seem to have a right shadow-offset)
+ButtonTile* LiquidStyle::separateTiles( QPixmap *pix,
+ int xO, int yO, int w, int h,
+ int, bool sunken) const
+{
+ ButtonTile * tile = new ButtonTile();
+ QPixmap *tmp;
+
+ int w1 = xO;
+ int w2 = w;
+ int w3 = pix->width() - xO - w;
+ int h1 = yO;
+ int h2 = h;
+ int h3 = pix->height() - yO - h;
+
+ int xO1 = 0;
+ int xO2 = xO;
+ int xO3 = xO + w;
+ int yO1 = 0;
+ int yO2 = yO;
+ int yO3 = yO + h;
+
+ if ( !sunken ) {
+ // Top tiles
+ tmp = new QPixmap( w1, h1 );
+ // bitBlt(...,x,y,width,height)
+ copyBlt( tmp, 0, 0, pix, xO1, yO1, w1, h1 );
+ tile->setPixmap( TileTopLeft, tmp );
+ tmp = new QPixmap( w2, h1 );
+ copyBlt( tmp, 0, 0, pix, xO2, yO1, w2, h1 );
+ tile->setPixmap( TileTop, tmp );
+ tmp = new QPixmap( w3, h1 );
+ copyBlt( tmp, 0, 0, pix, xO3, yO1, w3, h1 );
+ tile->setPixmap( TileTopRight, tmp );
+
+ // Middle tiles
+ tmp = new QPixmap( w1, h2 );
+ copyBlt( tmp, 0, 0, pix, xO1, yO2, w1, h2 );
+ tile->setPixmap( TileLeft, tmp );
+ tmp = new QPixmap( w2, h2 );
+ copyBlt( tmp, 0, 0, pix, xO2, yO2, w2, h2 );
+ tile->setPixmap( TileMiddle, tmp );
+ tmp = new QPixmap( w3, h2 );
+ copyBlt( tmp, 0, 0, pix, xO3, yO2, w3, h2 );
+ tile->setPixmap( TileRight, tmp );
+
+ // Bottom tiles
+ tmp = new QPixmap( w1, h3 );
+ copyBlt( tmp, 0, 0, pix, xO1, yO3, w1, h3 );
+ tile->setPixmap( TileBtmLeft, tmp );
+ tmp = new QPixmap( w2, h3 );
+ copyBlt( tmp, 0, 0, pix, xO2, yO3, w2, h3 );
+ tile->setPixmap( TileBtm, tmp );
+ tmp = new QPixmap( w3, h3 );
+ copyBlt( tmp, 0, 0, pix, xO3, yO3, w3, h3 );
+ tile->setPixmap( TileBtmRight, tmp );
+
+ }
+ else {
+ // Top tiles
+ tmp = new QPixmap( w1, h3 );
+ // bitBlt(...,x,y,width,height)
+ copyBlt( tmp, 0, 0, pix, xO1, yO1, w1, h3 );
+ tile->setPixmap( TileTopLeft, tmp );
+ tmp = new QPixmap( w2, h3 );
+ copyBlt( tmp, 0, 0, pix, xO2, yO1, w2, h3 );
+ tile->setPixmap( TileTop, tmp );
+ tmp = new QPixmap( w3, h3 );
+ copyBlt( tmp, 0, 0, pix, xO3, yO1, w3, h3 );
+ tile->setPixmap( TileTopRight, tmp );
+
+ // Middle tiles
+ tmp = new QPixmap( w1, h2 );
+ copyBlt( tmp, 0, 0, pix, xO1, yO2 + h3 - h1, w1, h2 );
+ tile->setPixmap( TileLeft, tmp );
+ tmp = new QPixmap( w2, h2 );
+ copyBlt( tmp, 0, 0, pix, xO2, yO2 + h3 - h1, w2, h2 );
+ tile->setPixmap( TileMiddle, tmp );
+ tmp = new QPixmap( w3, h2 );
+ copyBlt( tmp, 0, 0, pix, xO3, yO2 + h3 - h1, w3, h2 );
+ tile->setPixmap( TileRight, tmp );
+
+ // Bottom tiles
+ tmp = new QPixmap( w1, h1 );
+ copyBlt( tmp, 0, 0, pix, xO1, yO3 + h3 - h1, w1, h1 );
+ tile->setPixmap( TileBtmLeft, tmp );
+ tmp = new QPixmap( w2, h1 );
+ copyBlt( tmp, 0, 0, pix, xO2, yO3 + h3 - h1, w2, h1 );
+ tile->setPixmap( TileBtm, tmp );
+ tmp = new QPixmap( w3, h1 );
+ copyBlt( tmp, 0, 0, pix, xO3, yO3 + h3 - h1, w3, h1 );
+ tile->setPixmap( TileBtmRight, tmp );
+ }
+ return ( tile );
+}
+
+#define _LOFF_ tile->pixmap( TileLeft )->width()
+#define _ROFF_ tile->pixmap( TileRight )->width()
+#define _TOFF_ tile->pixmap( TileTop )->height()
+#define _BOFF_ tile->pixmap( TileBtm )->height()
+#define _MWIDTH_ tile->pixmap( TileMiddle )->width()
+#define _MHEIGHT_ tile->pixmap( TileMiddle )->height()
+#define _LRWIDTH_ (_LOFF_ + _ROFF_)
+#define _TBHEIGHT_ (_TOFF_ + _BOFF_)
+
+void LiquidStyle::drawRoundButton( QPainter *painter, const QColorGroup &cg, const QColor &c, int x, int y, int w, int h, bool pushedDown, bool hover, int bgX, int bgY ) const
+{
+
+ QColor myC =(isOOO && (hover || pushedDown))?optionHandler->CustomButtonColor():c;
+ LiquidStyle *ptr = const_cast<LiquidStyle*>( this );
+ ButtonTile *tile = pushedDown ? btnDict.find( myC.rgb() ) : btnShadowedDict.find( myC.rgb() );
+
+ if ( !tile )
+ {
+ tile = createButtonTile( myC, qApp->palette().color(QPalette::Active, QColorGroup::Background), ptr->btnBorderImg, ptr->btnShadowImg, ptr->buttonGlow, &(ptr->btnDict), &(ptr->btnShadowedDict), &(ptr->buttonGlowDict), 37, 21, 10, 11, 17, 1, 2, 2, pushedDown);
+ }
+
+ if ( !tile )
+ {
+ qWarning( "Button tile is NULL!" );
+ return ;
+ }
+
+ QPainter *p;
+ QPen oldPen = painter->pen();
+ if (!isHTMLButton)
+ {
+ if ( !tmpBtnPix )
+ ptr->tmpBtnPix = new QPixmap( w, h );
+ else if ( w > tmpBtnPix->width() || h > tmpBtnPix->height() )
+ {
+ // make temp pixmap size == largest button
+ ptr->tmpBtnPix->resize(w,h);
+ }
+ p = new QPainter(tmpBtnPix);
+
+ if (!isPlain())
+ {
+ QPixmap *stipple;
+ if (paintWidget && paintWidget->parentWidget())
+ {
+ stipple = const_cast<QPixmap*>(paintWidget->parentWidget()->palette().brush(QPalette::Active, QColorGroup::Background).pixmap());
+ if (!stipple || stipple->isNull())
+ p->fillRect(0,0,w,h, paintWidget->parentWidget()->palette().brush(QPalette::Active, QColorGroup::Background) );
+ else
+ p->drawTiledPixmap( 0, 0, w, h, *stipple, bgX, bgY );
+ }
+ else
+ {
+ stipple = cg.brush( QColorGroup::Background ).pixmap();
+ stipple ? p->drawTiledPixmap( 0, 0, w, h, *stipple, bgX, bgY ) :
+ p->fillRect(0,0,w,h, cg.brush( QColorGroup::Background ));
+ }
+ }
+ else
+ p->fillRect(0,0,w,h, cg.brush( QColorGroup::Background ));
+ }
+ else
+ {
+ p = painter;
+ }
+
+// QPainter p(tmpBtnPix);
+
+ // tiled fills
+ if ( w > _LRWIDTH_ )
+ {
+ p->drawTiledPixmap( _LOFF_, 0, w - _LRWIDTH_, _TOFF_, *tile->pixmap( TileTop ) );
+ p->drawTiledPixmap( _LOFF_, h - _BOFF_, w - _LRWIDTH_, _BOFF_, *tile->pixmap( TileBtm ) );
+ }
+ if ( h > _TBHEIGHT_ )
+ {
+ p->drawTiledPixmap( 0, _TOFF_, _LOFF_, h - _TBHEIGHT_, *tile->pixmap( TileLeft ) );
+ p->drawTiledPixmap( w - _ROFF_, _TOFF_, _ROFF_, h - _TBHEIGHT_, *tile->pixmap( TileRight ) );
+ }
+ if ( w > _LRWIDTH_ && h > _TBHEIGHT_ )
+ p->drawTiledPixmap( _LOFF_, _TOFF_, w - _LRWIDTH_, h - _TBHEIGHT_, *tile->pixmap( TileMiddle ) );
+ // corners
+ p->drawPixmap( 0, 0, *tile->pixmap( TileTopLeft ) );
+ p->drawPixmap( w - _ROFF_, 0, *tile->pixmap( TileTopRight ) );
+ p->drawPixmap( 0, h - _BOFF_, *tile->pixmap( TileBtmLeft ) );
+ p->drawPixmap( w - _ROFF_, h - _BOFF_, *tile->pixmap( TileBtmRight ) );
+
+ if (!isHTMLButton)
+ {
+ p->end();
+ delete p;
+ painter->drawPixmap( x, y, *tmpBtnPix, 0, 0, w, h );
+ }
+ else
+ p->setPen(oldPen);
+}
+
+
+void LiquidStyle::drawRectangularButton( QPainter *painter,
+ const QColorGroup &cg, const QColor &c,
+ int x, int y, int w, int h,
+ bool sunken, bool hover, bool isCombo, int position, bool isHTML) const
+{
+#define _HEIGHT_ ptr->rectbutton->height()
+#define _WIDTH_ ptr->rectbutton->width()
+ LiquidStyle *ptr = const_cast<LiquidStyle*>( this );
+
+ QColor tmpColor;
+ tmpColor = isCombo && !(hover || sunken) ? optionHandler->InactiveButtonColor() : c;
+
+ int xOffset, width;
+ int cw = 0;
+
+ ButtonTile *tile = rectBtnDict.find( tmpColor.rgb() );
+ if ( !tile )
+ tile = createButtonTile( tmpColor, cg.background(), ptr->rectbutton, ((QImage*)0L), ((QImage*)0L), &(ptr->rectBtnDict), (QIntDict<ButtonTile>*)0L, (QIntDict<ButtonTile>*)0L, 33, 25, 10, 5, 13, 15, 0, 0, sunken);
+
+ if ( !tile )
+ {
+ qWarning( "Button tile is NULL!" );
+ return ;
+ }
+
+ switch (position)
+ {
+ case left:
+ xOffset = _LOFF_;
+ width = w - _LOFF_;
+ cw = 24;
+ break;
+ case center:
+ xOffset = 0;
+ width = w;
+ cw = 24;
+ break;
+ case right:
+ xOffset = 0;
+ width = w - _ROFF_;
+ cw = 24-_ROFF_;
+ break;
+ case full:
+ xOffset = _LOFF_;
+ width = w - _LRWIDTH_;
+ cw = 24-_ROFF_;
+ break;
+ }
+
+ QPainter *p;
+ QPen oldPen = painter->pen();
+ if (!isHTML)
+ {
+ if ( !tmpBtnPix )
+ ptr->tmpBtnPix = new QPixmap( w, h );
+ else if ( w > tmpBtnPix->width() || h > tmpBtnPix->height() )
+ {
+ // make temp pixmap size == largest button
+ ptr->tmpBtnPix->resize(w,h);
+ }
+ p = new QPainter(tmpBtnPix);
+
+ if (position != center && paintWidget && paintWidget->parentWidget())
+ {
+ if (this->paintWidget->parentWidget()->paletteBackgroundPixmap ())
+ p->drawTiledPixmap(QRect(0, 0, w, h), *this->paintWidget->parentWidget()->paletteBackgroundPixmap(), ((QWidget *)this->paintWidget)->backgroundOffset());
+ else
+ p->fillRect( 0, 0, w, h, this->paintWidget->parentWidget()->paletteBackgroundColor());
+ }
+ else
+ p->fillRect( 0, 0, w, h, cg.background() );
+ }
+ else
+ {
+ p = painter;
+ }
+
+ int tileH = 0;
+ QPixmap tmpPix(_LOFF_, 1);
+
+ if (position == left || position == full)
+ {
+ p->drawPixmap( 0, 0, *tile->pixmap( TileTopLeft ) );
+ p->drawPixmap( 0, h - _BOFF_, *tile->pixmap( TileBtmLeft ) );
+ }
+
+ if (!isCombo || hover || sunken)
+ {
+ if ( w > _LRWIDTH_ )
+ {
+ p->drawTiledPixmap( xOffset, 0, width, _TOFF_, *tile->pixmap( TileTop ) );
+ p->drawTiledPixmap( xOffset, h - _BOFF_, width, _BOFF_, *tile->pixmap( TileBtm ) );
+ }
+
+ if ( h > _TBHEIGHT_ )
+ {
+ tileH = (int)((h-_HEIGHT_)/2);
+ if (position == left || position == full)
+ {
+ if (h > _HEIGHT_)
+ {
+ p->drawPixmap(0, _TOFF_+tileH, *tile->pixmap( TileLeft ));
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileLeft), 0, 0, _LOFF_, 1 );
+ p->drawTiledPixmap(0, _TOFF_, _LOFF_, tileH, tmpPix);
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileLeft), 0, _MHEIGHT_-1, _LOFF_, 1 );
+ p->drawTiledPixmap(0, _TOFF_+tileH+_MHEIGHT_, _LOFF_, h-_HEIGHT_-tileH, tmpPix);
+ }
+ else //tileH is negative in this case
+ p->drawPixmap( 0, _TOFF_, *tile->pixmap( TileLeft ), 0, -tileH, _LOFF_, _MHEIGHT_+2*tileH+1);
+ }
+ if (position == right || position == full)
+ {
+ if (h > _HEIGHT_)
+ {
+ tmpPix.resize(_ROFF_, 1);
+ p->drawPixmap(w-_ROFF_, _TOFF_+tileH, *tile->pixmap( TileRight ));
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileRight), 0, 0, _ROFF_, 1 );
+ p->drawTiledPixmap(w-_ROFF_, _TOFF_, _ROFF_, tileH, tmpPix);
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileRight), 0, _MHEIGHT_-1, _ROFF_, 1 );
+ p->drawTiledPixmap(w-_ROFF_, _TOFF_+tileH+_MHEIGHT_, _ROFF_, h-_HEIGHT_-tileH, tmpPix);
+ }
+ else
+ p->drawPixmap( w-_ROFF_, _TOFF_, *tile->pixmap(TileRight), 0, -tileH, _ROFF_, _MHEIGHT_+2*tileH+1 /*tileH is negative in this case*/ );
+ }
+ }
+
+
+ if ( w > _LRWIDTH_ && h > _TBHEIGHT_ )
+ {
+ if (h > _HEIGHT_)
+ {
+ tmpPix.resize(_MWIDTH_, 1);
+ p->drawTiledPixmap(xOffset, _TOFF_+tileH, width, _MHEIGHT_, *tile->pixmap(TileMiddle));
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileMiddle), 0, 0, _MWIDTH_, 1 );
+ p->drawTiledPixmap(xOffset, _TOFF_, width, tileH, tmpPix);
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileMiddle), 0, _MHEIGHT_-1, _MWIDTH_, 1 );
+ p->drawTiledPixmap(xOffset, _TOFF_+tileH+_MHEIGHT_, width, h-_HEIGHT_-tileH, tmpPix);
+ }
+ else //tileH is negative in this case
+ p->drawTiledPixmap( xOffset, _TOFF_, width, h-_TBHEIGHT_, *tile->pixmap(TileMiddle), 0, -tileH);
+ }
+
+
+ if (position == right || position == full)
+ {
+ p->drawPixmap( w - _ROFF_, 0, *tile->pixmap( TileTopRight ) );
+ p->drawPixmap( w - _ROFF_, h - _BOFF_, *tile->pixmap( TileBtmRight ) );
+ }
+
+ }
+ else // split combo...
+ {
+ if ( w > _LRWIDTH_ )
+ {
+ p->drawTiledPixmap( xOffset, 0, width-(24-_ROFF_), _TOFF_, *tile->pixmap( TileTop ) );
+ p->drawTiledPixmap( xOffset, h - _BOFF_, width-(24-_ROFF_), _BOFF_, *tile->pixmap( TileBtm ) );
+ }
+ if ( h > _TBHEIGHT_)
+ {
+ tileH = (int)((h-_HEIGHT_)/2);
+ if (position == left || position == full)
+ {
+ if (h > _HEIGHT_)
+ {
+ tmpPix.resize(_LOFF_, 1);
+ p->drawPixmap(0, _TOFF_+tileH, *tile->pixmap( TileLeft ));
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileLeft), 0, 0, _LOFF_, 1 );
+ p->drawTiledPixmap(0, _TOFF_, _LOFF_, tileH, tmpPix);
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileLeft), 0, _MHEIGHT_-1, _LOFF_, 1 );
+ p->drawTiledPixmap(0, _TOFF_+tileH+_MHEIGHT_, _LOFF_, h-_HEIGHT_-tileH, tmpPix);
+ }
+ else //tileH is negative in this case
+ p->drawPixmap( 0, _TOFF_, *tile->pixmap( TileLeft ), 0, -tileH, _LOFF_, _MHEIGHT_+2*tileH+1);
+ }
+ }
+ if ( w > _LRWIDTH_ && h > _TBHEIGHT_ )
+ {
+ if (h > _HEIGHT_)
+ {
+ tmpPix.resize(_MWIDTH_, 1);
+ p->drawTiledPixmap(xOffset, _TOFF_+tileH, width-(24-_ROFF_), _MHEIGHT_, *tile->pixmap(TileMiddle));
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileMiddle), 0, 0, _MWIDTH_, 1 );
+ p->drawTiledPixmap(xOffset, _TOFF_, width-(24-_ROFF_), tileH, tmpPix);
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileMiddle), 0, _MHEIGHT_-1, _MWIDTH_, 1 );
+ p->drawTiledPixmap(xOffset, _TOFF_+tileH+_MHEIGHT_, width-(24-_ROFF_), h-_HEIGHT_-tileH, tmpPix);
+ }
+ else //tileH is negative in this case
+ p->drawTiledPixmap( xOffset, _TOFF_, width-(24-_ROFF_), h-_TBHEIGHT_, *tile->pixmap(TileMiddle), 0, -tileH);
+ }
+
+ // second part of combos if needed
+ tile = rectBtnDict.find( c.rgb() );
+ if ( !tile )
+ tile = createButtonTile( c, cg.background(), ptr->rectbutton, ((QImage*)0L), ((QImage*)0L), &(ptr->rectBtnDict), (QIntDict<ButtonTile>*)0L, (QIntDict<ButtonTile>*)0L, 33, 25, 10, 5, 13, 15, 0, 0, sunken);
+ if ( !tile )
+ {
+ qWarning( "Button tile is NULL!" );
+ return ;
+ }
+
+ if ( w > _LRWIDTH_ )
+ {
+ p->drawTiledPixmap( w-24, 0, cw, _TOFF_, *tile->pixmap( TileTop ) );
+ p->drawTiledPixmap( w-24, h - _BOFF_, cw, _BOFF_, *tile->pixmap( TileBtm ) );
+ }
+
+ tileH = (int)((h-_HEIGHT_)/2);
+ if (position == right || position == full)
+ {
+ if (h > _HEIGHT_)
+ {
+ tileH = (int)((h-_HEIGHT_)/2);
+ tmpPix.resize(_ROFF_, 1);
+ p->drawPixmap(w-_ROFF_, _TOFF_+tileH, *tile->pixmap( TileRight ));
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileRight), 0, 0, _ROFF_, 1 );
+ p->drawTiledPixmap(w-_ROFF_, _TOFF_, _ROFF_, tileH, tmpPix);
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileRight), 0, _MHEIGHT_-1, _ROFF_, 1 );
+ p->drawTiledPixmap(w-_ROFF_, _TOFF_+tileH+_MHEIGHT_, _ROFF_, h-_HEIGHT_-tileH, tmpPix);
+ }
+ else if ( h > _TBHEIGHT_)//tileH is negative in this case
+ {
+ tileH = (int)((h-_HEIGHT_)/2);
+ p->drawPixmap( w-_ROFF_, _TOFF_, *tile->pixmap( TileRight ), 0, -tileH, _ROFF_, _MHEIGHT_+2*tileH+1);
+ }
+ p->drawPixmap( w - _ROFF_, 0, *tile->pixmap( TileTopRight ) );
+ p->drawPixmap( w - _ROFF_, h - _BOFF_, *tile->pixmap( TileBtmRight ) );
+ }
+
+ if ( w > _LRWIDTH_ && h > _TBHEIGHT_ )
+ {
+ if (h > _HEIGHT_)
+ {
+ tmpPix.resize(_MWIDTH_, 1);
+ p->drawTiledPixmap(w-24, _TOFF_+tileH, cw, _MHEIGHT_, *tile->pixmap(TileMiddle));
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileMiddle), 0, 0, _MWIDTH_, 1 );
+ p->drawTiledPixmap(w-24, _TOFF_, cw, tileH, tmpPix);
+ copyBlt( &tmpPix, 0, 0, tile->pixmap(TileMiddle), 0, _MHEIGHT_-1, _MWIDTH_, 1 );
+ p->drawTiledPixmap(w-24, _TOFF_+tileH+_MHEIGHT_, cw, h-_HEIGHT_-tileH, tmpPix);
+ }
+ else //tileH is negative in this case
+ p->drawTiledPixmap( w-24, _TOFF_, cw, h-_TBHEIGHT_, *tile->pixmap(TileMiddle), 0, -tileH);
+ }
+ }
+ if (position == center)
+ {
+ p->setPen(c.dark(130));
+ if (sunken || hover) p->drawLine(0,1,0,h-2);
+ p->drawLine(w-1,2,w-1,h-2);
+ }
+ else if (position == left)
+ {
+ p->setPen(c.dark(130));
+ p->drawLine(w-1,2,w-1,h-2);
+ }
+ else if (position == right && (sunken || hover))
+ {
+ p->setPen(c.dark(130));
+ p->drawLine(0,2,0,h-2);
+ }
+ if (isCombo)
+ {
+ p->setPen(c);
+ p->drawLine(w-24,2,w-24,h-2);
+
+ int ax = w - 15;
+ int ay = h/3 - 1;
+
+ p->setPen(cg.text());
+ p->setBrush( cg.text() );
+ p->drawPixmap(ax, ay-1, *sbUp, 1, 0, 5, 4);
+ p->drawPixmap(ax, ay+6, *sbDown, 1, 2, 5, 4);
+ }
+ if (!isHTML)
+ {
+ p->end();
+ delete p;
+ painter->drawPixmap( x, y, *tmpBtnPix, 0, 0, w, h );
+ }
+ else
+ p->setPen(oldPen);
+#undef _HEIGHT_
+#undef _WIDTH_
+}
+
+
+void LiquidStyle::drawCombo( QPainter *painter,
+ const QColorGroup &cg,
+ const QColor &c,
+ int x, int y, int w, int h,
+ bool sunken, bool hover, bool isCombo,
+ int position, bool isHTML ) const
+{
+
+ LiquidStyle *ptr = const_cast<LiquidStyle*>( this );
+
+ QColor myC =(isOOO && isCombo)?optionHandler->CustomButtonColor():c;
+ QColor tmpColor = isCombo && !(hover || sunken) ? optionHandler->InactiveButtonColor() : myC;
+
+ ButtonTile *tile = sunken ? comboDict.find( tmpColor.rgb() ) : comboShadowedDict.find( tmpColor.rgb() );
+ if ( !tile )
+ {
+ if (optionHandler->buttonStyle() == Milk && sunken)
+ tile = createButtonTile( tmpColor, cg.background(), ptr->btnBorderImg, ptr->comboShadow, ((QImage*)0L), &(ptr->comboDict), &(ptr->comboShadowedDict), (QIntDict<ButtonTile>*)0L, 44, 21, 7, 9, 30, 1, 2, 0, true);
+ else
+ tile = createButtonTile( tmpColor, cg.background(), ptr->combo, ptr->comboShadow, ((QImage*)0L), &(ptr->comboDict), &(ptr->comboShadowedDict), (QIntDict<ButtonTile>*)0L, 44, 21, 7, 9, 30, 1, 2, 0, sunken);
+ }
+
+ if ( !tile )
+ {
+ qWarning( "Button tile is NULL!" );
+ return ;
+ }
+
+ int xOffset, width, cw;
+
+ switch (position)
+ {
+ case full:
+ xOffset = _LOFF_;
+ width = w - _LRWIDTH_;
+ cw = 24 - _ROFF_;
+ break;
+ case left:
+ xOffset = _LOFF_;
+ width = w - _LOFF_;
+ cw = 24;
+ break;
+ case center:
+ xOffset = 0;
+ width = w;
+ cw = 24;
+ break;
+ case right:
+ xOffset = 0;
+ width = w - _ROFF_;
+ cw = 24 - _ROFF_;
+ break;
+ }
+
+ QPainter *p;
+ QPen oldPen = painter->pen();
+ if (!isHTML)
+ {
+ if ( !tmpBtnPix )
+ ptr->tmpBtnPix = new QPixmap( w, h );
+ else if ( w > tmpBtnPix->width() || h > tmpBtnPix->height() )
+ {
+ // make temp pixmap size == largest button
+ ptr->tmpBtnPix->resize(w,h);
+ }
+ p = new QPainter(tmpBtnPix);
+
+#if 0
+ QPixmap *stipple = cg.brush( QColorGroup::Background ).pixmap();
+ if ( !stipple ) // button may have custom colorgroup
+ stipple = qApp->palette().active().brush( QColorGroup::Background ).pixmap();
+ if ( stipple )
+ p->drawTiledPixmap( 0, 0, w, h, *stipple);
+ else
+ p->fillRect( 0, 0, w, h, cg.background() );
+#endif
+ if (position != center && paintWidget && paintWidget->parentWidget())
+ {
+ if (this->paintWidget->parentWidget()->paletteBackgroundPixmap ())
+ p->drawTiledPixmap(QRect(0, 0, w, h), *this->paintWidget->parentWidget()->paletteBackgroundPixmap(), ((QWidget *)this->paintWidget)->backgroundOffset());
+ else
+ p->fillRect( 0, 0, w, h, this->paintWidget->parentWidget()->paletteBackgroundColor());
+ }
+ else
+ p->fillRect( 0, 0, w, h, cg.background() );
+ }
+ else
+ {
+ p = painter;
+ }
+
+ if (position == left || position == full)
+ {
+ p->drawPixmap( 0, 0, *tile->pixmap( TileTopLeft ) );
+ p->drawPixmap( 0, h - _BOFF_, *tile->pixmap( TileBtmLeft ) );
+ }
+
+ if (!isCombo || hover || sunken)
+ {
+ if ( w > _LRWIDTH_ )
+ {
+ p->drawTiledPixmap( xOffset, 0, width, _TOFF_, *tile->pixmap( TileTop ) );
+ p->drawTiledPixmap( xOffset, h - _BOFF_, width, _BOFF_, *tile->pixmap( TileBtm ) );
+ }
+ if ( h > _TBHEIGHT_ )
+ {
+ if (position == left || position == full)
+ p->drawTiledPixmap( 0, _TOFF_, _LOFF_, h - _TBHEIGHT_, *tile->pixmap( TileLeft ) );
+ if (position == right || position == full)
+ p->drawTiledPixmap( w - _ROFF_, _TOFF_, _ROFF_, h - _TBHEIGHT_, *tile->pixmap( TileRight ) );
+ }
+ if ( w > _LRWIDTH_ && h > _TBHEIGHT_ )
+ p->drawTiledPixmap( xOffset, _TOFF_, width, h - _TBHEIGHT_, *tile->pixmap( TileMiddle ) );
+ if (position == right || position == full)
+ {
+ p->drawPixmap( w - _ROFF_, 0, *tile->pixmap( TileTopRight ) );
+ p->drawPixmap( w - _ROFF_, h - _BOFF_, *tile->pixmap( TileBtmRight ) );
+ }
+ }
+ else // split combo...
+ {
+ if ( w > _LRWIDTH_ )
+ {
+ p->drawTiledPixmap( xOffset, 0, width-(24 - _ROFF_), _TOFF_, *tile->pixmap( TileTop ) );
+ p->drawTiledPixmap( xOffset, h - _BOFF_, width-(24 - _ROFF_), _BOFF_, *tile->pixmap( TileBtm ) );
+ }
+ if ( h > _TBHEIGHT_ && (position == left || position == full))
+ p->drawTiledPixmap( 0, _TOFF_, _LOFF_, h - _TBHEIGHT_, *tile->pixmap( TileLeft ) );
+ if ( w > _LRWIDTH_ && h > _TBHEIGHT_ )
+ p->drawTiledPixmap( xOffset, _TOFF_, width-(24 - _ROFF_), h - _TBHEIGHT_, *tile->pixmap( TileMiddle ) );
+
+ // second part of combos if needed
+ tile = comboShadowedDict.find( myC.rgb() );
+ if ( !tile )
+ {
+ tile = createButtonTile( myC, cg.background(), ptr->combo, ptr->comboShadow, ((QImage*)0L), &(ptr->comboDict), &(ptr->comboShadowedDict), (QIntDict<ButtonTile>*)0L, 44, 21, 7, 9, 30, 1, 2, 0, sunken);
+ }
+ if ( !tile )
+ {
+ qWarning( "Button tile is NULL!" );
+ return ;
+ }
+ if ( w > _LRWIDTH_ )
+ {
+ p->drawTiledPixmap( w-24, 0, cw, _TOFF_, *tile->pixmap( TileTop ) );
+ p->drawTiledPixmap( w-24, h - _BOFF_, cw, _BOFF_, *tile->pixmap( TileBtm ) );
+ }
+ if ( h > _TBHEIGHT_ )
+ p->drawTiledPixmap( w - _ROFF_, _TOFF_, _ROFF_, h - _TBHEIGHT_, *tile->pixmap( TileRight ) );
+ if ( w > _LRWIDTH_ && h > _TBHEIGHT_ )
+ p->drawTiledPixmap( w-24, _TOFF_, cw, h - _TBHEIGHT_, *tile->pixmap( TileMiddle ) );
+ if (position == right || position == full)
+ {
+ p->drawPixmap( w - _ROFF_, 0, *tile->pixmap( TileTopRight ) );
+ p->drawPixmap( w - _ROFF_, h - _BOFF_, *tile->pixmap( TileBtmRight ) );
+ }
+ }
+
+ switch (position)
+ {
+ case left:
+ p->setPen(optionHandler->InactiveButtonColor().dark(130));
+ p->drawLine(w-1,3,w-1,h-6);
+ break;
+ case center:
+ p->setPen(optionHandler->InactiveButtonColor().dark(130));
+ if (sunken || hover) p->drawLine(0,3,0,h-6);
+ p->drawLine(w-1,3,w-1,h-6);
+ break;
+ case right:
+ if (sunken || hover)
+ {
+ p->setPen(optionHandler->InactiveButtonColor().dark(130));
+ p->drawLine(0,3,0,h-6);
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (isCombo)
+ {
+ p->setPen(c);
+ p->drawLine(w-24,1,w-24,h-4);
+
+ int ax = w - 15;
+ int ay = h/3 - 1;
+
+ p->setPen(cg.text());
+ p->setBrush( cg.text() );
+ p->drawPixmap(ax, ay-1, *sbUp, 1, 0, 5, 4);
+ p->drawPixmap(ax, ay+6, *sbDown, 1, 2, 5, 4);
+ }
+
+ if (!isHTML)
+ {
+ p->end();
+ delete p;
+ painter->drawPixmap( x, y, *tmpBtnPix, 0, 0, w, h );
+ }
+ else
+ p->setPen(oldPen);
+}
+
+void LiquidStyle::drawRoundFrame( QPainter *p, const QRect &r,
+ const QColorGroup &cg, bool focused, QPoint offset ) const
+{
+ ButtonTile *tile = focused ? activeRoundFrame : inactiveRoundFrame;
+ if (!tile) tile = createRoundFrameTile(*roundFrame, focused ? cg.button() : optionHandler->InactiveButtonColor(), &cg.background(), cg.base() );
+
+ // first: fill background (tiled)
+ // outer
+ QPixmap *stipple = cg.brush( QColorGroup::Background ).pixmap();
+ if (stipple)
+ {
+ p->drawTiledPixmap( r.x(),r.y(), 7, 8, *stipple, offset.x(), offset.y());
+ p->drawTiledPixmap( r.right() - 7, r.y(), 8, 8, *stipple, offset.x()+r.width()-6, offset.y());
+ p->drawTiledPixmap( r.x(), r.bottom()-7, 8, 8, *stipple, offset.x(), offset.y() + r.height()-6);
+ p->drawTiledPixmap( r.right() - 7, r.bottom()-7, 8, 8, *stipple, offset.x() + r.width() - 6, offset.y() + r.height()-6);
+ }
+ else
+ {
+ p->fillRect(r.x(),r.y(), 7, 8, cg.background());
+ p->fillRect(r.right() - 7, r.y(), 8, 8, cg.background());
+ p->fillRect(r.x(), r.bottom()-7, 8, 8, cg.background());
+ p->fillRect(r.right() - 7, r.bottom()-7, 8, 8, cg.background());
+ }
+ // inner
+ p->fillRect(r.x()+3,r.y()+4,r.width()-6,r.height()-7,cg.base());
+
+ // now draw frame
+ p->drawPixmap(0,0, *tile->pixmap( TileTopLeft ));
+ p->drawPixmap(r.right()-10,0, *tile->pixmap( TileTopRight ));
+ p->drawPixmap(0,r.bottom()-10, *tile->pixmap( TileBtmLeft ));
+ p->drawPixmap(r.right()-10,r.bottom()-10, *tile->pixmap( TileBtmRight ));
+ if (r.width() > 22)
+ {
+ p->drawTiledPixmap(11,0,r.width()-22,10, *tile->pixmap( TileTop ));
+ p->drawTiledPixmap(11,r.bottom()-10,r.width()-22,11, *tile->pixmap( TileBtm ));
+ }
+ if (r.height() > 21)
+ {
+ p->drawTiledPixmap(0,10,11,r.height()-21, *tile->pixmap( TileLeft ));
+ p->drawTiledPixmap(r.right()-10,10,11,r.height()-21, *tile->pixmap( TileRight ));
+ }
+ if (focused)
+ {
+ p->setPen(cg.button());
+ p->drawLine(r.x()+8,r.bottom()-1,r.right()-8,r.bottom()-1);
+ }
+}
+
+void LiquidStyle::drawEditFrame( QPainter *p, const QRect &r,
+ const QColorGroup &cg, bool isHTML, bool focused, bool inverse ) const
+{
+ QColor fill( cg.background().dark( 105 ) );
+ QColor tmp(0,0,0);
+ QColor light1( 0, 0, 0 );
+ QColor light2( 0, 0, 0 );
+
+ QColor dark1( 0, 0, 0 );
+ QColor dark2( 0, 0, 0 );
+ QColor dark3( 0, 0, 0 );
+
+ if ( !focused )
+ {
+ if (optionHandler->style() == Brushed)
+ {
+ light1 = cg.background().light( 140 );
+ light2 = cg.background().light( 120 );
+ }
+ else
+ {
+ light1 = cg.background().dark( 115 );
+ light2 = cg.background().dark( 120 );
+ }
+
+ dark1 = cg.background().dark( 140 );
+ dark2 = cg.background().dark( 160 );
+ dark3 = cg.background().dark( 200 );
+ }
+ else
+ {
+ int h,s,v;
+ cg.button().getHsv( &h, &s, &v );
+ tmp.setHsv(h, (int)(s/1.5) ,v);
+ light1 = tmp;
+ light2 = tmp.light( 120 );
+
+ dark1 = tmp.dark( 110 );
+ dark2 = tmp.dark( 120 );
+ dark3 = tmp.dark( 140 );
+ }
+
+ int x = r.x();
+ int y = inverse ? r.bottom() - 1: r.y();
+ int right = r.right();
+ int bottom = inverse ? r.y() + 1 : r.bottom();
+
+ if ( !isHTML )
+ {
+ p->setPen( fill );
+ p->drawPoint( x, y );
+ p->drawPoint( x, bottom );
+ p->drawPoint( right, y );
+ p->drawPoint( right, bottom );
+
+ // outer rect
+ // top
+ p->setPen( light1 );
+ p->drawPoint( x + 1, y );
+ p->drawPoint( right - 1, y );
+ p->drawPoint( x, y + 1 );
+ p->drawPoint( right, y + 1 );
+ // bottom
+ p->drawPoint( x, bottom - 1 );
+ p->drawPoint( right, bottom - 1 );
+ p->drawPoint( x + 1, bottom );
+ p->drawPoint( right - 1, bottom );
+ // top
+ focused ? p->setPen( light2 ) : p->setPen( dark1 );
+ p->drawLine( x + 2, y, right - 2, y );
+ // bottom, left and right
+ if (!focused) p->setPen( light2 );
+ p->drawLine( x, y + 2, x, bottom - 2 );
+ p->drawLine( right, y + 2, right, bottom - 2 );
+ if (!focused) p->setPen( light1 );
+ p->drawLine( x + 2, bottom, right - 2, bottom );
+ }
+ else
+ {
+ p->setPen( light2 );
+ p->drawLine( x, y, right, y );
+ p->drawLine( x, y, x, bottom );
+ p->setPen( dark1 );
+ p->drawLine( x, bottom, right, bottom );
+ p->drawLine( right, y, right, bottom );
+ }
+ // inner rect
+ p->setPen( dark1 );
+ p->drawPoint( x + 1, y + 1 );
+ p->drawPoint( x + 1, bottom - 1 );
+ p->drawPoint( right - 1, y + 1 );
+ p->drawPoint( right - 1, bottom - 1 );
+ p->drawLine( x + 2, bottom - 1, right - 2, bottom - 1 );
+ p->setPen( dark3 );
+ p->drawLine( x + 2, y + 1, right - 2, y + 1 );
+ p->setPen( dark2 );
+ p->drawLine( x + 1, y + 2, x + 1, bottom - 2 );
+ p->drawLine( right - 1, y + 2, right - 1, bottom - 2 );
+}
+
+bool LiquidStyle::isHTMLWidget( const QWidget *widget ) const
+{
+ const QObject * w = widget->parent();
+ if ( w )
+ {
+ if ( !w->inherits( "QClipperWidget" ) )
+ return ( false );
+ w = w->parent();
+ if ( w )
+ {
+ w = w->parent();
+ if ( w && w->inherits( "KHTMLView" ) )
+ return ( true );
+ }
+ }
+ return ( false );
+}
+
+void LiquidStyle::drawHTMLCBBorder( const QPixmap &pix, const QColor &c ) const
+{
+ QPainter p;
+ p.begin( &pix );
+ p.setPen( c.dark( 200 ) );
+ p.drawRect( 0, 0, 16, 16 );
+ p.end();
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-11 09:17:28 +0000