workspace/khotkeys/kcm_hotkeys/hotkeys_model.cpp

   1 /*
   2    Copyright (C) 2008 Michael Jansen <kde@michael-jansen.biz>
   3
   4    This library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Library General Public
   6    License as published by the Free Software Foundation; either
   7    version 2 of the License, or (at your option) any later version.
   8
   9    This library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Library General Public License for more details.
  13
  14    You should have received a copy of the GNU Library General Public License
  15    along with this library; see the file COPYING.LIB.  If not, write to
  16    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17    Boston, MA 02110-1301, USA.
  18 */
  19
  20 #include "hotkeys_model.h"
  21
  22 #include "action_data/simple_action_data.h"
  23 #include "action_data/action_data_group.h"
  24
  25 #include <typeinfo>
  26
  27 #include <QMimeData>
  28
  29 #include <KDE/KDebug>
  30 #include <KDE/KLocale>
  31 #include <KDE/KIcon>
  32
  33 static KHotKeys::ActionDataBase *findElement(
  34         void *ptr
  35         ,KHotKeys::ActionDataGroup *root)
  36     {
  37     Q_ASSERT(root);
  38     if (!root) return NULL;
  39
  40     KHotKeys::ActionDataBase *match = NULL;
  41
  42     Q_FOREACH( KHotKeys::ActionDataBase *element, root->children())
  43         {
  44         if (ptr == element)
  45             {
  46             match = element;
  47             break;
  48             }
  49
  50         if (KHotKeys::ActionDataGroup *subGroup = dynamic_cast<KHotKeys::ActionDataGroup*>(element))
  51             {
  52             match = findElement(ptr, subGroup);
  53             if (match) break;
  54             }
  55         }
  56
  57     return match;
  58     }
  59
  60
  61
  62 KHotkeysModel::KHotkeysModel( QObject *parent )
  63     : QAbstractItemModel(parent)
  64      ,_settings()
  65      ,_actions(0)
  66     {}
  67
  68
  69 KHotkeysModel::~KHotkeysModel()
  70     {
  71     }
  72
  73
  74 QModelIndex KHotkeysModel::addGroup( const QModelIndex & parent )
  75     {
  76     KHotKeys::ActionDataGroup *list;
  77     if (parent.isValid())
  78         {
  79         list = indexToActionDataGroup(parent);
  80         }
  81     else
  82         {
  83         list = _actions;
  84         }
  85     Q_ASSERT(list);
  86
  87     beginInsertRows( parent, list->size(), list->size() );
  88
  89     /* KHotKeys:: ActionDataGroup *action = */
  90     new KHotKeys::ActionDataGroup( list, i18n("New Group"), i18n("Comment"));
  91
  92     endInsertRows();
  93     return index( list->size()-1, NameColumn, parent );
  94     }
  95
  96
  97 // Add a group
  98 QModelIndex KHotkeysModel::insertActionData(  KHotKeys::ActionDataBase *data, const QModelIndex & parent )
  99     {
 100     Q_ASSERT(data);
 101
 102     KHotKeys::ActionDataGroup *list;
 103     if (parent.isValid())
 104         {
 105         list = indexToActionDataGroup(parent);
 106         }
 107     else
 108         {
 109         list = _actions;
 110         }
 111     Q_ASSERT(list);
 112
 113     beginInsertRows( parent, list->size(), list->size() );
 114
 115     data->reparent(list);
 116
 117     endInsertRows();
 118     return index( list->size()-1, NameColumn, parent );
 119     }
 120
 121
 122 int KHotkeysModel::columnCount( const QModelIndex & ) const
 123     {
 124     return 2;
 125     }
 126
 127
 128 QVariant KHotkeysModel::data( const QModelIndex &index, int role ) const
 129     {
 130     // Check that the index is valid
 131     if (!index.isValid())
 132         {
 133         return QVariant();
 134         }
 135
 136     // Get the item behind the index
 137     KHotKeys::ActionDataBase *action = indexToActionDataBase(index);
 138     Q_ASSERT(action);
 139
 140     // Handle CheckStateRole
 141     if (role==Qt::CheckStateRole)
 142         {
 143         switch(index.column())
 144             {
 145             case 1:
 146                 // If the parent is enabled we display the state of the object.
 147                 // If the parent is disabled this object is disabled too.
 148                 if (action->parent() && !action->parent()->enabled())
 149                     {
 150                     return Qt::Unchecked;
 151                     }
 152                 return action->enabled()
 153                     ? Qt::Checked
 154                     : Qt::Unchecked;
 155
 156             default:
 157                 return QVariant();
 158             }
 159         }
 160
 161     // Display and Tooltip. Tooltip displays the complete name. That's nice if
 162     // there is not enough space
 163     if (role==Qt::DisplayRole || role==Qt::ToolTipRole)
 164         {
 165         switch (index.column())
 166             {
 167             case 0:
 168                 return action->name();
 169
 170             case 1:
 171                 return QVariant();
 172
 173             case 2:
 174                 return indexToActionDataGroup(index)!=0;
 175
 176             case 3:
 177                 {
 178                 const std::type_info &ti = typeid(*action);
 179                 if (ti==typeid(KHotKeys::SimpleActionData))
 180                     return KHotkeysModel::SimpleActionData;
 181                 else if (ti==typeid(KHotKeys::ActionDataGroup))
 182                     return KHotkeysModel::ActionDataGroup;
 183                 else
 184                     return KHotkeysModel::Other;
 185                 }
 186
 187             default:
 188                 return QVariant();
 189             }
 190         }
 191
 192     // Decoration role
 193     if (role==Qt::DecorationRole)
 194         {
 195         switch (index.column())
 196             {
 197             case 0:
 198                 return dynamic_cast<KHotKeys::ActionDataGroup*>(action)
 199                     ? KIcon("folder")
 200                     : QVariant();
 201
 202             default:
 203                 return QVariant();
 204             }
 205         }
 206
 207
 208     // For everything else
 209     return QVariant();
 210     }
 211
 212
 213 bool KHotkeysModel::dropMimeData(
 214         const QMimeData *data
 215         ,Qt::DropAction action
 216         ,int row
 217         ,int column
 218         ,const QModelIndex &parent)
 219     {
 220     kDebug()
 221         << parent.data(Qt::DisplayRole) << ","
 222         << row << ","
 223         << column;
 224
 225     // We only support move actions and our own mime type
 226     if ( (action!=Qt::CopyAction)
 227             || !data->hasFormat("application/x-pointer"))
 228         {
 229         kDebug() << "Drop not supported " << data->formats();
 230         return false;
 231         }
 232
 233     // Decode the stream
 234     QByteArray encodedData = data->data("application/x-pointer");
 235     QDataStream stream(&encodedData, QIODevice::ReadOnly);
 236     QList<quintptr> ptrs;
 237     while (!stream.atEnd())
 238         {
 239         quintptr ptr;
 240         stream >> ptr;
 241         ptrs << ptr;
 242         }
 243
 244     // No pointers, nothing to do
 245     if (ptrs.empty()) return false;
 246
 247     // Get the group we have to drop into
 248     QModelIndex dropIndex = parent;
 249     KHotKeys::ActionDataGroup *dropToGroup = indexToActionDataGroup(dropIndex);
 250     if (!dropToGroup)
 251         {
 252         dropIndex = parent.parent();
 253         dropToGroup = indexToActionDataGroup(dropIndex);
 254         }
 255
 256     kDebug() << "dropping to " << dropToGroup->name();
 257
 258     // Do the moves
 259     Q_FOREACH(quintptr ptr, ptrs)
 260         {
 261         KHotKeys::ActionDataBase *element = findElement(
 262                 reinterpret_cast<void*>(ptr),
 263                 _actions);
 264
 265         if (element) moveElement(element, dropToGroup);
 266         }
 267
 268     return true;
 269     }
 270
 271
 272 void KHotkeysModel::emitChanged(KHotKeys::ActionDataBase *item)
 273     {
 274     Q_ASSERT( item );
 275
 276     KHotKeys::ActionDataGroup *parent = item->parent();
 277     QModelIndex topLeft;
 278     QModelIndex bottomRight;
 279     if (!parent)
 280         {
 281         topLeft = createIndex( 0, 0, _actions );
 282         bottomRight = createIndex( 0, 0, _actions );
 283         }
 284     else
 285         {
 286         int row = parent->children().indexOf(item);
 287         topLeft = createIndex( row, 0, parent );
 288         bottomRight = createIndex( row, columnCount(topLeft), parent );
 289         }
 290
 291     emit dataChanged( topLeft, bottomRight );
 292     }
 293
 294
 295 Qt::ItemFlags KHotkeysModel::flags( const QModelIndex &index ) const
 296     {
 297     Qt::ItemFlags flags = QAbstractItemModel::flags(index);
 298
 299     if (!index.isValid())
 300         {
 301             return flags | Qt::ItemIsDropEnabled;
 302         }
 303
 304     switch (index.column())
 305         {
 306         case 1:
 307             return flags
 308                 | Qt::ItemIsUserCheckable
 309                 | Qt::ItemIsDragEnabled
 310                 | Qt::ItemIsDropEnabled;
 311
 312         default:
 313             return flags
 314                 | Qt::ItemIsEditable
 315                 | Qt::ItemIsDragEnabled
 316                 | Qt::ItemIsDropEnabled;
 317         }
 318     }
 319
 320
 321 // Get header data for section
 322 QVariant KHotkeysModel::headerData( int section, Qt::Orientation, int role ) const
 323     {
 324     if (role!=Qt::DisplayRole)
 325         {
 326         return QVariant();
 327         }
 328
 329     switch (section)
 330         {
 331         case 0:
 332             return QVariant(i18n("Name"));
 333
 334         case 1:
 335             return QVariant(i18n("Enabled"));
 336
 337         case 2:
 338             return QVariant(i18n("Type"));
 339
 340         default:
 341             return QVariant();
 342         }
 343     }
 344
 345
 346 QModelIndex KHotkeysModel::index( int row, int column, const QModelIndex &parent ) const
 347     {
 348     KHotKeys::ActionDataGroup *actionGroup = indexToActionDataGroup(parent);
 349     if (!actionGroup || row>=actionGroup->children().size() )
 350         {
 351         return QModelIndex();
 352         }
 353
 354     KHotKeys::ActionDataBase *action =  actionGroup->children().at(row);
 355     Q_ASSERT( action );
 356     return createIndex( row, column, action );
 357     }
 358
 359
 360 // Convert index to ActionDataBase
 361 KHotKeys::ActionDataBase *KHotkeysModel::indexToActionDataBase( const QModelIndex &index ) const
 362     {
 363     if (!index.isValid())
 364         {
 365         return _actions;
 366         }
 367     return static_cast<KHotKeys::ActionDataBase*>( index.internalPointer() );
 368     }
 369
 370
 371 // Convert index to ActionDataGroup
 372 KHotKeys::ActionDataGroup *KHotkeysModel::indexToActionDataGroup( const QModelIndex &index ) const
 373     {
 374     if (!index.isValid())
 375         {
 376         return _actions;
 377         }
 378     return dynamic_cast<KHotKeys::ActionDataGroup*>( indexToActionDataBase(index) );
 379     }
 380
 381
 382 void KHotkeysModel::load()
 383     {
 384     _settings.read_settings(true);
 385     _actions = _settings.actions();
 386     reset();
 387     }
 388
 389
 390 QMimeData *KHotkeysModel::mimeData(const QModelIndexList &indexes) const
 391     {
 392     QMimeData * mimeData = new QMimeData();
 393     QByteArray encodedData;
 394
 395     QDataStream stream(&encodedData, QIODevice::WriteOnly);
 396
 397     Q_FOREACH (QModelIndex index, indexes)
 398         {
 399         if (index.isValid() and index.column() == 0)
 400             {
 401             KHotKeys::ActionDataBase *element = indexToActionDataBase(index);
 402             // We use the pointer as id.
 403             stream << reinterpret_cast<quintptr>(element);
 404             }
 405         }
 406
 407     mimeData->setData("application/x-pointer", encodedData);
 408     return mimeData;
 409     }
 410
 411
 412 QStringList KHotkeysModel::mimeTypes() const
 413     {
 414     QStringList types;
 415     types << "application/x-pointer";
 416     return types;
 417     }
 418
 419
 420 bool KHotkeysModel::moveElement(
 421         KHotKeys::ActionDataBase *element
 422         ,KHotKeys::ActionDataGroup *newGroup
 423         ,int position)
 424     {
 425     Q_ASSERT(element && newGroup);
 426     if (!element || !newGroup) return false;
 427
 428     // TODO: Make this logic more advanced
 429     // We do not allow moving into our systemgroup
 430     if (newGroup->is_system_group()) return false;
 431
 432     // Make sure we don't move a group to one of it's children or
 433     // itself.
 434     KHotKeys::ActionDataGroup *tmp = newGroup;
 435     do  {
 436         if (tmp == element)
 437             {
 438             kDebug() << "Forbidden move" << tmp->name();
 439             return false;
 440             }
 441         }
 442         while((tmp = tmp->parent()));
 443
 444     KHotKeys::ActionDataGroup *oldParent = element->parent();
 445
 446     // TODO: Make this logic more advanced
 447     // We do not allow moving from our systemgroup
 448     if (oldParent->is_system_group()) return false;
 449
 450     // Remove it from it's current place
 451     kDebug() << "Removing from";
 452     kDebug() << KHotkeysModel::data(createIndex(0, 0, oldParent), Qt::DisplayRole);
 453     kDebug() << "item " << oldParent->children().indexOf(element);
 454     kDebug() << "from " << oldParent->children().size();
 455     beginRemoveRows(
 456             createIndex(0, 0, oldParent),
 457             oldParent->children().indexOf(element),
 458             oldParent->children().indexOf(element));
 459     element->reparent(0);
 460     endRemoveRows();
 461
 462     // Add to the new
 463     kDebug() << "Adding to";
 464     kDebug() << KHotkeysModel::data(createIndex(0, 0, newGroup), Qt::DisplayRole);
 465     kDebug() << "from " << newGroup->children().size();
 466     beginInsertRows(
 467             createIndex(0, 0, newGroup),
 468             newGroup->children().size(),
 469             newGroup->children().size());
 470     element->reparent(newGroup);
 471     endInsertRows();
 472
 473     return true;
 474     }
 475
 476
 477 // Get parent object for index
 478 QModelIndex KHotkeysModel::parent( const QModelIndex &index ) const
 479     {
 480     KHotKeys::ActionDataBase *action = indexToActionDataBase(index);
 481     if (!action)
 482         {
 483         return QModelIndex();
 484         }
 485
 486     KHotKeys::ActionDataGroup *parent = action->parent();
 487     if (!parent)
 488         {
 489         return QModelIndex();
 490         }
 491
 492     KHotKeys::ActionDataGroup *grandparent = parent->parent();
 493     if (!grandparent)
 494         {
 495         return QModelIndex();
 496         }
 497
 498     int row = grandparent->children().indexOf(parent);
 499     return createIndex( row, 0, parent );
 500     }
 501
 502
 503 // Remove rows ( items )
 504 bool KHotkeysModel::removeRows( int row, int count, const QModelIndex &parent )
 505     {
 506     Q_ASSERT( count == 1 );
 507
 508     beginRemoveRows( parent, row, row+count-1 );
 509
 510     KHotKeys::ActionDataGroup *list;
 511     if (parent.isValid())
 512         {
 513         list = indexToActionDataGroup(parent);
 514         }
 515     else
 516         {
 517         list = _actions;
 518         }
 519     Q_ASSERT(list);
 520
 521     KHotKeys::ActionDataBase *action = indexToActionDataBase(index(row,0,parent));
 522
 523     action->aboutToBeErased();
 524     delete action;
 525
 526     endRemoveRows();
 527     return true;
 528     }
 529
 530
 531 // Number of rows for index
 532 int KHotkeysModel::rowCount( const QModelIndex &index ) const
 533     {
 534     KHotKeys::ActionDataGroup *group = indexToActionDataGroup(index);
 535     if (!group)
 536         {
 537         return 0;
 538         }
 539
 540     return group->children().count();
 541     }
 542
 543
 544 void KHotkeysModel::save()
 545     {
 546     _settings.write_settings();
 547     }
 548
 549
 550 // Set data
 551 bool KHotkeysModel::setData( const QModelIndex &index, const QVariant &value, int role )
 552     {
 553
 554     if ( !index.isValid() || role != Qt::EditRole )
 555         {
 556         return false;
 557         }
 558
 559     KHotKeys::ActionDataBase *action = indexToActionDataBase(index);
 560     Q_ASSERT( action );
 561
 562     switch ( index.column() )
 563         {
 564         case NameColumn:
 565             {
 566             action->set_name( value.toString() );
 567             }
 568             break;
 569
 570         default:
 571             return false;
 572         }
 573
 574     emit dataChanged( index, index );
 575     return true;
 576     }
 577
 578 #include "moc_hotkeys_model.cpp"