/***************************************************************************
 *   Copyright (C) 2006-2007 by Thomas L�bking                             *
 *   thomas.luebking@web.de                                                *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <QAction>
#include <QApplication>
#include <QAbstractScrollArea>
#include <QComboBox>
#include <QDesktopWidget>
#include <QLabel>
#include <QLayout>
#include <QLineEdit>
#include <QMenu>
#include <QMenuBar>
#include <QStyleOptionButton>
#include <QPainter>
#include <QPainterPath>
#include <QX11Info>
#include "oxygen.h"
#include "oxrender.h"
#include "dynamicbrush.h"

#include <QtDebug>

#include <cmath>

using namespace Oxygen;

extern int bgYoffset_;
extern Pixmap shadowPix;
extern Config config;
extern Dpi dpi;

#include "inlinehelp.cpp"
#include "makros.h"


void OxygenStyle::drawPrimitive ( PrimitiveElement pe, const QStyleOption * option, QPainter * painter, const QWidget * widget) const {
   Q_ASSERT(option);
   Q_ASSERT(painter);
   
   bool sunken = option->state & State_Sunken;
   bool isEnabled = option->state & State_Enabled;
   bool hover = isEnabled && (option->state & State_MouseOver);
   bool hasFocus = option->state & State_HasFocus;
   bool up = false;
   
   
   switch ( pe ) {
   case PE_FrameDefaultButton: // This frame around a default button, e.g. in a dialog.
      // we swap colors instead, frame only on focus!
      break;
   case PE_PanelButtonCommand: // Button used to initiate an action, for example, a QPushButton.
   case PE_PanelButtonBevel: { // Generic panel with a button bevel.
      const int $4 = dpi.$4;
      //bool isOn = option->state & State_On;
      const QStyleOptionButton* opt = qstyleoption_cast<const QStyleOptionButton*>(option);
      //bool isDefault = opt && (opt->features & QStyleOptionButton::DefaultButton);
      
      int step = hoverStep(widget);

      QColor c = btnBgColor(PAL, isEnabled, 0, 0);
      QRect r = RECT;
      
      // shadow
      shadows.button[sunken][step?step:hover*7].render(r, painter);

      r.adjust($4, $4, -$4, -$4);

      // background
      painter->setRenderHint(QPainter::Antialiasing,false);
      fillWithMask(painter, r, c, &masks.button);

      // edge and a nice light gradient
      painter->setRenderHint(QPainter::Antialiasing);
      QLinearGradient lg(r.x(), r.y(), r.x(), r.bottom());
      QGradientStops stops;
      stops << QGradientStop( 0, QColor(255,255,255, (isEnabled&&!sunken ? 220 : 160)) )
           << QGradientStop( 0.1, QColor(255,255,255, (isEnabled&&!sunken ? 100 : 60)) )
           << QGradientStop( 1, QColor(255,255,255, (isEnabled&&!sunken ? 50 : 35)) );
      lg.setStops(stops);
      QLinearGradient lg2(r.x(), r.y(), r.x(), r.bottom());
      stops.clear();
      stops << QGradientStop( 0, QColor(255,255,255, 40) )
           << QGradientStop( 1, QColor(255,255,255, 0) );
      lg2.setStops(stops);
      painter->setPen(QPen(QBrush(lg),1));
      painter->setBrush(lg2);
      QRectF rf = r;
      rf.adjust(0.5, 0.5,-0.5,-0.5);
      painter->drawRoundRect(rf, int(ceil(9*90.0/r.width())), int(ceil(9*90.0/r.height())));

      // hover effect
      QRadialGradient rg = QRadialGradient(r.width()/2.0, 0.35*r.height(), qMax(r.width(),r.height())/2.0 - 5, r.width()/2.0, 0.35*r.height());
      c = btnBgColor(PAL, isEnabled, hover, step);
      c.setAlpha(190);
      QColor c2= c;
      c2.setAlpha(60);
      stops << QGradientStop( 0, c ) << QGradientStop( 1, c2 );
      rg.setStops(stops);
      painter->setPen(Qt::NoPen);
      painter->setBrush(rg);
      r.adjust(1,1,-1,-1);
      painter->drawRoundRect(r, int(ceil(9*90.0/r.width())), int(ceil(9*90.0/r.height())));
      break;
   }
   case PE_PanelButtonTool: { // Panel for a Tool button, used with QToolButton.
      if (sunken || (option->state & State_On)) {
         if (sunken) hover = false;
/*
         fillWithMask(painter, RECT,
                      gradient(COLOR(Window), RECT.height(), Qt::Vertical,
                               hover ? GradButton : GradSunken), &masks.button);
         shadows.lineEdit[1].render(RECT, painter);
*/
         QRect r = RECT;
         painter->setRenderHint(QPainter::Antialiasing);
         QRadialGradient rg(r.width()/2, r.height()/2, r.height()/2, r.width()/2, r.height()/4);
         QGradientStops stops;
         stops << QGradientStop( 0, QColor(0,0,0, 50) )
           << QGradientStop( 1, QColor(0,0,0, 0) );
         rg.setStops(stops);
         painter->fillRect(r, rg);
         rg = QRadialGradient(r.width()/2, r.height()/2, r.height()/2, r.width()/2, 3*r.height()/4);
         stops.clear();
         stops << QGradientStop( 0, QColor(255,255,255, 190) )
           << QGradientStop( 1, QColor(255,255,255, 0) );
         rg.setStops(stops);
         painter->fillRect(r, rg);
      }
/*      else if (hover) {
         fillWithMask(painter, RECT.adjusted(dpi.$2,dpi.$1,-dpi.$2,0),
                      gradient(COLOR(Window), RECT.height(), Qt::Vertical,
                               GradButton), &masks.button);
         shadows.group.render(RECT, painter, Tile::Ring);
      }
*/      break;
   }
   case PE_PanelLineEdit: { // Panel for a QLineEdit.
      // spinboxes and combos allready have a lineedit as global frame
      if (widget && widget->parentWidget() &&
          (widget->parentWidget()->inherits("QAbstractSpinBox") ||
           widget->parentWidget()->inherits("QComboBox")))
         break;
      if (qstyleoption_cast<const QStyleOptionFrame *>(option) &&
          static_cast<const QStyleOptionFrame *>(option)->lineWidth < 1) {
         painter->fillRect(RECT, COLOR(Base)); break;
      }

      if (isEnabled) {
         fillWithMask(painter, RECT, COLOR(Base), &masks.button);
         if (hasFocus) {
            painter->save();
            painter->setPen(QPen(COLOR(Highlight), dpi.$2));
            painter->drawLine(RECT.left()+dpi.$4, RECT.bottom(),
                              RECT.right()-dpi.$3, RECT.bottom());
            painter->restore();
         }
      }
      shadows.lineEdit[isEnabled].render(RECT, painter);
      break;
   }
   case PE_FrameFocusRect: { // Generic focus indicator.
      painter->save();
      painter->setBrush(Qt::NoBrush);
      painter->setPen(COLOR(Highlight));
      painter->drawLine(RECT.bottomLeft(), RECT.bottomRight());
      painter->restore();
      break;
   }
   case PE_IndicatorArrowUp: // Generic Up arrow.
   case PE_IndicatorSpinUp: // Up symbol for a spin widget, for example a QSpinBox.
   case PE_IndicatorSpinPlus: // Increase symbol for a spin widget.
      up = true;
   case PE_IndicatorHeaderArrow: // Arrow used to indicate sorting on a list or table header
   case PE_IndicatorButtonDropDown: // indicator for a drop down button, for example, a tool button that displays a menu.
   case PE_IndicatorArrowDown: // Generic Down arrow.
   case PE_IndicatorSpinDown: // Down symbol for a spin widget.
   case PE_IndicatorSpinMinus: { // Decrease symbol for a spin widget.
      if (const QStyleOptionHeader* hopt =
          qstyleoption_cast<const QStyleOptionHeader*>(option)) {
         if (hopt->sortIndicator == QStyleOptionHeader::None)
            break;
         up = hopt->sortIndicator == QStyleOptionHeader::SortUp;
      }
      SAVE_ANTIALIAS;
      bool hadNoBrush = painter->brush() == Qt::NoBrush;
      painter->setRenderHint(QPainter::Antialiasing);
      if (hadNoBrush)
         painter->setBrush(painter->pen().brush());
      
      int w = RECT.width();
      
      // we want a golden mean cut arrow ;) 1:1.6180339887498948482
      int x[3], y[2];
      if (w <  8*RECT.height()/5) {
         if (w%2) --w;
         x[0] = RECT.x(); x[1] = RECT.right(); x[2] = x[0] + w/2;
         int h = 5*w/8;  if (!(h%2)) --h;
         y[0] = RECT.y() + (RECT.height()-h)/2; y[1] = y[0] + h;
      }
      else {
         w = 8*RECT.height()/5;
         if (w%2) --w;
         x[0] = RECT.x() + (RECT.width()-w)/2; x[1] = x[0] + w; x[2] = x[0] + w/2;
         y[0] = RECT.y(); y[1] = RECT.bottom();
      }
      if (up) {
         //  0.5 is to have sharp horizontal edges
        const QPointF points[3] =  { QPointF(x[0], y[1]+0.5), QPointF(x[1], y[1]+0.5), QPointF(x[2], y[0]) };
         painter->drawPolygon(points, 3);
      }
      else {
        //  0.5 is to have sharp horizontal edges
         const QPointF points[3] =  { QPointF(x[0], y[0]-0.5), QPointF(x[1], y[0]-0.5), QPointF(x[2], y[1]) };
         painter->drawPolygon(points, 3);
      }
      if (hadNoBrush)
         painter->setBrush(Qt::NoBrush);
      RESTORE_ANTIALIAS;
      break;
   }
   case PE_IndicatorArrowRight: // Generic Right arrow.
      up = true;
   case PE_IndicatorArrowLeft: { // Generic Left arrow.
      SAVE_ANTIALIAS;
      bool hadNoBrush = painter->brush() == Qt::NoBrush;
      painter->setRenderHint(QPainter::Antialiasing);
      if (hadNoBrush)
         painter->setBrush(painter->pen().brush());
      int x[2], y[3], h = RECT.height();
      if (h <  8*RECT.width()/5) {
         if (h%2) --h;
         y[0] = RECT.y(); y[1] = RECT.bottom(); y[2] = y[0] + h/2;
         int w = 5*h/8; if (!(w%2)) --w;
         x[0] = RECT.x() + (RECT.width()-w)/2; x[1] = x[0] + w;
      }
      else {
         h = 8*RECT.width()/5;
         if (h%2) --h;
         y[0] = RECT.y() + (RECT.height()-h)/2; y[1] = y[0] + h; y[2] = y[0] + h/2;
         x[0] = RECT.x(); x[1] = RECT.right();
      }
      if (up) { //right
        //  0.5 is to have sharp vertical edge
         const QPointF points[3] =  { QPointF(x[0]+0.5, y[0]), QPointF(x[0]+0.5, y[1]), QPointF(x[1], y[2]) };
         painter->drawPolygon(points, 3);
      }
      else {
         const QPointF points[3] =  { QPointF(x[0], y[2]), QPointF(x[1]-0.5, y[0]), QPointF(x[1]-0.5, y[1]) };
         painter->drawPolygon(points, 3);
      }
      if (hadNoBrush)
         painter->setBrush(Qt::NoBrush);
      RESTORE_ANTIALIAS;
      break;
   }
   case PE_IndicatorCheckBox: { // On/off indicator, for example, a QCheckBox.
      
      drawPrimitive(PE_PanelButtonBevel, option, painter, widget);
      
      if (!(sunken || (option->state & State_Off))) {
         QColor c = btnFgColor(PAL, isEnabled, hover||hasFocus);
         painter->save();
         painter->setRenderHint(QPainter::Antialiasing);
         QRect r = RECT.adjusted(dpi.$6,dpi.$6,-dpi.$6,-dpi.$6);
         const QPixmap &fill = gradient(c, r.height(), Qt::Vertical, config.gradBtn);
         switch (config.checkType) {
         case 0: {
            QPen pen(fill, r.width()/5, Qt::SolidLine, Qt::RoundCap, Qt::BevelJoin);
            painter->setPen(pen);
            painter->drawLine(r.x(),r.bottom(),r.right(),r.y());
            if (option->state & State_On)
               painter->drawLine(r.x(),r.y(),r.right(),r.bottom());
            break;
         }
         default:
         case 1: {
            QPen pen(fill, r.width()/5, Qt::SolidLine, Qt::RoundCap, Qt::BevelJoin);
            painter->setPen(pen);
            const QPoint points[4] = {
            QPoint(r.right(), r.top()),
            QPoint(r.x()+r.width()/3, r.bottom()),
            QPoint(r.x(), r.bottom()-r.height()/3),
            QPoint(r.x()+r.width()/3, r.bottom()-r.height()/5)
            };
            painter->drawPolygon(points, (option->state & State_On)?4:2);
            break;
         }
         case 2:
            if (option->state & State_On)
               painter->fillRect(r, fill);
            else {
               QRect r2 = r; r2.setBottom(r.top()+r.height()/3);
               fillWithMask(painter, r2, fill, &masks.button);
               r2 = r; r2.setTop(r.bottom()-r.height()/3);
               fillWithMask(painter, r2, fill, &masks.button);
            }
         }
         painter->restore();
      }
      break;
   }
   case PE_IndicatorRadioButton: { // Exclusive on/off indicator, for example, a QRadioButton.
      bool isOn = option->state & State_On;
      if (isOn) sunken = false;
      hover = hover && !isOn;
      const int $2 = dpi.$2, $1 = dpi.$1;
      int step = isOn ? 0 : hoverStep(widget);
      QColor c = btnBgColor(PAL, isEnabled, hover||hasFocus, step);
      QPoint xy = RECT.topLeft();
      
      // shadow
      painter->drawPixmap(sunken?xy+QPoint($1,$1):xy, shadows.radio[sunken][hover||hasFocus]);
      
      // glass
      xy += QPoint($2,$1);
      int sz = dpi.ExclusiveIndicator - dpi.$4;
      if (isEnabled)
         fillWithMask(painter, xy, gradient(c, sz, Qt::Vertical, config.gradBtn), masks.radio);
      else
         fillWithMask(painter, xy, c, masks.radio);
      painter->save();
      painter->setBrush(Qt::NoBrush);
      painter->setPen(Qt::white);
      painter->setRenderHint(QPainter::Antialiasing);
      painter->drawEllipse(xy.x(), xy.y(), sz, sz);
      painter->restore();
      
      if (isOn) { // drop?
         xy += QPoint($2,$2);
         sz -= dpi.$4;
         QColor c = btnFgColor(PAL, isEnabled, hover||hasFocus);
         xy += QPoint($2,$2);
         fillWithMask(painter, xy, gradient(c, sz, Qt::Vertical, config.gradBtn), masks.radioIndicator);
      }
      break;
   }
   case PE_Q3DockWindowSeparator: // Item separator for Qt 3 compatible dock window and toolbar contents.
      break;
   case PE_Frame: { // Generic frame; see also QFrame.
      if (widget) {
         // handle the
         if (widget->inherits("QComboBoxPrivateContainer")) {
            SAVE_PEN;
            painter->setPen(COLOR(Base));
            painter->drawRect(RECT.adjusted(0,0,-1,-1));
            RESTORE_PEN;
            break;
         }
         
         bool inverse = true, niceFrame = false;
         QRect rect = RECT; const QRect *outerRect = 0;
         
         const Tile::Mask *mask = 0L; const Tile::Set *shadow = 0L;
         if (sunken) {
            shadow = &shadows.lineEdit[isEnabled];
            mask = &masks.button;
         }
         else if (option->state & State_Raised) {
            shadow = &shadows.tab;
            mask = &masks.tab;
         }
         QPoint zero;
         const QBrush *brush = &PAL.brush(widget->backgroundRole());
         if (qobject_cast<const QFrame*>(widget)) { // frame, can be killed unless...
            if (widget->inherits("QTextEdit")) { // ...it's a TextEdit!
               niceFrame = true;
               inverse = false; brush = &PAL.brush(QPalette::Base);
            }
            else { // maybe we need to corect a textlabels margin
               if (const QLabel* label = qobject_cast<const QLabel*>(widget))
                  if (label->text() != QString() && label->margin() < dpi.$3)
                     const_cast<QLabel*>(label)->setMargin(dpi.$3);
               break; // painted on visual frame
            }
         }
         else if (qobject_cast<const VisualFrame*>(widget)) {
            if (widget->parentWidget() && widget->parentWidget()->parentWidget())
               brush = &PAL.brush(widget->parentWidget()->parentWidget()->backgroundRole());
            niceFrame = true;
            zero = widget->mapTo(widget->topLevelWidget(), QPoint(0,0));
            if (!sunken) {
               outerRect = &RECT;
               if (option->state & State_Raised)
                  rect = RECT.adjusted(dpi.$2,dpi.$1,-dpi.$2,-dpi.$4);
               else
                  rect = RECT.adjusted(dpi.$2,dpi.$2,-dpi.$2,-dpi.$2);
            }
         }
         if (niceFrame) {
            if (mask)
               fillWithMask(painter, rect, *brush, mask, Tile::Full, false, zero, inverse, outerRect);
            if (hasFocus) {
               painter->save();
               painter->setPen(QPen(COLOR(Highlight), dpi.$2));
               painter->drawLine(rect.left()+dpi.$4, rect.bottom(), rect.right()-dpi.$3, rect.bottom());
               painter->restore();
            }
            if (shadow)
               shadow->render(RECT, painter);
            else { // plain frame
               //horizontal
               shadows.line[false][Sunken].render(RECT, painter, Tile::Full, false);
               shadows.line[false][Sunken].render(RECT, painter, Tile::Full, true);
               //vertical
               shadows.line[true][Sunken].render(RECT, painter, Tile::Full, false);
               shadows.line[true][Sunken].render(RECT, painter, Tile::Full, true);
               break;
            }
            break;
         }
      }
      // fallback, we cannot paint shaped frame contents
      if (sunken)
         shadows.sunken.render(RECT,painter);
      else if (option->state & State_Raised)
//          shadows.raised.render(RECT,painter);
         break;
      else {
         //horizontal
         shadows.line[false][Sunken].render(RECT, painter, Tile::Full, false);
         shadows.line[false][Sunken].render(RECT, painter, Tile::Full, true);
         //vertical
         shadows.line[true][Sunken].render(RECT, painter, Tile::Full, false);
         shadows.line[true][Sunken].render(RECT, painter, Tile::Full, true);
      }
      break;
   }
   case PE_FrameMenu: { // Frame for popup windows/menus; see also QMenu.
      SAVE_PEN;
    QRect frame = RECT;
    int x,y,w,h;
    frame.getRect(&x, &y, &w, &h);

    painter->setRenderHint(QPainter::Antialiasing);
    painter->setBrush(Qt::NoBrush);
    QLinearGradient lg(0, 0, 0, 10);
    QGradientStops stops;
    stops << QGradientStop( 0, QColor(255,255,255, 110) )
           << QGradientStop( 1, QColor(128,128,128, 60) );
    lg.setStops(stops);
    painter->setPen(QPen(QBrush(lg),1));
    painter->drawLine(QPointF(6.3, 0.5), QPointF(w-6.3, 0.5));
    painter->drawArc(QRectF(0.5, 0.5, 9.5, 9.5),90*16, 90*16);
    painter->drawArc(QRectF(w-9.5-0.5, 0.5, 9.5, 9.5), 0, 90*16);

    painter->setPen(QColor(128,128,128, 60));
    painter->drawLine(QPointF(0.5, 6.3), QPointF(0.5, h-6.3));
    painter->drawLine(QPointF(w-0.5, 6.3), QPointF(w-0.5, h-6.3));

    lg = QLinearGradient(0, h-10, 0, h);
    stops.clear();
    stops << QGradientStop( 0, QColor(128,128,128, 60) )
           << QGradientStop( 1, QColor(0,0,0, 50) );
    lg.setStops(stops);
    painter->setPen(QPen(QBrush(lg),1));
    painter->drawArc(QRectF(0.5, h-9.5-0.5, 9.5, 9.5),180*16, 90*16);
    painter->drawArc(QRectF(w-9.5-0.5, h-9.5-0.5, 9.5, 9.5), 270*16, 90*16);
    painter->drawLine(QPointF(6.3, h-0.5), QPointF(w-6.3, h-0.5));

      RESTORE_PEN;
#if 0
      if (config.glassMenus) {
         painter->save();
         painter->setPen(Qt::white);
         painter->setBrush(Qt::NoBrush);
         painter->drawRect(RECT.adjusted(0,0,-1,-1));
         painter->restore();
//          painter->fillRect(RECT, Qt::white);
      }
      if (config.menuShadow) {
         QRect rect = RECT.adjusted(0,0, // don't ask...
                                    shadows.line[true][Sunken].thickness()+1,
                                    shadows.line[false][Sunken].thickness()+1);
         //horizontal
         shadows.line[false][Sunken].render(rect, painter, Tile::Full, false);
         shadows.line[false][Sunken].render(rect, painter, Tile::Full, true);
         //vertical
         shadows.line[true][Sunken].render(rect, painter, Tile::Full, false);
         shadows.line[true][Sunken].render(rect, painter, Tile::Full, true);
      }
#endif
     break;
   }
   case PE_PanelMenuBar: // Panel for menu bars.
   case PE_FrameDockWidget: // Panel frame for dock windows and toolbars.
      break;
   case PE_FrameTabWidget: // Frame for tab widgets.
      if (const QStyleOptionTabWidgetFrame *twf =
          qstyleoption_cast<const QStyleOptionTabWidgetFrame *>(option)) {
         
         bool mirror = false, vertical = false;
         switch (twf->shape) {
         case QTabBar::RoundedNorth: case QTabBar::TriangularNorth:
            break;
         case QTabBar::RoundedSouth: case QTabBar::TriangularSouth:
            mirror = true; break;
         case QTabBar::RoundedEast: case QTabBar::TriangularEast:
            mirror = true;
         case QTabBar::RoundedWest: case QTabBar::TriangularWest:
            vertical = true; break;
         }
             
         int baseHeight =
                vertical ? twf->tabBarSize.width() : twf->tabBarSize.height();
         if (baseHeight < 0)
            baseHeight = pixelMetric( PM_TabBarBaseHeight, option, widget )-dpi.$2;
         if (!baseHeight) {
            shadows.tab.render(RECT, painter);
            break;
         }
             
         QRect rect(RECT), tabRect(RECT), fillRect;
         int offset = 8;
         Qt::Orientation o = Qt::Vertical;
         Tile::PosFlags pf = Tile::Ring;
         if (vertical) { // east or west
            o = Qt::Horizontal;
            rect.adjust(0,offset,0,-offset);
            if (mirror) { // east
               rect.setLeft(rect.right()-baseHeight);
               fillRect = rect.adjusted(0, dpi.$2, -dpi.$3, -dpi.$3);
               pf &= ~Tile::Left;
               o = Qt::Horizontal;
               tabRect.setRight(tabRect.right()-(baseHeight-dpi.$2));
            }
            else {
               rect.setWidth(baseHeight);
               fillRect = rect.adjusted(dpi.$3, dpi.$2, 0, -dpi.$3);
               pf &= ~Tile::Right;
               o = Qt::Horizontal;
               tabRect.setLeft(tabRect.left()+(baseHeight-dpi.$2));
            }
            baseHeight = fillRect.width();
         }
         else { // north or south
            rect.adjust(offset,0,-offset,0);
            if (mirror) { //south
               rect.setTop(rect.bottom()-baseHeight);
               fillRect = rect.adjusted(dpi.$3, 0, -dpi.$3, -dpi.$3);
               pf &= ~Tile::Top;
               tabRect.setBottom(tabRect.bottom()-(baseHeight-dpi.$3));
            }
            else { // north
               rect.setHeight(baseHeight);
               fillRect = rect.adjusted(dpi.$3, dpi.$2, -dpi.$3, 0);
               pf &= ~Tile::Bottom;
               tabRect.setTop(tabRect.top()+baseHeight);
            }
            baseHeight = fillRect.height();
         }
         
         shadows.tab.render(rect, painter, pf);
         fillWithMask(painter, fillRect, gradient(CONF_COLOR(role_tab[0]), baseHeight, o, config.gradientStrong), &masks.tab, pf | Tile::Center);
         masks.tab.outline(fillRect, painter, CONF_COLOR(role_tab[0]).dark(110), true, pf);
         shadows.tab.render(tabRect, painter, Tile::Ring);
      }
      break;
   case PE_FrameLineEdit: // Panel frame for line edits.
      shadows.lineEdit[isEnabled].render(RECT.adjusted(0,0,0,-dpi.$2),painter);
      break;
   case PE_FrameGroupBox: { // Panel frame around group boxes.
      QRect rect = RECT.adjusted(dpi.$4,dpi.$2,-dpi.$4,0);
      rect.setHeight(qMax(dpi.$32, RECT.height()));
      fillWithMask(painter, rect, groupLight(rect.height()), &masks.button,
                   Tile::Full&~Tile::Bottom);
      rect.setBottom(RECT.bottom()-dpi.$32);
      shadows.group.render(RECT, painter, Tile::Ring);
      masks.button.outline(rect, painter, COLOR(Window).light(120), true,
                           Tile::Full&~Tile::Bottom);
      break;
   }
//    case PE_FrameButtonBevel: // Panel frame for a button bevel
//    case PE_FrameButtonTool: // Panel frame for a tool button
   case PE_FrameStatusBar: // Frame for a section of a status bar; see also QStatusBar.
      break;
   case PE_FrameWindow: // Frame around a MDI window or a docking window.
   {
      painter->save();
      painter->setPen(PAL.color(QPalette::Window).dark(110));
      painter->drawRect(RECT);
      painter->restore();
      break;
   }
   case PE_Q3Separator: // Qt 3 compatible generic separator.
      break;
   case PE_IndicatorViewItemCheck: // On/off indicator for a view item
   case PE_Q3CheckListIndicator: // Qt 3 compatible Checkbox part of a list view item.
   case PE_IndicatorMenuCheckMark: { // Check mark used in a menu.
      QRect rect;
      if (RECT.width() > RECT.height())
         rect.setRect(RECT.x()+(RECT.width()-RECT.height())/2, RECT.y(),
                      RECT.height()-1, RECT.height()-1);
      else
         rect.setRect(RECT.x(), RECT.y()+(RECT.height()-RECT.width())/2,
                      RECT.width()-1, RECT.width()-1);
      int off = rect.width()/4;
      
      painter->save();
      const bool selected = option->state & State_Selected && isEnabled;
      painter->setBrush(Qt::NoBrush);
      QPalette::ColorRole fgr;
      if (pe == PE_IndicatorMenuCheckMark) {
         if (widget)
            fgr = selected ? widget->backgroundRole() : widget->foregroundRole();
         else
            fgr = selected ? QPalette::Window : QPalette::WindowText;
      }
      else
         fgr = selected ? QPalette::HighlightedText : QPalette::Text;
      
      painter->setPen(PAL.color(fgr));
      painter->drawRect(rect.adjusted(0, off, -off, 0));
      
      if (!(option->state & State_Off)) {
         painter->setRenderHint(QPainter::Antialiasing);
         if (!(pe == PE_IndicatorMenuCheckMark || selected)) {
            fgr = QPalette::Highlight;
            painter->setPen(PAL.color(fgr));
         }
         painter->setBrush(PAL.color(fgr));
         const QPoint points[4] = {
            QPoint(rect.right(), rect.top()),
            QPoint(rect.x()+rect.width()/3, rect.bottom()),
            QPoint(rect.x(), rect.bottom()-rect.height()/3),
               QPoint(rect.x()+rect.width()/3, rect.bottom()-rect.height()/5)
         };
         painter->drawPolygon(points, 4);
      }
      painter->restore();
      break;
   }
   case PE_Q3CheckListExclusiveIndicator: // Qt 3 compatible Radio button part of a list view item.
      painter->save();
      painter->setRenderHint ( QPainter::Antialiasing );
      painter->drawEllipse ( RECT );
      _PRINTFLAGS_;
      if (option->state & State_On) {
         painter->setBrush ( painter->pen().color() );
         painter->drawEllipse ( RECT.adjusted(RECT.width()/4, RECT.height()/4, -RECT.width()/4, -RECT.height()/4) );
      }
      painter->restore();
      break;
//    case PE_IndicatorProgressChunk: // Section of a progress bar indicator; see also QProgressBar.
//    case PE_Q3CheckListController: // Qt 3 compatible Controller part of a list view item.
   case PE_IndicatorBranch: // Lines used to represent the branch of a tree in a tree view.
   {
      SAVE_PEN;
      int mid_h = RECT.x() + RECT.width() / 2;
      int mid_v = RECT.y() + RECT.height() / 2;
      int bef_h = mid_h;
      int bef_v = mid_v;
      int aft_h = mid_h;
      int aft_v = mid_v;
      
      painter->setPen(widget ?
                      midColor( PAL.color(widget->backgroundRole()), PAL.color(widget->foregroundRole())) :
                      midColor( PAL.color(QPalette::Base), PAL.color(QPalette::Text)) );
      static const int decoration_size = 9;
      if (option->state & State_Children) {
         int delta = decoration_size / 2 + 2;
         bef_h -= delta;
         bef_v -= delta;
         aft_h += delta;
         aft_v += delta;
         QStyleOption tmpOpt = *option;
         tmpOpt.rect = QRect(bef_h+2, bef_v+2, decoration_size, decoration_size);
         drawPrimitive(option->state & State_Open ? PE_IndicatorArrowDown :
                       option->direction == Qt::RightToLeft ? PE_IndicatorArrowLeft :
                       PE_IndicatorArrowRight, &tmpOpt, painter, widget);
      }
      if (RECT.x() ==  -1) { // this is for the first col and i don't see why we'd need a line here
         RESTORE_PEN;
         break;
      }
      
      if (option->state & (State_Item | State_Sibling))
         painter->drawLine(mid_h, RECT.y(), mid_h, bef_v);
      if (option->state & State_Sibling)
         painter->drawLine(mid_h, aft_v, mid_h, RECT.bottom());
      if (option->state & State_Item) {
         if (option->direction == Qt::RightToLeft)
            painter->drawLine(RECT.left(), mid_v, bef_h, mid_v);
         else
            painter->drawLine(aft_h, mid_v, RECT.right(), mid_v);
      }
      RESTORE_PEN;
      break;
   }
   case PE_IndicatorDockWidgetResizeHandle: // Resize handle for dock windows.
   {
      QPoint *points; int num;
      const int $12 = dpi.$12, $6 = dpi.$6;
      if (RECT.width() > RECT.height()) {
         int x = RECT.left()+RECT.width()/3;
         int y = RECT.top()+(RECT.height()-$6)/2;
         num = RECT.width()/(3*$12);
         if ((RECT.width()/3) % $12) ++num;
         points = new QPoint[num];
         for (int i = 0; i < num; ++i) {
            points[i] = QPoint(x,y); x += $12;
         }
      }
      else {
         int x = RECT.left()+(RECT.width()-$6)/2;
         int y = RECT.top()+RECT.height()/3;
         num = RECT.height()/(3*$12);
         if ((RECT.height()/3) % $12) ++num;
         points = new QPoint[num];
         for (int i = 0; i < num; ++i) {
            points[i] = QPoint(x,y); y += $12;
         }
      }
      painter->save();
      painter->setPen(Qt::NoPen);
      const QPixmap *fill; int cnt = num/2, imp = 1;
      QPalette::ColorRole role = QPalette::WindowText;
      if (hover) {
         role = QPalette::Highlight;
         imp = 8;
      }
      if (num%2)
      {
         fill = &gradient(midColor(COLOR(Window), PAL.color(role), 3, imp), $6, Qt::Vertical, GradSunken);
         fillWithMask(painter, points[cnt], *fill, masks.notch);
      }
      --num;
      for (int i = 0; i < cnt; ++i)
      {
         fill = &gradient(midColor(COLOR(Window), PAL.color(role), 3+cnt-i, imp), $6, Qt::Vertical, GradSunken);
         fillWithMask(painter, points[i], *fill, masks.notch);
         fillWithMask(painter, points[num-i], *fill, masks.notch);
      }
      painter->restore();
      delete[] points;
      break;
   }
   case PE_IndicatorToolBarHandle: // The handle of a toolbar.
      if (!(widget && widget->parentWidget()) ||
          widget->parentWidget()->underMouse()) {
         painter->save();
         QRect rect = RECT; bool line = false; int dx(0), dy(0);
         if (RECT.width() > RECT.height()) {
            line = (RECT.width() > 9*RECT.height()/2);
            if (line) {
               dx = 3*RECT.height()/2; dy = 0;
            }
            rect.setLeft(rect.left()+(rect.width()-rect.height())/2);
            rect.setWidth(rect.height());
         }
         else {
            line = (RECT.height() > 3*RECT.width());
            if (line) {
               dx = 0; dy = 3*RECT.width()/2;
            }
            rect.setTop(rect.top()+(rect.height()-rect.width())/2);
            rect.setHeight(rect.width());
         }
         QColor c = hover?COLOR(Highlight):COLOR(Window).dark(110);
         painter->setRenderHint(QPainter::Antialiasing);
         painter->setBrush(gradient(c, rect.height(), Qt::Vertical, GradSunken));
         painter->setPen(Qt::NoPen);
         painter->setBrushOrigin(rect.topLeft());
         painter->drawEllipse(rect);
         if (line) {
            const int $1 = dpi.$1;
            rect.adjust($1,$1,-$1,-$1);
            painter->setBrush(gradient(c, rect.height(), Qt::Vertical, GradSunken));
            rect.translate(-dx,-dy);
            painter->setBrushOrigin(rect.topLeft());
            painter->drawEllipse(rect);
            rect.translate( 2*dx, 2*dy);
            painter->setBrushOrigin(rect.topLeft());
            painter->drawEllipse(rect);
         }
         painter->restore();
      }
      break;
   case PE_IndicatorToolBarSeparator: // The separator in a toolbar.
      break;
   case PE_PanelToolBar: // The panel for a toolbar.
      break;
//    case PE_PanelTipLabel: // The panel for a tip label.
   case PE_FrameTabBarBase: // The frame that is drawn for a tabbar, ususally drawn for a tabbar that isn't part of a tab widget
      if (widget &&
          (qobject_cast<const QTabBar*>(widget) || // we alter the paintevent
          (widget->parentWidget() &&
           qobject_cast<QTabWidget*>(widget->parentWidget())))) // KDE abuse, allready has a nice base
         break;
      
      if (const QStyleOptionTabBarBase *tbb
            = qstyleoption_cast<const QStyleOptionTabBarBase *>(option)) {
         int size(0); Qt::Orientation o = Qt::Vertical;
         Tile::PosFlags pf = Tile::Ring;
         QRect fillRect;
         bool north = false;
         switch (tbb->shape) {
         case QTabBar::RoundedSouth:
         case QTabBar::TriangularSouth:
//             fillRect = RECT.adjusted(dpi.$3, dpi.$2, -dpi.$3, 0);
            pf &= ~Tile::Top;
            size = /*fillRect*/RECT.height();
            break;
         case QTabBar::RoundedNorth:
         case QTabBar::TriangularNorth:
            north = true;
//             fillRect = RECT.adjusted(dpi.$3, 0, -dpi.$3, -dpi.$3);
            pf &= ~Tile::Bottom;
            size = /*fillRect*/RECT.height();
            break;
         case QTabBar::RoundedWest:
         case QTabBar::TriangularWest:
//             fillRect = RECT.adjusted(0, dpi.$2, -dpi.$3, -dpi.$3);
            pf &= ~Tile::Right;
            o = Qt::Horizontal;
            size = /*fillRect*/RECT.width();
            break;
         case QTabBar::RoundedEast:
         case QTabBar::TriangularEast:
//             fillRect = RECT.adjusted(dpi.$3, dpi.$2, 0, -dpi.$3);
            pf &= ~Tile::Left;
            o = Qt::Horizontal;
            size = /*fillRect*/RECT.width();
            break;
         }
         fillWithMask(painter, RECT,
                      gradient(CONF_COLOR(role_tab[0]), size, o, config.gradientStrong),
                      &masks.button, pf | Tile::Center);
         if (north)
            shadows.lineEdit[0].render(RECT, painter, Tile::Ring & ~Tile::Bottom);
         else
            shadows.tab.render(RECT, painter, pf);
//          masks.tab.outline(fillRect, painter, CONF_COLOR(role_tab[0]).dark(110), true, pf);
      }
      break;
   case PE_IndicatorTabTear: // An indicator that a tab is partially scrolled out of the visible tab bar when there are many tabs.
      break;
   default:
      QCommonStyle::drawPrimitive( pe, option, painter, widget );
   } // switch
}