C++/Qt/QTreeView

ObjectTreeModel and QTreeView

<source lang="cpp"> Foundations of Qt Development\Chapter05\treemodel\main.cpp /*

* Copyright (c) 2006-2007, Johan Thelin
* 
* All rights reserved.
* 
* Redistribution and use in source and binary forms, with or without modification, 
* are permitted provided that the following conditions are met:
* 
*     * Redistributions of source code must retain the above copyright notice, 
*       this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above copyright notice,  
*       this list of conditions and the following disclaimer in the documentation 
*       and/or other materials provided with the distribution.
*     * Neither the name of APress nor the names of its contributors 
*       may be used to endorse or promote products derived from this software 
*       without specific prior written permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

1. include <QApplication>
2. include <QTreeView>
3. include "objecttreemodel.h"

int main( int argc, char **argv ) {

 QApplication app( argc, argv );
 
 QObject root;
 root.setObjectName( "root" );
 
 QObject *child;
 QObject *foo = new QObject( &root );
 foo->setObjectName( "foo" );
 child = new QObject( foo );
 child->setObjectName( "Mark" );
 child = new QObject( foo );
 child->setObjectName( "Bob" );
 child = new QObject( foo );
 child->setObjectName( "Kent" );
 
 QObject *bar = new QObject( &root );
 bar->setObjectName( "bar" );
 child = new QObject( bar );
 child->setObjectName( "Ole" );
 child = new QObject( bar );
 child->setObjectName( "Trond" );
 child = new QObject( bar );
 child->setObjectName( "Kjetil" );
 child = new QObject( bar );
 child->setObjectName( "Lasse" );
 QObject *baz = new QObject( &root );
 baz->setObjectName( "baz" );
 child = new QObject( baz );
 child->setObjectName( "Bengt" );
 child = new QObject( baz );
 child->setObjectName( "Sven" );

 ObjectTreeModel model( &root );
 
 QTreeView tree;
 tree.setModel( &model );
 
 tree.show();
 
 return app.exec();

}

Foundations of Qt Development\Chapter05\treemodel\objecttreemodel.cpp /*

* Copyright (c) 2006-2007, Johan Thelin
* 
* All rights reserved.
* 
* Redistribution and use in source and binary forms, with or without modification, 
* are permitted provided that the following conditions are met:
* 
*     * Redistributions of source code must retain the above copyright notice, 
*       this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above copyright notice,  
*       this list of conditions and the following disclaimer in the documentation 
*       and/or other materials provided with the distribution.
*     * Neither the name of APress nor the names of its contributors 
*       may be used to endorse or promote products derived from this software 
*       without specific prior written permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

1. include <QMetaObject>
2. include "objecttreemodel.h"

ObjectTreeModel::ObjectTreeModel( QObject *root, QObject *parent ) : QAbstractItemModel( parent ) {

 m_root = root;

} Qt::ItemFlags ObjectTreeModel::flags(const QModelIndex &index) const {

 return Qt::ItemIsEnabled | Qt::ItemIsSelectable;

} QVariant ObjectTreeModel::data( const QModelIndex &index, int role) const {

 if( !index.isValid() )
   return QVariant();
   
 if( role == Qt::DisplayRole )
 {
   switch( index.column() )
   {
   case 0:
     return static_cast<QObject*>( index.internalPointer() )->objectName();
     
   case 1:
     return static_cast<QObject*>( index.internalPointer() )->metaObject()->className();
     
   default:
     break;
   }
 }
 else if( role == Qt::ToolTipRole )
 {
   switch( index.column() )
   {
   case 0:
     return QString( "The name of the object." );
     
   case 1:
     return QString( "The name of the class." );
     
   default:
     break;
   }
 }
 return QVariant();

} QVariant ObjectTreeModel::headerData(int section, Qt::Orientation orientation, int role ) const {

 if( role != Qt::DisplayRole || orientation != Qt::Horizontal )
   return QVariant();
   
 switch( section )
 {
 case 0:
   return QString( "Object" );
   
 case 1:
   return QString( "Class" );
   
 default:
   return QVariant();
 }

} int ObjectTreeModel::rowCount(const QModelIndex &parent ) const {

 QObject *parentObject;
 
 if( !parent.isValid() )
   parentObject = m_root;
 else
   parentObject = static_cast<QObject*>( parent.internalPointer() );
   
 return parentObject->children().count();

} int ObjectTreeModel::columnCount(const QModelIndex &parent ) const {

 return 2;

} QModelIndex ObjectTreeModel::index(int row, int column, const QModelIndex &parent ) const {

 QObject *parentObject;
 
 if( !parent.isValid() )
   parentObject = m_root;
 else
   parentObject = static_cast<QObject*>( parent.internalPointer() );
 
 if( row < parentObject->children().count() )
   return createIndex( row, column, parentObject->children().at( row ) );
 else
   return QModelIndex();

} QModelIndex ObjectTreeModel::parent(const QModelIndex &index) const {

 if( !index.isValid() )
   return QModelIndex();
   
 QObject *indexObject = static_cast<QObject*>( index.internalPointer() );
 QObject *parentObject = indexObject->parent();
 
 if( parentObject == m_root )
   return QModelIndex();
   
 QObject *grandParentObject = parentObject->parent();
 
 return createIndex( grandParentObject->children().indexOf( parentObject ), 0, parentObject );

}

Foundations of Qt Development\Chapter05\treemodel\objecttreemodel.h /*

* Copyright (c) 2006-2007, Johan Thelin
* 
* All rights reserved.
* 
* Redistribution and use in source and binary forms, with or without modification, 
* are permitted provided that the following conditions are met:
* 
*     * Redistributions of source code must retain the above copyright notice, 
*       this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above copyright notice,  
*       this list of conditions and the following disclaimer in the documentation 
*       and/or other materials provided with the distribution.
*     * Neither the name of APress nor the names of its contributors 
*       may be used to endorse or promote products derived from this software 
*       without specific prior written permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

1. ifndef OBJECTTREEMODEL_H
2. define OBJECTTREEMODEL_H
3. include <QAbstractItemModel>

class ObjectTreeModel : public QAbstractItemModel { public:

 ObjectTreeModel( QObject *root, QObject *parent = 0 );
 
 Qt::ItemFlags flags( const QModelIndex &index ) const;
 QVariant data( const QModelIndex &index, int role ) const;
 QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const;
 int rowCount( const QModelIndex &parent = QModelIndex() ) const;
 int columnCount( const QModelIndex &parent = QModelIndex() ) const;
 
 QModelIndex index( int row, int column, const QModelIndex &parent = QModelIndex() ) const;
 QModelIndex parent( const QModelIndex &index ) const;
 

private:

 QObject *m_root;

};

1. endif // OBJECTTREEMODEL_H

 </source>

QTableView demo and QStandardItem

<source lang="cpp"> Foundations of Qt Development\Chapter05\readonlyview\main.cpp /*

* Copyright (c) 2006-2007, Johan Thelin
* 
* All rights reserved.
* 
* Redistribution and use in source and binary forms, with or without modification, 
* are permitted provided that the following conditions are met:
* 
*     * Redistributions of source code must retain the above copyright notice, 
*       this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above copyright notice,  
*       this list of conditions and the following disclaimer in the documentation 
*       and/or other materials provided with the distribution.
*     * Neither the name of APress nor the names of its contributors 
*       may be used to endorse or promote products derived from this software 
*       without specific prior written permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

1. include <QApplication>
2. include <QSplitter>
3. include <QTreeView>
4. include <QListView>
5. include <QTableView>
6. include <QStandardItemModel>

int main( int argc, char **argv ) {

 QApplication app( argc, argv );
 
 QTreeView *tree = new QTreeView();
 QListView *list = new QListView();
 QTableView *table = new QTableView();
 
 QSplitter splitter;
 splitter.addWidget( tree );
 splitter.addWidget( list );
 splitter.addWidget( table );
 
 QStandardItemModel model( 5, 2 );
 for( int r=0; r<5; r++ ) 
   for( int c=0; c<2; c++) 
   {
     QStandardItem *item = new QStandardItem( QString("Row:%0, Column:%1").arg(r).arg(c) );
     
     if( c == 0 )
       for( int i=0; i<3; i++ )
       {
         QStandardItem *child = new QStandardItem( QString("Item %0").arg(i) );
         child->setEditable( false );
         item->appendRow( child );
       }
     
     model.setItem(r, c, item);
   }
 model.setHorizontalHeaderItem( 0, new QStandardItem( "Foo" ) );
 model.setHorizontalHeaderItem( 1, new QStandardItem( "Bar-Baz" ) );
 tree->setModel( &model );
 list->setModel( &model );
 table->setModel( &model );
 list->setSelectionModel( tree->selectionModel() );
 table->setSelectionModel( tree->selectionModel() );
 table->setSelectionBehavior( QAbstractItemView::SelectRows );
 table->setSelectionMode( QAbstractItemView::SingleSelection );
 splitter.show();
 
 return app.exec();

}

 </source>

QTreeView demo and QStandardItem

<source lang="cpp"> Foundations of Qt Development\Chapter05\readonlyview\main.cpp /*

* Copyright (c) 2006-2007, Johan Thelin
* 
* All rights reserved.
* 
* Redistribution and use in source and binary forms, with or without modification, 
* are permitted provided that the following conditions are met:
* 
*     * Redistributions of source code must retain the above copyright notice, 
*       this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above copyright notice,  
*       this list of conditions and the following disclaimer in the documentation 
*       and/or other materials provided with the distribution.
*     * Neither the name of APress nor the names of its contributors 
*       may be used to endorse or promote products derived from this software 
*       without specific prior written permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

1. include <QApplication>
2. include <QSplitter>
3. include <QTreeView>
4. include <QListView>
5. include <QTableView>
6. include <QStandardItemModel>

int main( int argc, char **argv ) {

 QApplication app( argc, argv );
 
 QTreeView *tree = new QTreeView();
 QListView *list = new QListView();
 QTableView *table = new QTableView();
 
 QSplitter splitter;
 splitter.addWidget( tree );
 splitter.addWidget( list );
 splitter.addWidget( table );
 
 QStandardItemModel model( 5, 2 );
 for( int r=0; r<5; r++ ) 
   for( int c=0; c<2; c++) 
   {
     QStandardItem *item = new QStandardItem( QString("Row:%0, Column:%1").arg(r).arg(c) );
     
     if( c == 0 )
       for( int i=0; i<3; i++ )
       {
         QStandardItem *child = new QStandardItem( QString("Item %0").arg(i) );
         child->setEditable( false );
         item->appendRow( child );
       }
     
     model.setItem(r, c, item);
   }
 model.setHorizontalHeaderItem( 0, new QStandardItem( "Foo" ) );
 model.setHorizontalHeaderItem( 1, new QStandardItem( "Bar-Baz" ) );
 tree->setModel( &model );
 list->setModel( &model );
 table->setModel( &model );
 list->setSelectionModel( tree->selectionModel() );
 table->setSelectionModel( tree->selectionModel() );
 table->setSelectionBehavior( QAbstractItemView::SelectRows );
 table->setSelectionMode( QAbstractItemView::SingleSelection );
 splitter.show();
 
 return app.exec();

}

 </source>

QTreeView drag and drop

<source lang="cpp"> /****************************************************************************

• • Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
  • All rights reserved.
  • Contact: Nokia Corporation (qt-info@nokia.com)
  • This file is part of the documentation of the Qt Toolkit.
  • $QT_BEGIN_LICENSE:LGPL$
  • Commercial Usage
  • Licensees holding valid Qt Commercial licenses may use this file in
  • accordance with the Qt Commercial License Agreement provided with the
  • Software or, alternatively, in accordance with the terms contained in
  • a written agreement between you and Nokia.
  • GNU Lesser General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU Lesser
  • General Public License version 2.1 as published by the Free Software
  • Foundation and appearing in the file LICENSE.LGPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU Lesser General Public License version 2.1 requirements
  • will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  • In addition, as a special exception, Nokia gives you certain additional
  • rights. These rights are described in the Nokia Qt LGPL Exception
  • version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  • GNU General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU
  • General Public License version 3.0 as published by the Free Software
  • Foundation and appearing in the file LICENSE.GPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU General Public License version 3.0 requirements will be
  • met: http://www.gnu.org/copyleft/gpl.html.
  • If you have questions regarding the use of this file, please contact
  • Nokia at qt-info@nokia.com.
  • $QT_END_LICENSE$
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

/****************************************************************************

• • Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
  • All rights reserved.
  • Contact: Nokia Corporation (qt-info@nokia.com)
  • This file is part of an example program for Qt.
  • EDITIONS: NOLIMITS
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

1. ifndef DRAGDROPMODEL_H
2. define DRAGDROPMODEL_H
3. include "treemodel.h"

class DragDropModel : public TreeModel {

   Q_OBJECT

public:

   DragDropModel(const QStringList &strings, QObject *parent = 0);
   Qt::ItemFlags flags(const QModelIndex &index) const;
   bool dropMimeData(const QMimeData *data, Qt::DropAction action,
                     int row, int column, const QModelIndex &parent);
   QMimeData *mimeData(const QModelIndexList &indexes) const;
   QStringList mimeTypes() const;
   Qt::DropActions supportedDropActions() const;

};

1. endif

1. include <QtGui>
2. include "dragdropmodel.h"

DragDropModel::DragDropModel(const QStringList &strings, QObject *parent)

   : TreeModel(strings, parent)

{ } bool DragDropModel::dropMimeData(const QMimeData *data,

   Qt::DropAction action, int row, int column, const QModelIndex &parent)

{

   if (action == Qt::IgnoreAction)
       return true;
   if (!data->hasFormat("text/plain"))
       return false;
   int beginRow;
   if (row != -1)
       beginRow = row;
   else if (parent.isValid())
       beginRow = 0;
   else
       beginRow = rowCount(QModelIndex());
   QByteArray encodedData = data->data("text/plain");
   QDataStream stream(&encodedData, QIODevice::ReadOnly);
   QHash<qint64, QMap<int,QHash<int,QString> > > newItems;
   while (!stream.atEnd()) {
       qint64 id;
       int row;
       int column;
       QString text;
       stream >> id >> row >> column >> text;
       newItems[id][row][column] = text;
   }
   int rows = newItems.count();
   insertRows(beginRow, rows, parent);
   QMap<int,QHash<int,QString> > childItems;
   foreach (childItems, newItems.values()) {
       QHash<int,QString> rowItems;
       foreach (rowItems, childItems.values()) {
           foreach (int column, rowItems.keys()) {
               QModelIndex idx = index(beginRow, column, parent);
               setData(idx, rowItems[column]);
           }
           ++beginRow;
       }
   }
   return true;

} Qt::ItemFlags DragDropModel::flags(const QModelIndex &index) const {

   Qt::ItemFlags defaultFlags = TreeModel::flags(index);
   if (index.isValid())
       return Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | defaultFlags;
   else
       return Qt::ItemIsDropEnabled | defaultFlags;

} QMimeData *DragDropModel::mimeData(const QModelIndexList &indexes) const {

   QMimeData *mimeData = new QMimeData();
   QByteArray encodedData;
   QDataStream stream(&encodedData, QIODevice::WriteOnly);
   foreach (QModelIndex index, indexes) {
       if (index.isValid()) {
           QString text = data(index, Qt::DisplayRole).toString();
           stream << index.internalId() << index.row() << index.column() << text;
       }
   }
   mimeData->setData("text/plain", encodedData);
   return mimeData;

} QStringList DragDropModel::mimeTypes() const {

   QStringList types;
   types << "text/plain";
   return types;

} Qt::DropActions DragDropModel::supportedDropActions() const {

   return Qt::CopyAction | Qt::MoveAction;

}

1. ifndef TREEITEM_H
2. define TREEITEM_H
3. include <QList>
4. include <QVariant>

class TreeItem { public:

   TreeItem(const QList<QVariant> &data, TreeItem *parent = 0);
   ~TreeItem();
   void appendChild(TreeItem *child);
   TreeItem *child(int row);
   int childCount() const;
   int columnCount() const;
   QVariant data(int column) const;
   bool insertChild(int row, TreeItem *item);
   TreeItem *parent();
   bool removeChild(int row);
   int row() const;
   bool setData(int column, const QVariant &data);

private:

   QList<TreeItem*> childItems;
   QList<QVariant> itemData;
   TreeItem *parentItem;

};

1. endif

/*

   treeitem.cpp
   A container for items of data supplied by the simple tree model.

• /

1. include <QStringList>
2. include "treeitem.h"

TreeItem::TreeItem(const QList<QVariant> &data, TreeItem *parent) {

   parentItem = parent;
   itemData = data;

} TreeItem::~TreeItem() {

   qDeleteAll(childItems);

} void TreeItem::appendChild(TreeItem *item) {

   childItems.append(item);

} TreeItem *TreeItem::child(int row) {

   return childItems.value(row);

} int TreeItem::childCount() const {

   return childItems.count();

} int TreeItem::columnCount() const {

   return itemData.count();

} QVariant TreeItem::data(int column) const {

   return itemData.value(column);

} bool TreeItem::insertChild(int row, TreeItem *item) {

   if (row < 0 || row > childItems.count())
       return false;
   childItems.insert(row, item);
   return true;

} TreeItem *TreeItem::parent() {

   return parentItem;

} bool TreeItem::removeChild(int row) {

   if (row < 0 || row >= childItems.count())
       return false;
   delete childItems.takeAt(row);
   return true;

} int TreeItem::row() const {

   if (parentItem)
       return parentItem->childItems.indexOf(const_cast<TreeItem*>(this));
   return 0;

} bool TreeItem::setData(int column, const QVariant &data) {

   if (column < 0 || column >= itemData.count())
       return false;
   itemData.replace(column, data);
   return true;

}

1. ifndef TREEMODEL_H
2. define TREEMODEL_H
3. include <QAbstractItemModel>
4. include <QModelIndex>
5. include <QVariant>

class TreeItem; class TreeModel : public QAbstractItemModel {

   Q_OBJECT

public:

   TreeModel(const QStringList &strings, QObject *parent = 0);
   ~TreeModel();
   QVariant data(const QModelIndex &index, int role) const;
   Qt::ItemFlags flags(const QModelIndex &index) const;
   QVariant headerData(int section, Qt::Orientation orientation,
                       int role = Qt::DisplayRole) const;
   QModelIndex index(int row, int column,
                     const QModelIndex &parent = QModelIndex()) const;
   QModelIndex parent(const QModelIndex &index) const;
   int rowCount(const QModelIndex &parent = QModelIndex()) const;
   int columnCount(const QModelIndex &parent = QModelIndex()) const;
   bool insertRows(int position, int rows, const QModelIndex &parent = QModelIndex());
   bool removeRows(int position, int rows, const QModelIndex &parent = QModelIndex());
   bool setData(const QModelIndex &index, const QVariant &value,
                int role = Qt::EditRole);

private:

   void setupModelData(const QStringList &lines, TreeItem *parent);
   TreeItem *rootItem;

};

1. endif

/*

   treemodel.cpp
   Provides a simple tree model to show how to create and use hierarchical
   models.

• /

1. include <QtGui>
2. include "treeitem.h"
3. include "treemodel.h"

TreeModel::TreeModel(const QStringList &strings, QObject *parent)

   : QAbstractItemModel(parent)

{

   QList<QVariant> rootData;
   rootData << "Title" << "Summary";
   rootItem = new TreeItem(rootData);
   setupModelData(strings, rootItem);

} TreeModel::~TreeModel() {

   delete rootItem;

} int TreeModel::columnCount(const QModelIndex &parent) const {

   if (parent.isValid())
       return static_cast<TreeItem*>(parent.internalPointer())->columnCount();
   else
       return rootItem->columnCount();

} QVariant TreeModel::data(const QModelIndex &index, int role) const {

   if (!index.isValid())
       return QVariant();
   if (role != Qt::DisplayRole)
       return QVariant();
   TreeItem *item = static_cast<TreeItem*>(index.internalPointer());
   return item->data(index.column());

} Qt::ItemFlags TreeModel::flags(const QModelIndex &index) const {

   if (!index.isValid())
       return Qt::ItemIsEnabled;
   return Qt::ItemIsEnabled | Qt::ItemIsSelectable;

} QVariant TreeModel::headerData(int section, Qt::Orientation orientation,

                              int role) const

{

   if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
       return rootItem->data(section);
   return QVariant();

} QModelIndex TreeModel::index(int row, int column, const QModelIndex &parent)

           const

{

   TreeItem *parentItem;
   if (!parent.isValid())
       parentItem = rootItem;
   else
       parentItem = static_cast<TreeItem*>(parent.internalPointer());
   TreeItem *childItem = parentItem->child(row);
   if (childItem)
       return createIndex(row, column, childItem);
   else
       return QModelIndex();

} bool TreeModel::insertRows(int position, int rows, const QModelIndex &parent) {

   TreeItem *parentItem;
   if (!parent.isValid())
       parentItem = rootItem;
   else
       parentItem = static_cast<TreeItem*>(parent.internalPointer());
   if (position < 0 || position > parentItem->childCount())
       return false;
   QList<QVariant> blankList;
   for (int column = 0; column < columnCount(); ++column)
       blankList << QVariant("");
   beginInsertRows(parent, position, position + rows - 1);
   for (int row = 0; row < rows; ++row) {
       TreeItem *newItem = new TreeItem(blankList, parentItem);
       if (!parentItem->insertChild(position, newItem))
           break;
   }
   endInsertRows();
   return true;

} QModelIndex TreeModel::parent(const QModelIndex &index) const {

   if (!index.isValid())
       return QModelIndex();
   TreeItem *childItem = static_cast<TreeItem*>(index.internalPointer());
   TreeItem *parentItem = childItem->parent();
   if (parentItem == rootItem)
       return QModelIndex();
   return createIndex(parentItem->row(), 0, parentItem);

} bool TreeModel::removeRows(int position, int rows, const QModelIndex &parent) {

   TreeItem *parentItem;
   if (!parent.isValid())
       parentItem = rootItem;
   else
       parentItem = static_cast<TreeItem*>(parent.internalPointer());
   if (position < 0 || position > parentItem->childCount())
       return false;
   beginRemoveRows(parent, position, position + rows - 1);
   for (int row = 0; row < rows; ++row) {
       if (!parentItem->removeChild(position))
           break;
   }
   endRemoveRows();
   return true;

} int TreeModel::rowCount(const QModelIndex &parent) const {

   TreeItem *parentItem;
   if (!parent.isValid())
       parentItem = rootItem;
   else
       parentItem = static_cast<TreeItem*>(parent.internalPointer());
   return parentItem->childCount();

} bool TreeModel::setData(const QModelIndex &index,

                       const QVariant &value, int role)

{

   if (!index.isValid() || role != Qt::EditRole)
       return false;
   TreeItem *item = static_cast<TreeItem*>(index.internalPointer());
   if (item->setData(index.column(), value))
       emit dataChanged(index, index);
   else
       return false;
   return true;

} void TreeModel::setupModelData(const QStringList &lines, TreeItem *parent) {

   QList<TreeItem*> parents;
   QList<int> indentations;
   parents << parent;
   indentations << 0;
   int number = 0;
   while (number < lines.count()) {
       int position = 0;
       while (position < lines[number].length()) {
           if (lines[number].mid(position, 1) != " ")
               break;
           position++;
       }
       QString lineData = lines[number].mid(position).trimmed();
       if (!lineData.isEmpty()) {
           // Read the column data from the rest of the line.
           QStringList columnStrings = lineData.split("\t", QString::SkipEmptyParts);
           QList<QVariant> columnData;
           for (int column = 0; column < columnStrings.count(); ++column)
               columnData << columnStrings[column];
           if (position > indentations.last()) {
               // The last child of the current parent is now the new parent
               // unless the current parent has no children.
               if (parents.last()->childCount() > 0) {
                   parents << parents.last()->child(parents.last()->childCount()-1);
                   indentations << position;
               }
           } else {
               while (position < indentations.last() && parents.count() > 0) {
                   parents.pop_back();
                   indentations.pop_back();
               }
           }
           // Append a new item to the current parent"s list of children.
           parents.last()->appendChild(new TreeItem(columnData, parents.last()));
       }
       number++;
   }

}

1. ifndef WINDOW_H
2. define WINDOW_H
3. include <QMainWindow>

class QTreeView; class MainWindow : public QMainWindow {

   Q_OBJECT

public:

   MainWindow();

private:

   void setupItems();
   QTreeView *treeView;

};

1. endif
2. include <QtGui>
3. include "mainwindow.h"
4. include "dragdropmodel.h"

MainWindow::MainWindow() {

   QMenu *fileMenu = new QMenu(tr("&File"));
   QAction *quitAction = fileMenu->addAction(tr("E&xit"));
   quitAction->setShortcut(tr("Ctrl+Q"));
   menuBar()->addMenu(fileMenu);

// For convenient quoting:

   QTreeView *treeView = new QTreeView(this);
   treeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
   treeView->setDragEnabled(true);
   treeView->setAcceptDrops(true);
   treeView->setDropIndicatorShown(true);
   this->treeView = treeView;
   connect(quitAction, SIGNAL(triggered()), this, SLOT(close()));
   setupItems();
   setCentralWidget(treeView);
   setWindowTitle(tr("Tree View"));

} void MainWindow::setupItems() {

   QStringList items;
   items << tr("Widgets\tUser interface objects used to create GUI applications.")
         << tr("  QWidget\tThe basic building block for all other widgets.")
         << tr("  QDialog\tThe base class for dialog windows.")
         << tr("Tools\tUtilities and applications for Qt developers.")
         << tr("  Qt Designer\tA GUI form designer for Qt applications.")
         << tr("  Qt Assistant\tA documentation browser for Qt documentation.");
   DragDropModel *model = new DragDropModel(items, this);
   QModelIndex index = model->index(0, 0, QModelIndex());
   model->insertRows(2, 3, index);
   index = model->index(0, 0, QModelIndex());
   index = model->index(2, 0, index);
   model->setData(index, QVariant("QFrame"));
   model->removeRows(3, 2, index.parent());
   treeView->setModel(model);

}

1. include <QtGui>
2. include "mainwindow.h"

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

   QApplication app(argc, argv);
   MainWindow *window = new MainWindow;
   window->show();
   return app.exec();

}

 </source>

Some selections made using a table view

<source lang="cpp"> /****************************************************************************

• • Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
  • All rights reserved.
  • Contact: Nokia Corporation (qt-info@nokia.com)
  • This file is part of the documentation of the Qt Toolkit.
  • $QT_BEGIN_LICENSE:LGPL$
  • Commercial Usage
  • Licensees holding valid Qt Commercial licenses may use this file in
  • accordance with the Qt Commercial License Agreement provided with the
  • Software or, alternatively, in accordance with the terms contained in
  • a written agreement between you and Nokia.
  • GNU Lesser General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU Lesser
  • General Public License version 2.1 as published by the Free Software
  • Foundation and appearing in the file LICENSE.LGPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU Lesser General Public License version 2.1 requirements
  • will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  • In addition, as a special exception, Nokia gives you certain additional
  • rights. These rights are described in the Nokia Qt LGPL Exception
  • version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  • GNU General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU
  • General Public License version 3.0 as published by the Free Software
  • Foundation and appearing in the file LICENSE.GPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU General Public License version 3.0 requirements will be
  • met: http://www.gnu.org/copyleft/gpl.html.
  • If you have questions regarding the use of this file, please contact
  • Nokia at qt-info@nokia.com.
  • $QT_END_LICENSE$
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

1. ifndef WINDOW_H
2. define WINDOW_H
3. include <QItemSelection>
4. include <QMainWindow>
5. include <QModelIndex>
6. include <QWidget>
7. include <QTableView>

class MainWindow : public QMainWindow {

   Q_OBJECT

public:

   MainWindow(QWidget *parent = 0);

public slots:

   void updateSelection(const QItemSelection &selected,
                        const QItemSelection &deselected);
   void changeCurrent(const QModelIndex &current, const QModelIndex &previous);

private:

   QAbstractItemModel *model;
   QItemSelectionModel *selectionModel;
   QTableView *table;

};

1. endif

/*

 window.cpp
 A minimal subclass of QTableView with slots to allow the selection model
 to be monitored.

• /

1. include <QAbstractItemModel>
2. include <QItemSelection>
3. include <QItemSelectionModel>
4. include <QStatusBar>
5. include "model.h"
6. include "window.h"

MainWindow::MainWindow(QWidget *parent)

   : QMainWindow(parent)

{

   setWindowTitle("Selected items in a table model");
   model = new TableModel(8, 4, this);
   table = new QTableView(this);
   table->setModel(model);
   selectionModel = table->selectionModel();
   connect(selectionModel,
       SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
       this, SLOT(updateSelection(const QItemSelection &, const QItemSelection &)));
   connect(selectionModel,
       SIGNAL(currentChanged(const QModelIndex &, const QModelIndex &)),
       this, SLOT(changeCurrent(const QModelIndex &, const QModelIndex &)));
   statusBar();
   setCentralWidget(table);

}

void MainWindow::updateSelection(const QItemSelection &selected,

   const QItemSelection &deselected)

{

   QModelIndex index;
   QModelIndexList items = selected.indexes();
   foreach (index, items) {
       QString text = QString("(%1,%2)").arg(index.row()).arg(index.column());
       model->setData(index, text);

   }

   items = deselected.indexes();
   foreach (index, items)
       model->setData(index, "");

}

void MainWindow::changeCurrent(const QModelIndex &current,

   const QModelIndex &previous)

{

   statusBar()->showMessage(
       tr("Moved from (%1,%2) to (%3,%4)")
           .arg(previous.row()).arg(previous.column())
           .arg(current.row()).arg(current.column()));

}

/****************************************************************************

• • Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
  • All rights reserved.
  • Contact: Nokia Corporation (qt-info@nokia.com)
  • This file is part of the documentation of the Qt Toolkit.
  • $QT_BEGIN_LICENSE:LGPL$
  • Commercial Usage
  • Licensees holding valid Qt Commercial licenses may use this file in
  • accordance with the Qt Commercial License Agreement provided with the
  • Software or, alternatively, in accordance with the terms contained in
  • a written agreement between you and Nokia.
  • GNU Lesser General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU Lesser
  • General Public License version 2.1 as published by the Free Software
  • Foundation and appearing in the file LICENSE.LGPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU Lesser General Public License version 2.1 requirements
  • will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  • In addition, as a special exception, Nokia gives you certain additional
  • rights. These rights are described in the Nokia Qt LGPL Exception
  • version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  • GNU General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU
  • General Public License version 3.0 as published by the Free Software
  • Foundation and appearing in the file LICENSE.GPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU General Public License version 3.0 requirements will be
  • met: http://www.gnu.org/copyleft/gpl.html.
  • If you have questions regarding the use of this file, please contact
  • Nokia at qt-info@nokia.com.
  • $QT_END_LICENSE$
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

1. ifndef MODEL_H
2. define MODEL_H
3. include <QAbstractTableModel>
4. include <QStringList>
5. include <QVariant>

class TableModel : public QAbstractTableModel {

   Q_OBJECT

public:

   TableModel(int rows = 1, int columns = 1, QObject *parent = 0);
   int rowCount(const QModelIndex &parent = QModelIndex()) const;
   int columnCount(const QModelIndex &parent = QModelIndex()) const;
   QVariant data(const QModelIndex &index, int role) const;
   QVariant headerData(int section, Qt::Orientation orientation,
                       int role = Qt::DisplayRole) const;
   Qt::ItemFlags flags(const QModelIndex &index) const;
   bool setData(const QModelIndex &index, const QVariant &value,
                int role = Qt::EditRole);
   bool insertRows(int position, int rows, const QModelIndex &parent = QModelIndex());
   bool insertColumns(int position, int columns, const QModelIndex &parent = QModelIndex());
   bool removeRows(int position, int rows, const QModelIndex &parent = QModelIndex());
   bool removeColumns(int position, int columns, const QModelIndex &parent = QModelIndex());

private:

   QList<QStringList> rowList;

};

1. endif

/*

   model.cpp
   Provides a table model for use in various examples.

• /

1. include <QtGui>
2. include "model.h"

/*!

   Constructs a table model with at least one row and one column.

• /

TableModel::TableModel(int rows, int columns, QObject *parent)

   : QAbstractTableModel(parent)

{

   QStringList newList;
   for (int column = 0; column < qMax(1, columns); ++column) {
       newList.append("");
   }
   for (int row = 0; row < qMax(1, rows); ++row) {
       rowList.append(newList);
   }

}

/*!

   Returns the number of items in the row list as the number of rows
   in the model.

• /

int TableModel::rowCount(const QModelIndex &/*parent*/) const {

   return rowList.size();

} /*!

   Returns the number of items in the first list item as the number of
   columns in the model. All rows should have the same number of columns.

• /

int TableModel::columnCount(const QModelIndex &/*parent*/) const {

   return rowList[0].size();

} /*!

   Returns an appropriate value for the requested data.
   If the view requests an invalid index, an invalid variant is returned.
   Any valid index that corresponds to a string in the list causes that
   string to be returned for the display role; otherwise an invalid variant
   is returned.

• /

QVariant TableModel::data(const QModelIndex &index, int role) const {

   if (!index.isValid())
       return QVariant();
   if (role == Qt::DisplayRole)
       return rowList[index.row()][index.column()];
   else
       return QVariant();

} /*!

   Returns the appropriate header string depending on the orientation of
   the header and the section. If anything other than the display role is
   requested, we return an invalid variant.

• /

QVariant TableModel::headerData(int section, Qt::Orientation orientation,

                               int role) const

{

   if (role != Qt::DisplayRole)
       return QVariant();
   if (orientation == Qt::Horizontal)
       return QString("Column %1").arg(section);
   else
       return QString("Row %1").arg(section);

} /*!

   Returns an appropriate value for the item"s flags. Valid items are
   enabled, selectable, and editable.

• /

Qt::ItemFlags TableModel::flags(const QModelIndex &index) const {

   if (!index.isValid())
       return Qt::ItemIsEnabled;
   return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;

} /*!

   Changes an item in the model, but only if the following conditions
   are met:
   * The index supplied is valid.
   * The role associated with editing text is specified.
   The dataChanged() signal is emitted if the item is changed.

• /

bool TableModel::setData(const QModelIndex &index,

                        const QVariant &value, int role)

{

   if (!index.isValid() || role != Qt::EditRole)
       return false;
   rowList[index.row()][index.column()] = value.toString();
   emit dataChanged(index, index);
   return true;

} /*!

   Inserts a number of rows into the model at the specified position.

• /

bool TableModel::insertRows(int position, int rows, const QModelIndex &parent) {

   int columns = columnCount();
   beginInsertRows(parent, position, position + rows - 1);
   for (int row = 0; row < rows; ++row) {
       QStringList items;
       for (int column = 0; column < columns; ++column)
           items.append("");
       rowList.insert(position, items);
   }
   endInsertRows();
   return true;

} /*!

   Inserts a number of columns into the model at the specified position.
   Each entry in the list is extended in turn with the required number of
   empty strings.

• /

bool TableModel::insertColumns(int position, int columns, const QModelIndex &parent) {

   int rows = rowCount();
   beginInsertColumns(parent, position, position + columns - 1);
   for (int row = 0; row < rows; ++row) {
       for (int column = position; column < columns; ++column) {
           rowList[row].insert(position, "");
       }
   }
   endInsertColumns();
   return true;

} /*!

   Removes a number of rows from the model at the specified position.

• /

bool TableModel::removeRows(int position, int rows, const QModelIndex &parent) {

   beginRemoveRows(parent, position, position + rows - 1);
   for (int row = 0; row < rows; ++row) {
       rowList.removeAt(position);
   }
   endRemoveRows();
   return true;

} /*!

   Removes a number of columns from the model at the specified position.
   Each row is shortened by the number of columns specified.

• /

bool TableModel::removeColumns(int position, int columns, const QModelIndex &parent) {

   int rows = rowCount();
   beginRemoveColumns(parent, position, position + columns - 1);
   for (int row = 0; row < rows; ++row) {
       for (int column = 0; column < columns; ++column) {
           rowList[row].removeAt(position);
       }
   }
   endRemoveColumns();
   return true;

}

/****************************************************************************

• • Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
  • All rights reserved.
  • Contact: Nokia Corporation (qt-info@nokia.com)
  • This file is part of the documentation of the Qt Toolkit.
  • $QT_BEGIN_LICENSE:LGPL$
  • Commercial Usage
  • Licensees holding valid Qt Commercial licenses may use this file in
  • accordance with the Qt Commercial License Agreement provided with the
  • Software or, alternatively, in accordance with the terms contained in
  • a written agreement between you and Nokia.
  • GNU Lesser General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU Lesser
  • General Public License version 2.1 as published by the Free Software
  • Foundation and appearing in the file LICENSE.LGPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU Lesser General Public License version 2.1 requirements
  • will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  • In addition, as a special exception, Nokia gives you certain additional
  • rights. These rights are described in the Nokia Qt LGPL Exception
  • version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  • GNU General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU
  • General Public License version 3.0 as published by the Free Software
  • Foundation and appearing in the file LICENSE.GPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU General Public License version 3.0 requirements will be
  • met: http://www.gnu.org/copyleft/gpl.html.
  • If you have questions regarding the use of this file, please contact
  • Nokia at qt-info@nokia.com.
  • $QT_END_LICENSE$
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

/*

 main.cpp
 A simple example that shows how selections can be used directly on a model.
 It shows the result of some selections made using a table view.

• /

1. include <QApplication>
2. include "window.h"

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

   QApplication app(argc, argv);
   QMainWindow *window = new MainWindow;
   window->show();
   window->resize(640, 480);
   return app.exec();

}

 </source>

Using QTreeView

<source lang="cpp"> /****************************************************************************

• • Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
  • All rights reserved.
  • Contact: Nokia Corporation (qt-info@nokia.com)
  • This file is part of the documentation of the Qt Toolkit.
  • $QT_BEGIN_LICENSE:LGPL$
  • Commercial Usage
  • Licensees holding valid Qt Commercial licenses may use this file in
  • accordance with the Qt Commercial License Agreement provided with the
  • Software or, alternatively, in accordance with the terms contained in
  • a written agreement between you and Nokia.
  • GNU Lesser General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU Lesser
  • General Public License version 2.1 as published by the Free Software
  • Foundation and appearing in the file LICENSE.LGPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU Lesser General Public License version 2.1 requirements
  • will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  • In addition, as a special exception, Nokia gives you certain additional
  • rights. These rights are described in the Nokia Qt LGPL Exception
  • version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  • GNU General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU
  • General Public License version 3.0 as published by the Free Software
  • Foundation and appearing in the file LICENSE.GPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU General Public License version 3.0 requirements will be
  • met: http://www.gnu.org/copyleft/gpl.html.
  • If you have questions regarding the use of this file, please contact
  • Nokia at qt-info@nokia.com.
  • $QT_END_LICENSE$
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

1. ifndef WINDOW_H
2. define WINDOW_H
3. include <QMainWindow>

class QAction; class QTreeWidget; class QTreeWidgetItem; class MainWindow : public QMainWindow {

   Q_OBJECT

public:

   MainWindow();

public slots:

   void findItems();
   void insertItem();
   void removeItem();
   void sortAscending();
   void sortDescending();
   void updateMenus(QTreeWidgetItem *current);
   void updateSortItems();

private:

   void setupTreeItems();
   QAction *ascendingAction;
   QAction *autoSortAction;
   QAction *descendingAction;
   QAction *insertAction;
   QAction *removeAction;
   QTreeWidget *treeWidget;

};

1. endif

1. include <QtGui>
2. include "mainwindow.h"

MainWindow::MainWindow() {

   QMenu *fileMenu = new QMenu(tr("&File"));
   QAction *quitAction = fileMenu->addAction(tr("E&xit"));
   quitAction->setShortcut(tr("Ctrl+Q"));
   QMenu *itemsMenu = new QMenu(tr("&Items"));
   insertAction = itemsMenu->addAction(tr("&Insert Item"));
   removeAction = itemsMenu->addAction(tr("&Remove Item"));
   removeAction->setEnabled(false);
   itemsMenu->addSeparator();
   ascendingAction = itemsMenu->addAction(tr("Sort in &Ascending Order"));
   descendingAction = itemsMenu->addAction(tr("Sort in &Descending Order"));
   autoSortAction = itemsMenu->addAction(tr("&Automatically Sort Items"));
   autoSortAction->setCheckable(true);
   itemsMenu->addSeparator();
   QAction *findItemsAction = itemsMenu->addAction(tr("&Find Items"));
   findItemsAction->setShortcut(tr("Ctrl+F"));
   menuBar()->addMenu(fileMenu);
   menuBar()->addMenu(itemsMenu);

/* For convenient quoting:

   QTreeWidget *treeWidget = new QTreeWidget(this);

• /

   treeWidget = new QTreeWidget(this);
   treeWidget->setColumnCount(2);

   QStringList headers;
   headers << tr("Subject") << tr("Default");
   treeWidget->setHeaderLabels(headers);

   connect(quitAction, SIGNAL(triggered()), this, SLOT(close()));
   connect(ascendingAction, SIGNAL(triggered()), this, SLOT(sortAscending()));
   connect(autoSortAction, SIGNAL(triggered()), this, SLOT(updateSortItems()));
   connect(descendingAction, SIGNAL(triggered()), this, SLOT(sortDescending()));
   connect(findItemsAction, SIGNAL(triggered()), this, SLOT(findItems()));
   connect(insertAction, SIGNAL(triggered()), this, SLOT(insertItem()));
   connect(removeAction, SIGNAL(triggered()), this, SLOT(removeItem()));
   connect(treeWidget,
           SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)),
           this, SLOT(updateMenus(QTreeWidgetItem *)));
   setupTreeItems();
   updateMenus(treeWidget->currentItem());
   setCentralWidget(treeWidget);
   setWindowTitle(tr("Tree Widget"));

} void MainWindow::setupTreeItems() {

   QTreeWidgetItem *cities = new QTreeWidgetItem(treeWidget);
   cities->setText(0, tr("Cities"));
   QTreeWidgetItem *osloItem = new QTreeWidgetItem(cities);
   osloItem->setText(0, tr("Oslo"));
   osloItem->setText(1, tr("Yes"));

   (new QTreeWidgetItem(cities))->setText(0, tr("Stockholm"));
   (new QTreeWidgetItem(cities))->setText(0, tr("Helsinki"));
   (new QTreeWidgetItem(cities))->setText(0, tr("Copenhagen"));

   QTreeWidgetItem *planets = new QTreeWidgetItem(treeWidget, cities);
   planets->setText(0, tr("Planets"));
   (new QTreeWidgetItem(planets))->setText(0, tr("Mercury"));
   (new QTreeWidgetItem(planets))->setText(0, tr("Venus"));
   QTreeWidgetItem *earthItem = new QTreeWidgetItem(planets);
   earthItem->setText(0, tr("Earth"));
   earthItem->setText(1, tr("Yes"));
   (new QTreeWidgetItem(planets))->setText(0, tr("Mars"));
   (new QTreeWidgetItem(planets))->setText(0, tr("Jupiter"));
   (new QTreeWidgetItem(planets))->setText(0, tr("Saturn"));
   (new QTreeWidgetItem(planets))->setText(0, tr("Uranus"));
   (new QTreeWidgetItem(planets))->setText(0, tr("Neptune"));
   (new QTreeWidgetItem(planets))->setText(0, tr("Pluto"));

} void MainWindow::findItems() {

   QString itemText = QInputDialog::getText(this, tr("Find Items"),
       tr("Text to find (including wildcards):"));
   if (itemText.isEmpty())
       return;

   QTreeWidgetItem *item;
   foreach (item, treeWidget->selectedItems())
       treeWidget->setItemSelected(item, false);

   QList<QTreeWidgetItem *> found = treeWidget->findItems(
       itemText, Qt::MatchWildcard);
   foreach (item, found) {
       treeWidget->setItemSelected(item, true);
       // Show the item->text(0) for each item.
   }

} void MainWindow::insertItem() {

   QTreeWidgetItem *currentItem = treeWidget->currentItem();
   if (!currentItem)
       return;
   QString itemText = QInputDialog::getText(this, tr("Insert Item"),
       tr("Input text for the new item:"));
   if (itemText.isEmpty())
       return;

   QTreeWidgetItem *parent = currentItem->parent();
   QTreeWidgetItem *newItem;
   if (parent)
       newItem = new QTreeWidgetItem(parent, treeWidget->currentItem());
   else

       newItem = new QTreeWidgetItem(treeWidget, treeWidget->currentItem());

   newItem->setText(0, itemText);

} void MainWindow::removeItem() {

   QTreeWidgetItem *currentItem = treeWidget->currentItem();
   if (!currentItem)
       return;

   QTreeWidgetItem *parent = currentItem->parent();
   int index;
   if (parent) {
       index = parent->indexOfChild(treeWidget->currentItem());
       delete parent->takeChild(index);
   } else {
       index = treeWidget->indexOfTopLevelItem(treeWidget->currentItem());
       delete treeWidget->takeTopLevelItem(index);

   }

} void MainWindow::sortAscending() {

   treeWidget->sortItems(0, Qt::AscendingOrder);

} void MainWindow::sortDescending() {

   treeWidget->sortItems(0, Qt::DescendingOrder);

} void MainWindow::updateMenus(QTreeWidgetItem *current) {

   insertAction->setEnabled(current != 0);
   removeAction->setEnabled(current != 0);

} void MainWindow::updateSortItems() {

   ascendingAction->setEnabled(!autoSortAction->isChecked());
   descendingAction->setEnabled(!autoSortAction->isChecked());
   treeWidget->setSortingEnabled(autoSortAction->isChecked());

}

1. include <QtGui>
2. include "mainwindow.h"

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

   QApplication app(argc, argv);
   MainWindow *window = new MainWindow;
   window->show();
   return app.exec();

}

 </source>

View a model in several views, and share a selection model

<source lang="cpp"> /****************************************************************************

• • Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
  • All rights reserved.
  • Contact: Nokia Corporation (qt-info@nokia.com)
  • This file is part of the documentation of the Qt Toolkit.
  • $QT_BEGIN_LICENSE:LGPL$
  • Commercial Usage
  • Licensees holding valid Qt Commercial licenses may use this file in
  • accordance with the Qt Commercial License Agreement provided with the
  • Software or, alternatively, in accordance with the terms contained in
  • a written agreement between you and Nokia.
  • GNU Lesser General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU Lesser
  • General Public License version 2.1 as published by the Free Software
  • Foundation and appearing in the file LICENSE.LGPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU Lesser General Public License version 2.1 requirements
  • will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  • In addition, as a special exception, Nokia gives you certain additional
  • rights. These rights are described in the Nokia Qt LGPL Exception
  • version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  • GNU General Public License Usage
  • Alternatively, this file may be used under the terms of the GNU
  • General Public License version 3.0 as published by the Free Software
  • Foundation and appearing in the file LICENSE.GPL included in the
  • packaging of this file. Please review the following information to
  • ensure the GNU General Public License version 3.0 requirements will be
  • met: http://www.gnu.org/copyleft/gpl.html.
  • If you have questions regarding the use of this file, please contact
  • Nokia at qt-info@nokia.com.
  • $QT_END_LICENSE$
  • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • /

/*

 main.cpp
 A simple example of how to view a model in several views, and share a
 selection model.

• /

1. include <QtGui>

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

   QApplication app(argc, argv);
   QSplitter *splitter = new QSplitter;

   QDirModel *model = new QDirModel;
  
   QTreeView *tree = new QTreeView(splitter);

   tree->setModel(model);
 
   tree->setRootIndex(model->index(QDir::currentPath()));

   QListView *list = new QListView(splitter);
   list->setModel(model);
   list->setRootIndex(model->index(QDir::currentPath()));

   QItemSelectionModel *selection = new QItemSelectionModel(model);
   tree->setSelectionModel(selection);
   list->setSelectionModel(selection);

   splitter->setWindowTitle("Two views onto the same directory model");
   splitter->show();
   return app.exec();

}

 </source>