|  | Home · All Classes · Main Classes · Grouped Classes · Modules · Functions |

# piecesmodel.cpp Example File
itemviews/puzzle/piecesmodel.cpp

        /****************************************************************************
        **
        ** Copyright (C) 2005-2006 Trolltech ASA. All rights reserved.
        **
        ** This file is part of the documentation of the Qt Toolkit.
        **
        ** This file may be used under the terms of the GNU General Public
        ** License version 2.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 GNU
        ** General Public Licensing requirements will be met:
        ** http://www.trolltech.com/products/qt/opensource.html
        **
        ** If you are unsure which license is appropriate for your use, please
        ** review the following information:
        ** http://www.trolltech.com/products/qt/licensing.html or contact the
        ** sales department at sales@trolltech.com.
        **
        ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
        ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        **
        ****************************************************************************/

        #include <QtGui>

        #include "piecesmodel.h"

        PiecesModel::PiecesModel(QObject *parent)
            : QAbstractListModel(parent)
        {
        }

        QVariant PiecesModel::data(const QModelIndex &index, int role) const
        {
            if (!index.isValid())
                return QVariant();

            if (role == Qt::DecorationRole)
                return QIcon(pixmaps.value(index.row()).scaled(60, 60,
                                 Qt::KeepAspectRatio, Qt::SmoothTransformation));
            else if (role == Qt::UserRole)
                return pixmaps.value(index.row());
            else if (role == Qt::UserRole + 1)
                return locations.value(index.row());

            return QVariant();
        }

        void PiecesModel::addPiece(const QPixmap &pixmap, const QPoint &location)
        {
            int row;
            if (int(2.0*rand()/(RAND_MAX+1.0)) == 1)
                row = 0;
            else
                row = pixmaps.size();

            beginInsertRows(QModelIndex(), row, row);
            pixmaps.insert(row, pixmap);
            locations.insert(row, location);
            endInsertRows();
        }

        Qt::ItemFlags PiecesModel::flags(const QModelIndex &index) const
        {
            if (index.isValid()) {
                return (Qt::ItemIsEnabled | Qt::ItemIsSelectable
                      | Qt::ItemIsDragEnabled | Qt::ItemIsSelectable | Qt::ItemIsDropEnabled);
            }

            return Qt::ItemIsEnabled | Qt::ItemIsDropEnabled;
        }

        bool PiecesModel::removeRows(int row, int count, const QModelIndex &parent)
        {
            if (parent.isValid())
                return false;

            if (row >= pixmaps.size() || row + count <= 0)
                return false;

            int beginRow = qMax(0, row);
            int endRow = qMin(row + count - 1, pixmaps.size() - 1);

            beginRemoveRows(parent, beginRow, endRow);

            while (beginRow <= endRow) {
                pixmaps.removeAt(beginRow);
                locations.removeAt(beginRow);
                ++beginRow;
            }

            endRemoveRows();
            return true;
        }

        QStringList PiecesModel::mimeTypes() const
        {
            QStringList types;
            types << "image/x-puzzle-piece";
            return types;
        }

        QMimeData *PiecesModel::mimeData(const QModelIndexList &indexes) const
        {
            QMimeData *mimeData = new QMimeData();
            QByteArray encodedData;

            QDataStream stream(&encodedData, QIODevice::WriteOnly);

            foreach (QModelIndex index, indexes) {
                if (index.isValid()) {
                    QPixmap pixmap = qVariantValue<QPixmap>(data(index, Qt::UserRole));
                    QPoint location = data(index, Qt::UserRole+1).toPoint();
                    stream << pixmap << location;
                }
            }

            mimeData->setData("image/x-puzzle-piece", encodedData);
            return mimeData;
        }

        bool PiecesModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
                                       int row, int column, const QModelIndex &parent)
        {
            if (!data->hasFormat("image/x-puzzle-piece"))
                return false;

            if (action == Qt::IgnoreAction)
                return true;

            if (column > 0)
                return false;

            int endRow;

            if (!parent.isValid() && row < 0)
                endRow = pixmaps.size();
            else if (!parent.isValid())
                endRow = qMin(row, pixmaps.size());
            else
                endRow = parent.row();

            QByteArray encodedData = data->data("image/x-puzzle-piece");
            QDataStream stream(&encodedData, QIODevice::ReadOnly);

            while (!stream.atEnd()) {
                QPixmap pixmap;
                QPoint location;
                stream >> pixmap >> location;

                beginInsertRows(QModelIndex(), endRow, endRow);
                pixmaps.insert(endRow, pixmap);
                locations.insert(endRow, location);
                endInsertRows();

                ++endRow;
            }

            return true;
        }

        int PiecesModel::rowCount(const QModelIndex &parent) const
        {
            if (parent.isValid())
                return 0;
            else
                return pixmaps.size();
        }

        Qt::DropActions PiecesModel::supportedDropActions() const
        {
            return Qt::CopyAction | Qt::MoveAction;
        }