File indexing completed on 2024-05-26 16:15:04

 /* This file is part of the KDE project
  * Copyright (C) 2007 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2008 Fredy Yanardi <fyanardi@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KoPADocumentModel.h"
 
 #include "KoPADocument.h"
 #include "KoPAPageBase.h"
 #include <KoShapePainter.h>
 #include <KoShapeManager.h>
 #include <KoShapeContainer.h>
 #include <KoToolManager.h>
 #include <KoPageLayout.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 #include <KoSelection.h>
 #include <KoShapeLayer.h>
 #include <KoShapeGroup.h>
 #include <KoShapeGroupCommand.h>
 #include <KoShapeUngroupCommand.h>
 #include <KoShapeRenameCommand.h>
 #include <KoZoomHandler.h>
 #include <KoPAOdfPageSaveHelper.h>
 #include <KoDrag.h>
 #include <KoPAPastePage.h>
 #include <KoIcon.h>
 
 #include <klocalizedstring.h>
 #include <PageAppDebug.h>
 
 #include <QMimeData>
 #include <QApplication>
 #include <QClipboard>
 #include <QMenu>
 #include <QPainterPath>
 
 #include "commands/KoPAPageMoveCommand.h"
 
 KoPADocumentModel::KoPADocumentModel( QObject* parent, KoPADocument *document )
 : KoDocumentSectionModel( parent )
 , m_document(0)
 , m_master(false)
 , m_lastContainer( 0 )
 {
     setDocument( document );
 }
 
 Qt::DropActions KoPADocumentModel::supportedDragActions() const
 {
     return Qt::MoveAction;
 }
 
 void KoPADocumentModel::update()
 {
     emit layoutAboutToBeChanged();
     emit layoutChanged();
     if (m_document) {
         dataChanged(index(0, 0), index(m_document->pageCount() - 1, columnCount() - 1));
     }
 }
 
 int KoPADocumentModel::rowCount( const QModelIndex &parent ) const
 {
     if (!m_document) {
         return 0;
     }
 
     // check if parent is root node
     if ( ! parent.isValid() ) {
         return m_document->pages(m_master).count();
     }
 
     Q_ASSERT(parent.model() == this);
     Q_ASSERT(parent.internalPointer());
 
     KoShapeContainer *parentShape = dynamic_cast<KoShapeContainer*>( (KoShape*)parent.internalPointer() );
     if ( ! parentShape ) {
         return 0;
     }
 
     return parentShape->shapeCount();
 }
 
 int KoPADocumentModel::columnCount( const QModelIndex & ) const
 {
     return 1;
 }
 
 QModelIndex KoPADocumentModel::index( int row, int column, const QModelIndex &parent ) const
 {
     if ( !m_document ) {
         return QModelIndex();
     }
 
     // check if parent is root node
     if ( ! parent.isValid() ) {
         if ( row >= 0 && row < m_document->pages(m_master).count() ) {
             return createIndex( row, column, m_document->pages(m_master).at(row) );
         } else {
             return QModelIndex();
         }
     }
 
     Q_ASSERT(parent.model() == this);
     Q_ASSERT(parent.internalPointer());
 
     KoShapeContainer *parentShape = dynamic_cast<KoShapeContainer*>( (KoShape*)parent.internalPointer() );
     if ( ! parentShape ) {
         return QModelIndex();
     }
 
     if ( row < parentShape->shapeCount() ) {
         return createIndex( row, column, childFromIndex( parentShape, row ) );
     } else {
         return QModelIndex();
     }
 }
 
 QModelIndex KoPADocumentModel::parent( const QModelIndex &child ) const
 {
     // check if child is root node
     if ( ! child.isValid() || !m_document ) {
         return QModelIndex();
     }
 
     Q_ASSERT(child.model() == this);
     Q_ASSERT(child.internalPointer());
 
     KoShape *childShape = static_cast<KoShape*>( child.internalPointer() );
     if ( ! childShape ) {
         return QModelIndex();
     }
 
     // get the children's parent shape
     KoShapeContainer *parentShape = childShape->parent();
     if ( ! parentShape ) {
         return QModelIndex();
     }
 
     // get the grandparent to determine the row of the parent shape
     KoShapeContainer *grandParentShape = parentShape->parent();
     if ( ! grandParentShape ) {
         KoPAPageBase* page = dynamic_cast<KoPAPageBase*>( parentShape);
         return createIndex( m_document->pages(m_master).indexOf( page ), 0, parentShape );
     }
 
     return createIndex( indexFromChild( grandParentShape, parentShape ), 0, parentShape );
 }
 
 QVariant KoPADocumentModel::data( const QModelIndex &index, int role ) const
 {
     if ( ! index.isValid() || !m_document ) {
         return QVariant();
     }
 
     Q_ASSERT(index.model() == this);
     Q_ASSERT(index.internalPointer());
 
     KoShape *shape = static_cast<KoShape*>( index.internalPointer() );
 
     switch (role)
     {
         case Qt::DisplayRole:
         {
             QString name = shape->name();
             if ( name.isEmpty() ) {
                 if ( dynamic_cast<KoPAPageBase *>( shape ) ) {
                     if (m_document->pageType() == KoPageApp::Slide ) {
                         name = i18n("Slide %1",  m_document->pageIndex(dynamic_cast<KoPAPageBase *>(shape)) + 1);
                     } else {
                         name = i18n("Page  %1", m_document->pageIndex(dynamic_cast<KoPAPageBase *>(shape)) + 1);
                     }
                 } else if ( dynamic_cast<KoShapeLayer*>( shape ) ) {
                     name = i18n("Layer") + QString(" (%1)").arg(shape->zIndex());
                 } else if ( dynamic_cast<KoShapeGroup*>( shape ) ) {
                     name = i18n("Group") + QString(" (%1)").arg(shape->zIndex());
                 } else {
                     name = i18n("Shape") + QString(" (%1)").arg(shape->zIndex());
                 }
             }
             return name;
         }
         case Qt::DecorationRole: return QVariant();//return shape->icon();
         case Qt::EditRole: return shape->name();
         case Qt::SizeHintRole:
         {
             KoPAPageBase *page = dynamic_cast<KoPAPageBase*>(shape);
             if (page) { // return actual page size for page
                 KoPageLayout layout = page->pageLayout();
                 return QSize(layout.width, layout.height);
             }
             else
                 return shape->size();
         }
         case ActiveRole:
         {
             KoCanvasController * canvasController = KoToolManager::instance()->activeCanvasController();
             KoSelection * selection = canvasController->canvas()->shapeManager()->selection();
             if ( ! selection ) {
                 return false;
             }
 
             /* KoShapeLayer *layer = dynamic_cast<KoShapeLayer*>( shape );
             if ( layer )
                 return (layer == selection->activeLayer() );
             else */
             return selection->isSelected( shape );
         }
         case PropertiesRole: return QVariant::fromValue( properties( shape ) );
         case AspectRatioRole:
         {
             QTransform matrix = shape->absoluteTransformation( 0 );
             QRectF bbox = matrix.mapRect( shape->outline().boundingRect() );
             KoShapeContainer *container = dynamic_cast<KoShapeContainer*>( shape );
             if ( container ) {
                 bbox = QRectF();
                 foreach( KoShape* shape, container->shapes() ) {
                     bbox = bbox.united( shape->outline().boundingRect() );
                 }
             }
             return qreal(bbox.width()) / bbox.height();
         }
         default:
             if (role >= int(BeginThumbnailRole)) {
                 return createThumbnail( shape, QSize( role - int(BeginThumbnailRole), role - int(BeginThumbnailRole) ) );
             } else {
                 return QVariant();
             }
     }
 }
 
 Qt::ItemFlags KoPADocumentModel::flags(const QModelIndex &index) const
 {
     if ( !m_document ) {
         return 0;
     }
 
     if ( ! index.isValid() ) {
         return Qt::ItemIsEnabled | Qt::ItemIsDropEnabled;
     }
 
     Q_ASSERT(index.model() == this);
     Q_ASSERT(index.internalPointer());
 
     Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEditable;
     //if ( dynamic_cast<KoShapeContainer*>( (KoShape*)index.internalPointer() ) )
         flags |= Qt::ItemIsDropEnabled;
     return flags;
 }
 
 bool KoPADocumentModel::setData(const QModelIndex &index, const QVariant &value, int role )
 {
     if ( ! index.isValid() || !m_document ) {
         return false;
     }
 
     Q_ASSERT(index.model() == this);
     Q_ASSERT(index.internalPointer());
 
     KoShape *shape = static_cast<KoShape*>( index.internalPointer() );
     switch (role)
     {
         case Qt::DisplayRole:
         case Qt::EditRole:
         {
             KUndo2Command * cmd = new KoShapeRenameCommand( shape, value.toString() );
             if (dynamic_cast<KoPAPageBase *>(shape)) {
                 if (m_document->pageType() == KoPageApp::Slide) {
                     cmd->setText(kundo2_i18n("Rename Slide"));
                 } else {
                     cmd->setText(kundo2_i18n("Rename Page"));
                 }
             }
             else if (dynamic_cast<KoShapeLayer *>(shape)) {
                 cmd->setText(kundo2_i18n("Rename Layer"));
             }
             m_document->addCommand( cmd );
         }   break;
         case PropertiesRole:
             setProperties( shape, value.value<PropertyList>());
             break;
         case ActiveRole:
             /* if (value.toBool())
             {
                 KoCanvasController * canvasController = KoToolManager::instance()->activeCanvasController();
                 KoSelection * selection = canvasController->canvas()->shapeManager()->selection();
 
                 KoShapeLayer *layer = dynamic_cast<KoShapeLayer*>( shape );
                 if ( layer && selection ) {
                     selection->setActiveLayer( layer );
                 }
             } */
             break;
         default:
             return false;
     }
 
     emit dataChanged( index, index );
     return true;
 }
 
 KoDocumentSectionModel::PropertyList KoPADocumentModel::properties( KoShape* shape ) const
 {
     PropertyList l;
 
     if (KoPAPageBase *page = dynamic_cast<KoPAPageBase *>(shape)) {
         // The idea is to display the page-number so users know what page-number/slide-number
         // the shape has also in the case the slide has a name (in which case it's not named
         // "Slide [slide-number]" any longer.
         // Maybe we should better use KoTextPage::visiblePageNumber here?
         l << Property(i18n("Slide"), QString::number(m_document->pageIndex(page) + 1));
     }
 
     l << Property(i18n("Visible"), koIcon("layer-visible-on"), koIcon("layer-visible-off"), shape->isVisible());
     l << Property(i18n("Locked"), koIcon("object-locked"), koIcon("object-unlocked"), shape->isGeometryProtected());
     return l;
 }
 
 void KoPADocumentModel::setProperties( KoShape* shape, const PropertyList &properties )
 {
     bool oldVisibleState = shape->isVisible();
     bool oldLockedState = shape->isGeometryProtected();
 
     shape->setVisible( properties.at( 0 ).state.toBool() );
     shape->setGeometryProtected( properties.at( 1 ).state.toBool() );
 
     if ( ( oldVisibleState != shape->isVisible() ) || ( oldLockedState != shape->isGeometryProtected() ) ) {
         shape->update();
     }
 }
 
 QImage KoPADocumentModel::createThumbnail( KoShape* shape, const QSize &thumbSize ) const
 {
     QSize size(thumbSize.width(), thumbSize.height());
     KoShapePainter shapePainter;
 
     KoPAPageBase *page = dynamic_cast<KoPAPageBase*>(shape);
     if (page) { // We create a thumbnail with actual width / height ratio for page
         KoZoomHandler zoomHandler;
         KoPageLayout layout = page->pageLayout();
         qreal ratio = (zoomHandler.resolutionX() * layout.width) / (zoomHandler.resolutionY() * layout.height);
         if ( ratio > 1 ) {
             size.setHeight( size.width() / ratio );
         } else {
             size.setWidth( size.height() * ratio );
         }
         QPixmap pixmap = m_document->pageThumbnail( page, size );
         return pixmap.toImage();
     }
 
     QList<KoShape*> shapes;
     KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
     if (container) {
         shapes = container->shapes();
     }
     shapes.append(shape);
 
     shapePainter.setShapes( shapes );
 
     QImage thumb( size, QImage::Format_RGB32 );
     // draw the background of the thumbnail
     thumb.fill( QColor( Qt::white ).rgb() );
     shapePainter.paint(thumb);
 
     return thumb;
 }
 
 KoShape * KoPADocumentModel::childFromIndex( KoShapeContainer *parent, int row ) const
 {
     return parent->shapes().at(row);
 }
 
 int KoPADocumentModel::indexFromChild( KoShapeContainer *parent, KoShape *child ) const
 {
     if ( !m_document ) {
         return 0;
     }
 
     return parent->shapes().indexOf( child );
 }
 
 Qt::DropActions KoPADocumentModel::supportedDropActions () const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 QStringList KoPADocumentModel::mimeTypes() const
 {
     QStringList types;
     types << QLatin1String("application/x-kopalayermodeldatalist");
     return types;
 }
 
 QMimeData * KoPADocumentModel::mimeData( const QModelIndexList & indexes ) const
 {
     // check if there is data to encode
     if ( ! indexes.count() ) {
         return 0;
     }
 
     // check if we support a format
     QStringList types = mimeTypes();
     if ( types.isEmpty() ) {
         return 0;
     }
 
     QMimeData *data = new QMimeData();
     QString format = types[0];
     QByteArray encoded;
     QDataStream stream(&encoded, QIODevice::WriteOnly);
 
     // encode the data
     QModelIndexList::ConstIterator it = indexes.begin();
     for( ; it != indexes.end(); ++it) {
         stream << QVariant::fromValue( qulonglong( it->internalPointer() ) );
     }
 
     data->setData(format, encoded);
     return data;
 }
 
 bool KoPADocumentModel::dropMimeData( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent )
 {
     Q_UNUSED( row );
     Q_UNUSED( column );
 
     // check if the action is supported
     if ( ! data || action != Qt::MoveAction ) {
         return false;
     }
     // check if the format is supported
     QStringList types = mimeTypes();
     if ( types.isEmpty() ) {
         return false;
     }
     QString format = types[0];
     if ( ! data->hasFormat(format) ) {
         return false;
     }
 
     QByteArray encoded = data->data( format );
     QDataStream stream(&encoded, QIODevice::ReadOnly);
     QList<KoShape*> shapes;
 
     // decode the data
     while( ! stream.atEnd() ) {
         QVariant v;
         stream >> v;
         shapes.append( static_cast<KoShape*>( (void*)v.value<qulonglong>() ) );
     }
 
     QList<KoShape*> toplevelShapes;
     QList<KoShapeLayer*> layers;
     QList<KoPAPageBase *> pages;
     // remove shapes having its parent in the list
     // and separate the layers
     foreach( KoShape * shape, shapes ) {
         // check whether the selection contains page
         // by the UI rules, the selection should contains page only
         KoPAPageBase *page = dynamic_cast<KoPAPageBase *>( shape );
         if ( page ) {
             pages.append( page );
             continue;
         }
 
         KoShapeContainer *parentShape = shape->parent();
         bool hasParentInList = false;
         while ( parentShape ) {
             if ( shapes.contains( parentShape ) ) {
                 hasParentInList = true;
                 break;
             }
             parentShape = parentShape->parent();
         }
         if ( hasParentInList ) {
             continue;
         }
 
         KoShapeLayer * layer = dynamic_cast<KoShapeLayer*>( shape );
         if ( layer ) {
             layers.append( layer );
         } else {
             toplevelShapes.append( shape );
         }
     }
 
     // dropping to root, only page(s) is allowed
     if (!parent.isValid()) {
         if ( !pages.isEmpty() ) {
             if ( row < 0 ) {
                 return false;
             }
             KoPAPageBase *after = (row != 0) ? m_document->pageByIndex(row - 1, false) : 0;
             debugPageApp << "KoPADocumentModel::dropMimeData parent = root, dropping page(s) as root, moving page(s)";
             return doDrop(pages, after, action);
         }
         else {
             debugPageApp << "KoPADocumentModel::dropMimeData parent = root, dropping non-page as root, returning false";
             return false;
         }
     }
     else if (parent.isValid() && !pages.isEmpty()){
         if (parent.row() < 0) {
             return false;
         }
         KoPAPageBase *after;
         if ((m_document->pageIndex(pages.first()) - 1) == parent.row()) {
             after = (parent.row() != 0) ? m_document->pageByIndex(parent.row() - 1, false) : 0;
         }
         else {
             after = (parent.row() > -1) ? m_document->pageByIndex(parent.row(), false) : 0;
         }
         return doDrop(pages, after, action);
     }
 
     KoShape *shape = static_cast<KoShape*>( parent.internalPointer() );
     KoShapeContainer * container = dynamic_cast<KoShapeContainer*>( shape );
     if ( container ) {
         KoShapeGroup * group = dynamic_cast<KoShapeGroup*>( container );
         if ( group ) {
             debugPageApp <<"KoPADocumentModel::dropMimeData parent = group";
             if ( ! toplevelShapes.count() ) {
                 return false;
             }
 
             emit layoutAboutToBeChanged();
             beginInsertRows( parent, group->shapeCount(), group->shapeCount()+toplevelShapes.count() );
 
             KUndo2Command * cmd = new KUndo2Command();
             cmd->setText( kundo2_i18n("Reparent shapes") );
 
             foreach( KoShape * shape, toplevelShapes ) {
                 new KoShapeUngroupCommand( shape->parent(), QList<KoShape*>() << shape, QList<KoShape*>(), cmd );
             }
 
             new KoShapeGroupCommand( group, toplevelShapes, cmd );
             KoCanvasController * canvasController = KoToolManager::instance()->activeCanvasController();
             canvasController->canvas()->addCommand( cmd );
 
             endInsertRows();
             emit layoutChanged();
         } else {
             debugPageApp <<"KoPADocumentModel::dropMimeData parent = container";
             if ( toplevelShapes.count() ) {
                 emit layoutAboutToBeChanged();
                 beginInsertRows( parent, container->shapeCount(), container->shapeCount()+toplevelShapes.count() );
 
                 KUndo2Command * cmd = new KUndo2Command();
                 cmd->setText( kundo2_i18n("Reparent shapes") );
 
                 QList<bool> clipped;
                 QList<bool> inheritsTransform;
                 foreach( KoShape * shape, toplevelShapes ) {
                     if ( ! shape->parent() ) {
                         clipped.append( false );
                         inheritsTransform.append(false);
                         continue;
                     }
 
                     clipped.append( shape->parent()->isClipped( shape ) );
                     inheritsTransform.append(shape->parent()->inheritsTransform(shape));
                     new KoShapeUngroupCommand( shape->parent(), QList<KoShape*>() << shape, QList<KoShape*>(), cmd );
                 }
                 // shapes are dropped on a container, so add them to the container
                 new KoShapeGroupCommand(container, toplevelShapes, clipped, inheritsTransform, cmd);
                 KoCanvasController * canvasController = KoToolManager::instance()->activeCanvasController();
                 canvasController->canvas()->addCommand( cmd );
 
                 endInsertRows();
                 emit layoutChanged();
             } else if ( layers.count() ) {
                 KoShapeLayer * layer = dynamic_cast<KoShapeLayer*>( container );
                 if ( ! layer ) {
                     return false;
                 }
 
                 // TODO layers are dropped on a layer, so change layer ordering
                 return false;
             }
         }
     } else {
         debugPageApp <<"KoPADocumentModel::dropMimeData parent = shape";
         if ( ! toplevelShapes.count() ) {
             return false;
         }
 
         // TODO shapes are dropped on a shape, reorder them
         return false;
     }
 
     return true;
 }
 
 QModelIndex KoPADocumentModel::parentIndexFromShape( const KoShape * child )
 {
     if ( !m_document ) {
         return QModelIndex();
     }
 
     // check if child shape is a layer, and return invalid model index if it is
     const KoShapeLayer *childlayer = dynamic_cast<const KoShapeLayer*>( child );
     if ( childlayer ) {
         return QModelIndex();
     }
 
     // get the children's parent shape
     KoShapeContainer *parentShape = child->parent();
     if ( ! parentShape ) {
         return QModelIndex();
     }
 
     // check if the parent is a layer
     KoShapeLayer *parentLayer = dynamic_cast<KoShapeLayer*>( parentShape );
 
 
     if ( parentLayer ) {
         KoPAPageBase * page = dynamic_cast<KoPAPageBase*>( parentLayer->parent() );
         if ( page ) {
             return createIndex( m_document->pages(m_master).count() - 1 - m_document->pages(m_master).indexOf( page ), 0, parentLayer );
         }
     }
     // get the grandparent to determine the row of the parent shape
     KoShapeContainer *grandParentShape = parentShape->parent();
     if ( ! grandParentShape ) {
         return QModelIndex();
     }
 
     return createIndex( indexFromChild( grandParentShape, parentShape ), 0, parentShape );
 }
 
 void KoPADocumentModel::setDocument( KoPADocument* document )
 {
     if (m_document == document) {
         return;
     }
 
     if (m_document) {
         disconnect( m_document, SIGNAL(pageAdded(KoPAPageBase*)), this, SLOT(update()) );
         disconnect( m_document, SIGNAL(pageRemoved(KoPAPageBase*)), this, SLOT(update()) );
         disconnect( m_document, SIGNAL(update(KoPAPageBase*)), this, SLOT(update()) );
         disconnect( m_document, SIGNAL(shapeAdded(KoShape*)), this, SLOT(update()) );
         disconnect( m_document, SIGNAL(shapeRemoved(KoShape*)), this, SLOT(update()) );
     }
 
     beginResetModel();
     m_document = document;
     endResetModel();
 
     if ( m_document ) {
         connect( m_document, SIGNAL(pageAdded(KoPAPageBase*)), this, SLOT(update()) );
         connect( m_document, SIGNAL(pageRemoved(KoPAPageBase*)), this, SLOT(update()) );
         connect( m_document, SIGNAL(update(KoPAPageBase*)), this, SLOT(update()) );
         connect( m_document, SIGNAL(shapeAdded(KoShape*)), this, SLOT(update()) );
         connect( m_document, SIGNAL(shapeRemoved(KoShape*)), this, SLOT(update()) );
     }
 }
 
 void KoPADocumentModel::setMasterMode(bool master)
 {
     m_master = master;
     update(); // Rebuild the model
 }
 
 bool KoPADocumentModel::doDrop(QList<KoPAPageBase *> pages, KoPAPageBase *pageAfter, Qt::DropAction action)
 {
     Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
     bool enableMove = true;
 
     foreach (KoPAPageBase *page, pages) {
         if (!m_document->pages(false).contains(page)) {
             KoPAPageBase *newPage = page;
             pages.replace(pages.indexOf(page), newPage);
             enableMove = false;
             break;
         }
     }
 
     if (((modifiers & Qt::ControlModifier) == 0) &&
         ((modifiers & Qt::ShiftModifier) == 0)) {
            QMenu popup;
            QString seq = QKeySequence(Qt::ShiftModifier).toString();
            seq.chop(1);
            QAction *popupMoveAction = new QAction(i18n("&Move Here") + '\t' + seq, this);
            popupMoveAction->setIcon(koIcon("go-jump"));
            seq = QKeySequence(Qt::ControlModifier).toString();
            seq.chop(1);
            QAction *popupCopyAction = new QAction(i18n("&Copy Here") + '\t' + seq, this);
            popupCopyAction->setIcon(koIcon("edit-copy"));
            seq = QKeySequence( Qt::ControlModifier + Qt::ShiftModifier ).toString();
            seq.chop(1);
            QAction *popupCancelAction = new QAction(i18n("C&ancel") + '\t' + QKeySequence(Qt::Key_Escape).toString(), this);
            popupCancelAction->setIcon(koIcon("process-stop"));
 
            if (enableMove) {
                popup.addAction(popupMoveAction);
            }
            popup.addAction(popupCopyAction);
            popup.addSeparator();
            popup.addAction(popupCancelAction);
 
            QAction *result = popup.exec(QCursor::pos());
 
            if (result == popupCopyAction) {
                action = Qt::CopyAction;
            } else if (result == popupMoveAction) {
                action = Qt::MoveAction;
            } else {
                return false;
            }
     } else if ((modifiers & Qt::ControlModifier) != 0) {
         action = Qt::CopyAction;
     } else if ((modifiers & Qt::ShiftModifier) != 0) {
         action = Qt::MoveAction;
     } else {
         return false;
     }
 
     switch (action) {
     case Qt::MoveAction: {
        KoPAPageMoveCommand *command = new KoPAPageMoveCommand(m_document, pages, pageAfter);
        m_document->addCommand( command );
        if ((m_document->pageIndex(pageAfter) + pages.count()) < m_document->pageCount()) {
             emit requestPageSelection(m_document->pageIndex(pageAfter) + 1, pages.count());
        }
        return true;
     }
     case Qt::CopyAction: {
        // Copy Pages
        KoPAOdfPageSaveHelper saveHelper(m_document, pages);
        KoDrag drag;
        drag.setOdf(KoOdf::mimeType(m_document->documentType()), saveHelper);
        drag.addToClipboard();
        //Paste Pages
        const QMimeData * data = QApplication::clipboard()->mimeData();
        static const KoOdf::DocumentType documentTypes[] = { KoOdf::Graphics, KoOdf::Presentation };
 
        for (unsigned int i = 0; i < sizeof(documentTypes) / sizeof(KoOdf::DocumentType); ++i) {
            if (data->hasFormat( KoOdf::mimeType(documentTypes[i]))) {
                KoPAPastePage paste(m_document, pageAfter);
                paste.paste(documentTypes[i], data);
                break;
            }
        }
        emit requestPageSelection(m_document->pageIndex(pageAfter) + 1, sizeof(documentTypes) / sizeof(KoOdf::DocumentType) - 1);
        return true;
     }
     default:
        qDebug("Unknown action: %d ", (int)action);
        return false;
     }
     return false;
 }