#include <QtGui>

// base
// drag & drop sur le widget pour le déplacer
// bouton fermer pour fermer l'application
// dessine un dégradé RGBA en fond
class BaseWidget : public QWidget
{
    // position dans le repère widget de clic gauche
    QPoint p;
    QPolygon polygon;
    QLinearGradient gradient;

public:
    BaseWidget()
    :QWidget
    (
        0,
        // enlève la décoration Windows et l'entrée dans la barre de tâche
        Qt::FramelessWindowHint | Qt::SubWindow
    )
    {
        resize(200,200);

        // bouton pour fermer l'application
        QPushButton *b = new QPushButton("fermer",this);
        QLayout *l= new QVBoxLayout(this);
        l->addWidget(b);
        connect(b,SIGNAL(clicked()),qApp,SLOT(quit()));
        // initialisation du polygone
        QVector<QPoint>  points;
        // même suite aléatoire pour chaque polygone
        qsrand(150);
        const int nbpoints = 100;
        const double r2PI = 2. * 3.14159265;
        for (int i = 0 ; i < nbpoints ; ++i)
        {
            float distance = 80.+20*qrand()/RAND_MAX;
            points << QPoint
                        (
                            100 + distance*cos(r2PI * i/nbpoints),
                            100 + distance*sin(r2PI * i/nbpoints)
                        );
        }
        polygon = QPolygon (points);

        // initialisation du gradient
        gradient.setStart (0. , 0.);
        gradient.setFinalStop (size().width() , 0.);
        {
             // Gradienstops pour varier l'apha et la couleur du gradient
            QGradientStops gs;
            gs  <<QGradientStop(0. , QColor(50 , 0   , 50  , 255))
                <<QGradientStop(.5 , QColor(0  , 255 , 255 , 100))
                <<QGradientStop(1. , QColor(50 , 50  , 0   , 255));

            gradient.setStops (gs);
        }

    }
protected:
    void mousePressEvent   ( QMouseEvent * mouseEvent )
    {
        // sauvegarde du point dans le repère widget lors du clic gauche
        if(mouseEvent->buttons() == Qt::LeftButton)  p = mouseEvent->pos();

    }
    void mouseMoveEvent  ( QMouseEvent * mouseEvent )
    {
        // repositionne la fenêtre en fonction de la position de la souris
        if(mouseEvent->buttons() & Qt::LeftButton)     move( mouseEvent->globalPos() - p);
    }
    protected:
    void paintEvent(QPaintEvent * )
        {
            QPainter p(this);
            p.setPen(Qt::NoPen);
            // utilisation d'un gradient linéaire entre deux coins de la fenêtre
            p.setBrush(gradient);
            p.drawPolygon(polygon);
        }
};


// widget avec un fond translucide
class TranslucideWidget : public BaseWidget
{
    // position dans le repère widget de clic gauche
    QPoint p;
public:
    TranslucideWidget()
    {
        // windows avec fond translucide
        setAttribute(Qt::WA_TranslucentBackground, true);
    }
};

// widget utilisant un masque
class MaskWidget : public BaseWidget
{
public:
    MaskWidget()
    {
        // création d'un mask sous forme de chessboard.
        QBitmap mask(5,5);
        {
            QPainter p(&mask);
            p.fillRect(mask.rect(),Qt::color0);
            p.setPen(Qt::color1);
            for (int i = 0 ; i < mask.height() ; ++i)
            for(int j = 0 ; j< mask.width() ; ++j)
            if( !(i%2 ^ j%2))
            p.drawPoint(j,i);
        }
        // retaille le masque à la taille de la fenêtre
        mask = mask.scaled(size());
        // application du masque sur tout le widget
        setMask(mask);
    }
};

// widget utilisant windowOpacity
class OpacityWidget : public BaseWidget
{
public:
    OpacityWidget()
    {
        //modifie l'opacité de la fenêtre
        setWindowOpacity (.5);
    }
};


class CompositionWidget : public BaseWidget
{
public:
    CompositionWidget()
    {
        // windows avec fond translucide
        setAttribute(Qt::WA_TranslucentBackground, true);

        // Création d'un masque en forme de chessboard
        QBitmap mask(5,5);
        {
            QPainter p(&mask);
            p.fillRect(mask.rect(),Qt::color0);
            p.setPen(Qt::color1);
            for (int i = 0 ; i < mask.height() ; ++i)
            for(int j = 0 ; j< mask.width() ; ++j)
            if( !(i%2 ^ j%2))
            p.drawPoint(j,i);
        }
        // retaille le masque à la taille de la fenêtre
        mask = mask.scaled(size());
        // application du masque sur tout le widget
        setMask(mask);


        // modifie l'opacité de la fenêtre
        setWindowOpacity (.5);
    }
};

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    TranslucideWidget translucideWidget;
    translucideWidget.show();
    translucideWidget.move(50,50);

    MaskWidget maskWidget;
    maskWidget.show();
    maskWidget.move(300,50);

    OpacityWidget opacityWidget;
    opacityWidget.show();
    opacityWidget.move(50,300);

    CompositionWidget compositionWidget;
    compositionWidget.show();
    compositionWidget.move(300 , 300);

    return app.exec();
}

QApplication::setStyle(new QPlastiqueStyle);

QWidget {
     border: 1px solid gray;
     border-radius: 10px;
     padding: 1px 10px 1px 10px;
     margin: 3px;
 }

 QLineEdit:enabled {
     background: green;
 }
 QLineEdit:!enabled {
     background: grey;
 }
 QComboBox::drop-down {
     subcontrol-origin: padding;
     subcontrol-position: top right;
     width: 50px;
     border-radius: 0;
 }

QLabel label;
QPixmap pixmap;

pixmap.load("image.jpg");
label->setPixmap(pixmap);

QWidget widget;
QPalette palette;

palette.setBrush(this->backgroundRole(), QBrush(QImage("image.jpg")));
this->setPalette(palette);

QWidget widget;
QString stylesheet("QWidget{ background-image: url(image.jpg); }");

widget.setStyleSheet(stylesheet);

QPushButton *bouton = new QPushButton("Passez la souris ici !", this);
bouton->setStyleSheet("color: blue;");
setStyleSheet("QPushButton { background-color: #FFFFFF } QPushButton:hover { background-color: #FFD800 } ");

QPushButton *bouton = new QPushButton("Passez la souris ici !", this);
bouton->setObjectName("Bouton");
setStyleSheet("QPushButton#Bouton { color: blue; background-color: #FFFFFF }"
              "QPushButton#Bouton:hover { background-color: #FFD800 } ");

class ProxyStyle : public QStyle
    {
    public:
        ProxyStyle(const QString &baseStyle) { style = QStyleFactory::create(baseStyle); }
 
        void polish(QWidget *w) { style->polish(w); }
        void unPolish(QWidget *w) { style->unPolish(w); }
        int pixelMetric(PixelMetric metric, QWidget *widget) const
            { return style->pixelMetric(metric, widget); }
        ...
 
    private:
        QStyle *style;
    };

class MyStyle : public ProxyStyle
    {
    public:
        MyStyle(const QString &baseStyle);
 
        int pixelMetric(PixelMetric metric, const QWidget *widget) const;
    };
 
    int MyStyle::pixelMetric(PixelMetric metric, const QWidget *widget) const
    {
        if (metric == PM_SplitterWidth)
            return 6;
        return ProxyStyle::pixelMetric(metric, widget);
    }

int main(int argc, char *argv[])
    {
        QApplication app(argc, argv);
        app.setStyle(new MyStyle(app.style().name()));
        ...
        return app.exec();
    }

*[enabled="true"] { background-color: yellow }

*[cssclass="class1"] { background-color: blue }
*[cssclass="class2"] { background-color: red }

_ui->widget1->setProperty("cssclass", "class1");
_ui->widget2->setProperty("cssclass", "class2");
_ui->widget3->setProperty("cssclass", "class2");

_ui->widget3->setProperty("cssclass", "");

widget->setProperty("cssclass", "une-classe-css");
widget->style()->unpolish(widget);
widget->style()->polish(widget);