File indexing completed on 2024-04-21 15:03:00

 /***************************************************************************
  * actioncollectionmodel.cpp
  * This file is part of the KDE project
  * copyright (C) 2006-2007 by Sebastian Sauer (mail@dipe.org)
  *
  * This program 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 program 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 program; see the file COPYING.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  ***************************************************************************/
 
 #include "actioncollectionmodel.h"
 #include "krossui_debug.h"
 
 #include <kross/core/action.h>
 #include <kross/core/actioncollection.h>
 #include <kross/core/manager.h>
 
 #include <klocalizedstring.h>
 #include <QDebug>
 
 #include <QEvent>
 #include <QMimeData>
 #include <QPointer>
 
 using namespace Kross;
 
 /******************************************************************************
  * ActionCollectionModel
  */
 
 namespace Kross
 {
 
 /// \internal d-pointer class.
 class ActionCollectionModel::Private
 {
 public:
     QPointer<ActionCollection> collection;
     Mode mode;
 };
 
 }
 
 ActionCollectionModel::ActionCollectionModel(QObject *parent, ActionCollection *collection, Mode mode)
     : QAbstractItemModel(parent)
     , d(new Private())
 {
     //krossdebug( QString( "ActionCollectionModel::ActionCollectionModel:") );
     d->collection = collection ? collection : Kross::Manager::self().actionCollection();
     d->mode = mode;
     //setSupportedDragActions(Qt::MoveAction);
 
     //ActionCollection propagates signals to parent
     QObject::connect(d->collection, SIGNAL(dataChanged(Action*)), this, SLOT(slotDataChanged(Action*)));
     QObject::connect(d->collection, SIGNAL(dataChanged(ActionCollection*)), this, SLOT(slotDataChanged(ActionCollection*)));
 
     QObject::connect(d->collection, SIGNAL(collectionToBeInserted(ActionCollection*,ActionCollection*)), this, SLOT(slotCollectionToBeInserted(ActionCollection*,ActionCollection*)));
     QObject::connect(d->collection, SIGNAL(collectionInserted(ActionCollection*,ActionCollection*)), this, SLOT(slotCollectionInserted(ActionCollection*,ActionCollection*)));
     QObject::connect(d->collection, SIGNAL(collectionToBeRemoved(ActionCollection*,ActionCollection*)), this, SLOT(slotCollectionToBeRemoved(ActionCollection*,ActionCollection*)));
     QObject::connect(d->collection, SIGNAL(collectionRemoved(ActionCollection*,ActionCollection*)), this, SLOT(slotCollectionRemoved(ActionCollection*,ActionCollection*)));
 
     QObject::connect(d->collection, SIGNAL(actionToBeInserted(Action*,ActionCollection*)), this, SLOT(slotActionToBeInserted(Action*,ActionCollection*)));
     QObject::connect(d->collection, SIGNAL(actionInserted(Action*,ActionCollection*)), this, SLOT(slotActionInserted(Action*,ActionCollection*)));
     QObject::connect(d->collection, SIGNAL(actionToBeRemoved(Action*,ActionCollection*)), this, SLOT(slotActionToBeRemoved(Action*,ActionCollection*)));
     QObject::connect(d->collection, SIGNAL(actionRemoved(Action*,ActionCollection*)), this, SLOT(slotActionRemoved(Action*,ActionCollection*)));
 }
 
 ActionCollectionModel::~ActionCollectionModel()
 {
     delete d;
 }
 
 ActionCollection *ActionCollectionModel::rootCollection() const
 {
     return d->collection;
 }
 
 int ActionCollectionModel::rowNumber(ActionCollection *collection) const
 {
     Q_ASSERT(collection != nullptr);
     ActionCollection *par = collection->parentCollection();
     Q_ASSERT(par != nullptr);
     int row = par->collections().indexOf(collection->objectName()) + par->actions().count();
     return row;
 }
 
 QModelIndex ActionCollectionModel::indexForCollection(ActionCollection *collection) const
 {
     if (collection == d->collection) {
         return QModelIndex();
     }
     return createIndex(rowNumber(collection), 0, collection->parentCollection());
 }
 
 QModelIndex ActionCollectionModel::indexForAction(Action *act) const
 {
     ActionCollection *coll = static_cast<ActionCollection *>(act->parent());
     return createIndex(coll->actions().indexOf(act), 0, coll);
 }
 
 void ActionCollectionModel::slotCollectionToBeInserted(ActionCollection *child, ActionCollection *parent)
 {
     //krossdebug( QString( "ActionCollectionModel::slotCollectionToBeInserted: %1 %2" ).arg( child->name() ).arg( parent->name( ) )  );
     Q_ASSERT(parent);
     Q_UNUSED(child)
     int row = parent->actions().count() + parent->collections().count(); // we assume child is appended!!
     QModelIndex parIdx = indexForCollection(parent);
     beginInsertRows(parIdx, row, row);
 }
 
 void ActionCollectionModel::slotCollectionInserted(ActionCollection *, ActionCollection *)
 {
     //krossdebug( QString( "ActionCollectionModel::slotCollectionInserted: %1 %2" ).arg( child->name( ) ).arg( parent->name( ) )  );
     endInsertRows();
 }
 
 void ActionCollectionModel::slotCollectionToBeRemoved(ActionCollection *child, ActionCollection *parent)
 {
     //krossdebug( QString( "ActionCollectionModel::slotCollectionToBeRemoved: %1 %2" ).arg( child->name() ).arg( parent->name() ) );
     int row = rowNumber(child);
     QModelIndex parIdx = indexForCollection(parent);
     beginRemoveRows(parIdx, row, row);
 }
 
 void ActionCollectionModel::slotCollectionRemoved(ActionCollection *, ActionCollection *)
 {
     //krossdebug( QString( "ActionCollectionModel::slotCollectionRemoved: %1 %2" ).arg( child->name() ).arg( parent->name() ) );
     endRemoveRows();
 }
 
 void ActionCollectionModel::slotActionToBeInserted(Action *child, ActionCollection *parent)
 {
     //krossdebug( QString( "ActionCollectionModel::slotActionInserted: %1 %2" ).arg( child->name() ).arg( parent->name() ) );
     Q_ASSERT(parent);
     Q_UNUSED(child)
     int row = parent->actions().count(); // assume child is appended to actions!!
     QModelIndex parIdx = indexForCollection(parent);
     beginInsertRows(parIdx, row, row);
 }
 
 void ActionCollectionModel::slotActionInserted(Action *, ActionCollection *)
 {
     //krossdebug( QString( "ActionCollectionModel::slotActionInserted: %1 %2" ).arg( child->name() ).arg( parent->name() ) );
     endInsertRows();
 }
 
 void ActionCollectionModel::slotActionToBeRemoved(Action *child, ActionCollection *parent)
 {
     //krossdebug( QString( "ActionCollectionModel::slotActionToBeRemoved: %1 %2" ).arg( child->name() ).arg( parent->name() ) );
     Q_ASSERT(parent);
     int row = parent->actions().indexOf(child);
     QModelIndex parIdx = indexForCollection(parent);
     beginRemoveRows(parIdx, row, row);
 }
 
 void ActionCollectionModel::slotActionRemoved(Action *, ActionCollection *)
 {
     //krossdebug( QString( "ActionCollectionModel::slotActionRemoved: %1 %2" ).arg( child->name() ).arg( parent->name() ) );
     endRemoveRows();
 }
 
 //NOTE: not used anymore, remove?
 void ActionCollectionModel::slotUpdated()
 {
     //emit layoutAboutToBeChanged();
     //emit layoutChanged();
 }
 
 void ActionCollectionModel::slotDataChanged(ActionCollection *coll)
 {
     //krossdebug( QString( "ActionCollectionModel::slotDataChanged: %1" ).arg( coll->name() ) );
     QModelIndex idx = indexForCollection(coll);
     emit dataChanged(idx, idx);   // NOTE: change if more than one column
 }
 
 void ActionCollectionModel::slotDataChanged(Action *act)
 {
     //krossdebug( QString( "ActionCollectionModel::slotDataChanged: %1" ).arg( act->name() ) );
     QModelIndex idx = indexForAction(act);
     emit dataChanged(idx, idx);   // NOTE: change if more than one column
 }
 
 Action *ActionCollectionModel::action(const QModelIndex &index)
 {
     ActionCollection *par = static_cast<ActionCollection *>(index.internalPointer());
     if (par == nullptr || index.row() >= par->actions().count()) {
         return nullptr;
     }
     return par->actions().value(index.row());
 }
 
 ActionCollection *ActionCollectionModel::collection(const QModelIndex &index)
 {
     ActionCollection *par = static_cast<ActionCollection *>(index.internalPointer());
     if (par == nullptr) {
         return nullptr;
     }
     int row = index.row() - par->actions().count();
     if (row < 0) {
         return nullptr; // this is probably an action
     }
     return par->collection(par->collections().value(row));
 }
 
 int ActionCollectionModel::columnCount(const QModelIndex &) const
 {
     return 1;
 }
 
 int ActionCollectionModel::rowCount(const QModelIndex &index) const
 {
     if (action(index)) {
         return 0;
     }
     ActionCollection *par = index.isValid() ? collection(index) : d->collection.data();
     Q_ASSERT_X(par, "ActionCollectionModel::rowCount", "index is not an action nor a collection");
     if (!par) {
         qWarning() << "index is not an action nor a collection" << index;
         return 0;
     }
     int rows = par->actions().count() + par->collections().count();
     return rows;
 }
 
 QModelIndex ActionCollectionModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (! hasIndex(row, column, parent)) {
         return QModelIndex();
     }
     ActionCollection *par = parent.isValid() ? collection(parent) : d->collection.data();
     if (par == nullptr) {
         // safety: may happen if parent index is an action (ModelTest tests this)
         return QModelIndex();
     }
     return createIndex(row, column, par);
 }
 
 QModelIndex ActionCollectionModel::parent(const QModelIndex &index) const
 {
     if (! index.isValid()) {
         return QModelIndex();
     }
     ActionCollection *par = static_cast<ActionCollection *>(index.internalPointer());
     Q_ASSERT(par != nullptr);
     if (par == d->collection) {
         return QModelIndex();
     }
     return createIndex(rowNumber(par), 0, par->parentCollection());
 }
 
 Qt::ItemFlags ActionCollectionModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags flags = QAbstractItemModel::flags(index);
     if (! index.isValid()) {
         return Qt::ItemIsDropEnabled | flags;
     }
 
     flags |= Qt::ItemIsSelectable;
     //flags |= Qt::ItemIsEditable;
     flags |= Qt::ItemIsDragEnabled;
     flags |= Qt::ItemIsDropEnabled;
 
     if ((index.column() == 0) && (d->mode & UserCheckable)) {
         flags |= Qt::ItemIsUserCheckable;
     }
     return flags;
 }
 
 QVariant ActionCollectionModel::data(const QModelIndex &index, int role) const
 {
     if (index.isValid()) {
         Action *act = action(index);
         if (act) {
             switch (role) {
             case Qt::DecorationRole: {
                 if (d->mode & Icons)
                     if (! act->iconName().isEmpty()) {
                         return act->icon();
                     }
             } break;
             case Qt::DisplayRole:
                 return KLocalizedString::removeAcceleratorMarker(act->text());
             case Qt::ToolTipRole: // fall through
             case Qt::WhatsThisRole: {
                 if (d->mode & ToolTips) {
                     const QString file = QFileInfo(act->file()).fileName();
                     return QString("<qt><b>%1</b><br>%2</qt>")
                            .arg(file.isEmpty() ? act->name() : file)
                            .arg(act->description());
                 }
             } break;
             case Qt::CheckStateRole: {
                 if (d->mode & UserCheckable) {
                     return act->isEnabled() ? Qt::Checked : Qt::Unchecked;
                 }
             } break;
             default: break;
             }
             return QVariant();
         }
         ActionCollection *coll = collection(index);
         if (coll) {
             switch (role) {
             case Qt::DecorationRole: {
                 if (d->mode & Icons)
                     if (! coll->iconName().isEmpty()) {
                         return coll->icon();
                     }
             } break;
             case Qt::DisplayRole:
                 return coll->text();
             case Qt::ToolTipRole: // fall through
             case Qt::WhatsThisRole: {
                 if (d->mode & ToolTips) {
                     return QString("<qt><b>%1</b><br>%2</qt>").arg(coll->text()).arg(coll->description());
                 }
             } break;
             case Qt::CheckStateRole: {
                 if (d->mode & UserCheckable) {
                     return coll->isEnabled() ? Qt::Checked : Qt::Unchecked;
                 }
             } break;
             default: break;
             }
             return QVariant();
         }
     }
     return QVariant();
 }
 
 bool ActionCollectionModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     Q_UNUSED(value);
     if (! index.isValid() /*|| ! (d->mode & UserCheckable)*/) {
         return false;
     }
 
     Action *act = action(index);
     if (act) {
         switch (role) {
         //case Qt::EditRole: act->setText( value.toString() ); break;
         case Qt::CheckStateRole: act->setEnabled(! act->isEnabled()); break;
         default: return false;
         }
         return false;
     }
     ActionCollection *coll = collection(index);
     if (coll) {
         switch (role) {
         //case Qt::EditRole: item->coll->setText( value.toString() ); break;
         case Qt::CheckStateRole: coll->setEnabled(! coll->isEnabled()); break;
         default: return false;
         }
         return false;
     }
     //emit dataChanged(index, index);
     return true;
 }
 
 bool ActionCollectionModel::insertRows(int row, int count, const QModelIndex &parent)
 {
     qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::insertRows: row=" << row << " count=" << count;
     if (! parent.isValid()) {
         return false;
     }
 
     ActionCollection *coll = collection(parent);
     if (coll) {
         qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::insertRows: parentindex is ActionCollection with name=" << coll->name();
     } else {
         Action *act = action(parent);
         if (act) {
             qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::insertRows: parentindex is Action with name=" << act->name();
         }
     }
     return QAbstractItemModel::insertRows(row, count, parent);
 }
 
 bool ActionCollectionModel::removeRows(int row, int count, const QModelIndex &parent)
 {
     qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::removeRows: row=" << row << " count=" << count;
     return QAbstractItemModel::removeRows(row, count, parent);
 }
 
 bool ActionCollectionModel::insertColumns(int column, int count, const QModelIndex &parent)
 {
     qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::insertColumns: column=" << column << " count=" << count;
     return QAbstractItemModel::insertColumns(column, count, parent);
 }
 
 bool ActionCollectionModel::removeColumns(int column, int count, const QModelIndex &parent)
 {
     qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::removeColumns: column=" << column << " count=" << count;
     return QAbstractItemModel::removeColumns(column, count, parent);
 }
 
 QStringList ActionCollectionModel::mimeTypes() const
 {
     //krossdebug( QString("ActionCollectionModel::mimeTypes") );
     return QStringList() << "application/vnd.text.list";
 }
 
 QString fullPath(const QModelIndex &index)
 {
     if (! index.isValid()) {
         return QString();
     }
     QString n;
     Action *a = ActionCollectionModel::action(index);
     if (a) {
         n = a->name();
     } else {
         ActionCollection *c = ActionCollectionModel::collection(index);
         if (c) {
             n = c->name() + '/';
             if (! n.endsWith('/')) {
                 n += '/';
             }
         }
     }
     ActionCollection *par = static_cast<ActionCollection *>(index.internalPointer());
     for (ActionCollection *p = par; p != nullptr; p = par->parentCollection()) {
         QString s = p->name();
         if (! s.endsWith('/')) {
             s += '/';
         }
         n = s + n;
     }
     return n;
 }
 
 QMimeData *ActionCollectionModel::mimeData(const QModelIndexList &indexes) const
 {
     //krossdebug( QString("ActionCollectionModel::mimeData") );
     QMimeData *mimeData = new QMimeData();
     QByteArray encodedData;
 
     QDataStream stream(&encodedData, QIODevice::WriteOnly);
     foreach (const QModelIndex &index, indexes) {
         //if( ! index.isValid() ) continue;
         //QString text = data(index, Qt::DisplayRole).toString();
         QString path = fullPath(index);
         if (! path.isNull()) {
             stream << path;
         }
     }
 
     mimeData->setData("application/vnd.text.list", encodedData);
     return mimeData;
 }
 
 bool ActionCollectionModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
     qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::dropMimeData: row=" << row << " col=" << column;
     if (action == Qt::IgnoreAction) {
         return true;
     }
     if (! data->hasFormat("application/vnd.text.list")) {
         return false;
     }
     if (column > 0) {
         return false;
     }
 
     qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::dropMimeData: ENCODED DATA:";
     QByteArray encodedData = data->data("application/vnd.text.list");
     QDataStream stream(&encodedData, QIODevice::ReadOnly);
     QStringList newItems;
     int rows = 0;
     while (! stream.atEnd()) {
         QString text;
         stream >> text;
         newItems << text;
         qCDebug(KROSS_UI_LOG) << QString("  %1 \"%2\"").arg(rows).arg(text);
         ++rows;
     }
 
     //FIXME: return false for now since insertRows/removeRows need to be implemented before!
     //return false;
 
     /*
     int beginRow;
     if( row != -1 )
         beginRow = row;
     else if( parent.isValid() )
         beginRow = parent.row();
     else
         beginRow = rowCount( QModelIndex() );
     krossdebug( QString("ActionCollectionModel::dropMimeData: beginRow=%1").arg(beginRow) );
     */
 
     QModelIndex targetindex = index(row, column, parent);
     ActionCollection *coll = collection(targetindex);
     if (coll) {
         qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::dropMimeData: parentindex is ActionCollection with name=" << coll->name();
     } else {
         Action *act = this->action(targetindex);
         if (act) {
             qCDebug(KROSS_UI_LOG) << "ActionCollectionModel::dropMimeData: parentindex is Action with name=" << act->name();
         }
     }
     return false;
     //return QAbstractItemModel::dropMimeData(data, action, row, column, parent);
 }
 
 Qt::DropActions ActionCollectionModel::supportedDropActions() const
 {
     return Qt::CopyAction | Qt::MoveAction | Qt::TargetMoveAction;
     //return Qt::CopyAction | Qt::MoveAction | Qt::TargetMoveAction | Qt::LinkAction;
 }
 
 /******************************************************************************
  * ActionCollectionProxyModel
  */
 
 ActionCollectionProxyModel::ActionCollectionProxyModel(QObject *parent, ActionCollectionModel *model)
     : QSortFilterProxyModel(parent)
 {
     setSourceModel(model ? model : new ActionCollectionModel(this));
     setFilterCaseSensitivity(Qt::CaseInsensitive);
     setDynamicSortFilter(true);
 }
 
 ActionCollectionProxyModel::~ActionCollectionProxyModel()
 {
 }
 
 void ActionCollectionProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
 {
     Q_ASSERT(dynamic_cast< ActionCollectionModel * >(sourceModel));
     QSortFilterProxyModel::setSourceModel(sourceModel);
 }
 
 bool ActionCollectionProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
 {
     //krossdebug( QString( "ActionCollectionProxyModel::filterAcceptsRow: row=%1 parentrow=%2" ).arg( source_row ).arg( source_parent.row() ) );
     QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
     if (! index.isValid()) {
         return false;
     }
 
     Action *action = ActionCollectionModel::action(index);
     if (action) {
         return action->isEnabled() && QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
     }
     ActionCollection *collection = ActionCollectionModel::collection(index);
     if (collection) {
         return collection->isEnabled();
     }
     return true;
 }
 
 #include "moc_actioncollectionmodel.cpp"