#include <QApplication>
#include <QtGui>

class Delegate : public QItemDelegate
{
    Q_OBJECT

    public:
    inline void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
    {
        // Création d'un QStyleOptionProgressBar qui permettra de dessiner notre barre de progression :
        QStyleOptionProgressBar progressBar;

        progressBar.state = QStyle::State_Enabled;
        progressBar.direction = QApplication::layoutDirection();
        progressBar.fontMetrics = QApplication::fontMetrics();
        progressBar.rect = option.rect;
        progressBar.maximum = 100;
        progressBar.minimum = 0;

        // Gestion de la progression :
        int progress = index.data().toInt();
        progress = (progress < progressBar.minimum) ? progressBar.minimum : progress;
        progress = (progress > progressBar.maximum) ? progressBar.maximum : progress;
        progressBar.progress = progress;

        // Gestion du texte :
        progressBar.text = QString::number(progressBar.progress) + "%";
        progressBar.textAlignment = Qt::AlignCenter;
        progressBar.textVisible = true;

        // Affichage de la barre de progression à l'aide du style de l'application :
        QApplication::style()->drawControl(QStyle::CE_ProgressBar, &progressBar, painter);
    }
};

#include "main.moc"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QStandardItemModel *model = new QStandardItemModel(6, 2);
    QTreeView *view = new QTreeView;
    view->header()->setVisible(false);
    view->setModel(model);

    // Utilisation de la fonction setItemDelegateForColumn() :
    view->setItemDelegateForColumn(0, new Delegate);

    for(int i = 0; i <= 5; ++i)
    {
        model->setData(model->index(i, 0), i);
        model->setData(model->index(i, 1), "Texte");
    }

    view->show();

    return app.exec();
}

#include <QApplication>
#include <QFileSystemModel>
#include <QTreeView>
#include <QListView>
#include <QTableView>

int main(int argc, char **argv)
{
   QApplication app(argc, argv);

   QFileSystemModel model; // le modèle est ici le système de fichier
   model.setRootPath(QDir::rootPath());

   QTreeView treeView;
   treeView.setModel(&model);
   QListView listView;
   listView.setModel(&model);
   QTableView tableView;
   tableView.setModel(&model);

   // partageons la sélection pour plus de cohérence
   QItemSelectionModel *selection = treeView.selectionModel();
   listView.setSelectionModel(selection);
   tableView.setSelectionModel(selection);

   // changeons la racine en fonction de la sélection
   // (car les tables et listes ne sont pas faites pour naviguer, on pourra toujours naviguer avec l'arbre)
   QObject::connect(selection, SIGNAL(currentChanged(const QModelIndex, const QModelIndex)), &listView,
       SLOT(setRootIndex(const QModelIndex)));
   QObject::connect(selection, SIGNAL(currentChanged(const QModelIndex, const QModelIndex)), &tableView,
       SLOT(setRootIndex(const QModelIndex)));

   treeView.show();
   listView.show();
   tableView.show();

   return app.exec();
}

#include <QtGui>
#include <cstdlib>  // srand(), rand() et RAND_MAX
#include <ctime>    // time()

class MyQTreeWidgetItem :public QTreeWidgetItem
{
public :
    // Constructeur de MyQTreeWidgetItem
    MyQTreeWidgetItem ( QTreeWidgetItem * parent, int type = Type ):QTreeWidgetItem(parent,type){};
    MyQTreeWidgetItem ( QTreeWidget * parent, int type = Type ):QTreeWidgetItem(parent,type){};

    // Réimplemente le test
    bool operator< ( const QTreeWidgetItem & other ) const
    {
        // On récupère la colonne utilisée pour le test
        const QTreeWidget * pTree =treeWidget ();
        // Si aucun TreeWidget n'est associé, on utilise la colonne 0
        int colonne   = pTree ? pTree->sortColumn() : 0;

        // On récupère les données sous forme de variant situé dans la colonne
        QVariant  q1= data ( colonne , 0 );
        QVariant  q2= other.data ( colonne , 0 );
        // On vérifie que les deux variants sont de même type
        if (q1.type() == q2.type())
        {
            // Si ce sont des int
            if (q1.type()==QVariant::Int)       return q1.toInt()<q2.toInt();
            // Si ce sont des double
            if (q1.type()==QVariant::Double)    return q1.toDouble()<q2.toDouble();
        }
        // Sinon, on appelle le comparateur de la classe mère "QTreeWidgetItem"
        return QTreeWidgetItem::operator<(other);
    }
};

int main(int argc, char* argv[])
{
    srand(time(NULL));
    QApplication app(argc, argv);

    QTreeWidget tree;
    // On remplit l'en-tête
    QStringList entete;
    entete << "int" << "double" ;
    tree.setHeaderItem(new QTreeWidgetItem((QTreeWidgetItem*)0,entete));
    tree.setSortingEnabled(true);

    // On crée une première branche avec des QTreeWidgetItem
    // Les items seront triés de manière lexicale
    QTreeWidgetItem *parentitem = new QTreeWidgetItem(&tree);
    parentitem->setText(0,"QTreeWidgetItem");
    for (int i=0;i<20;++i)
    {
        QTreeWidgetItem*item = new QTreeWidgetItem(parentitem);
        item ->setData (0, 0, QVariant(i));
        item ->setData (1, 0, QVariant(rand()/(1.+RAND_MAX)*i));
    }

    // On crée une deuxième branche avec notre nouvelle classe
    // Les items seront triés de manière numérique
    parentitem = new MyQTreeWidgetItem(&tree);
    parentitem->setText(0,"MyQTreeWidgetItem ");
    for (int i=0;i<20;++i)
    {
        MyQTreeWidgetItem *item = new MyQTreeWidgetItem(parentitem);
        item ->setData (0, 0, QVariant(i));
        item ->setData (1, 0, QVariant(rand()/(1.+RAND_MAX)*i));
    }

    tree.resize(400, 650);
    tree.expandAll();
    tree.show();
    return app.exec();
}

#include <QtGui>

class MyQListWidgetItem :public QListWidgetItem
{
public :
    // Constructeur de MyQListWidgetItem.
    MyQListWidgetItem ( QListWidget * parent, int type = Type ):QListWidgetItem(parent,type){};

   // Réimplémente le test
   bool operator< ( const QListWidgetItem & other ) const
   {
       //On récupère les données sous forme de variant
       QVariant  q1= data ( 0 );
       QVariant  q2= other.data (  0 );
       //On vérifie que les deux variants sont de même type
       if (q1.type() ==q2.type())
        {
           // Si ce sont des int
           if (q1.type()==QVariant::Int)     return q1.toInt()<q2.toInt();
           // Si ce sont des double
           if (q1.type()==QVariant::Double)     return q1.toDouble()<q2.toDouble();
        }
       // Sinon on appelle le comparateur de la classe mère "QListWidgetItem"
       return QListWidgetItem::operator<(other);
   }

};

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);

    // Viewer  de gauche
    QListWidget  * pList1 = new QListWidget;
    // On active le tri. Par défaut, tri par ordre croissant
    pList1->setSortingEnabled(true);
    // On utilise nos items. Tri  par ordre numérique
    for (int i=0;i<20;++i)
    {
       QListWidgetItem*item = new MyQListWidgetItem(pList1);
       item ->setData ( 0, QVariant(i));
    }

    // Viewer  de droite
    QListWidget  * pList2 = new QListWidget;
    // On active le tri. Par défaut, tri par ordre croissant
    pList2->setSortingEnabled(true);
    // On utilise les QListWidgetItem. Tri ordre lexical
    for (int i=0;i<20;++i)
    {
       QListWidgetItem*item = new QListWidgetItem(pList2);
       item ->setData ( 0, QVariant(i));
    }

    QWidget w;
    QHBoxLayout  hl(&w);
    hl.addWidget(pList1);
    hl.addWidget(pList2);
    w.resize(400, 400);
    w.show();
    return app.exec();
}

//On efface les QTableWidgetItem contenus dans le tableau
tableWidget->clear();
//On efface toutes les lignes du tableau
tableWidget->setRowCount(0);