messagelist/widget.cpp

   1 /*
   2     Copyright (c) 2009 Kevin Ottens <ervin@kde.org>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program 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
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17 */
  18
  19 #include "widget.h"
  20
  21 #include <akonadi/collection.h>
  22 #include <akonadi/item.h>
  23 #include <akonadi/itemcopyjob.h>
  24 #include <akonadi/itemmovejob.h>
  25
  26 #include "storagemodel.h"
  27 #include "core/messageitem.h"
  28 #include "core/view.h"
  29
  30 #include <QtCore/QTimer>
  31 #include <QtGui/QAction>
  32 #include <QtGui/QApplication>
  33 #include <QtGui/QDrag>
  34 #include <QtGui/QDragMoveEvent>
  35 #include <QtGui/QDropEvent>
  36
  37 #include <KDE/KDebug>
  38 #include <KDE/KIcon>
  39 #include <KDE/KIconLoader>
  40 #include <KDE/KLocale>
  41 #include <KDE/KMenu>
  42 #include <KDE/KXMLGUIClient>
  43 #include <KDE/KXMLGUIFactory>
  44 #include <KDE/KComboBox>
  45
  46 #include <Nepomuk/Tag>
  47
  48 namespace MessageList
  49 {
  50
  51 class Widget::Private
  52 {
  53 public:
  54   Private( Widget *owner )
  55     : q( owner ), mXmlGuiClient( 0 ) { }
  56
  57   Akonadi::Item::List selectionAsItems() const;
  58   Akonadi::Item itemForRow( int row ) const;
  59   KMime::Message::Ptr messageForRow( int row ) const;
  60
  61   Widget * const q;
  62
  63   int mLastSelectedMessage;
  64   KXMLGUIClient *mXmlGuiClient;
  65 };
  66
  67 } // namespace MessageList
  68
  69 using namespace MessageList;
  70 using namespace Akonadi;
  71
  72 Widget::Widget( QWidget *parent )
  73   : Core::Widget( parent ), d( new Private( this ) )
  74 {
  75   populateStatusFilterCombo();
  76 }
  77
  78 Widget::~Widget()
  79 {
  80   delete d;
  81 }
  82
  83 void Widget::setXmlGuiClient( KXMLGUIClient *xmlGuiClient )
  84 {
  85   d->mXmlGuiClient = xmlGuiClient;
  86 }
  87
  88 bool Widget::canAcceptDrag( const QDropEvent * e )
  89 {
  90   Collection::List collections = static_cast<const StorageModel*>( storageModel() )->displayedCollections();
  91
  92   if ( collections.size()!=1 )
  93     return false; // no folder here or too many (in case we can't decide where the drop will end)
  94
  95   const Collection target = collections.first();
  96
  97   if ( ( target.rights() & Collection::CanCreateItem ) == 0 )
  98     return false; // no way to drag into
  99
 100   const KUrl::List urls = KUrl::List::fromMimeData( e->mimeData() );
 101   foreach ( const KUrl &url, urls ) {
 102     const Collection collection = Collection::fromUrl( url );
 103     if ( collection.isValid() ) { // You're not supposed to drop collections here
 104       return false;
 105     } else { // Yay, this is an item!
 106       const QString type = url.queryItems()["type"]; // But does it have the right type?
 107       if ( !target.contentMimeTypes().contains( type ) ) {
 108         return false;
 109       }
 110     }
 111   }
 112
 113   return true;
 114 }
 115
 116 bool Widget::selectNextMessageItem( MessageList::Core::MessageTypeFilter messageTypeFilter,
 117                                     MessageList::Core::ExistingSelectionBehaviour existingSelectionBehaviour,
 118                                     bool centerItem,
 119                                     bool loop )
 120 {
 121   return view()->selectNextMessageItem( messageTypeFilter, existingSelectionBehaviour, centerItem, loop );
 122 }
 123
 124 bool Widget::selectPreviousMessageItem( MessageList::Core::MessageTypeFilter messageTypeFilter,
 125                                         MessageList::Core::ExistingSelectionBehaviour existingSelectionBehaviour,
 126                                         bool centerItem,
 127                                         bool loop )
 128 {
 129   return view()->selectPreviousMessageItem( messageTypeFilter, existingSelectionBehaviour, centerItem, loop );
 130 }
 131
 132 bool Widget::focusNextMessageItem( MessageList::Core::MessageTypeFilter messageTypeFilter, bool centerItem, bool loop )
 133 {
 134   return view()->focusNextMessageItem( messageTypeFilter, centerItem, loop );
 135 }
 136
 137 bool Widget::focusPreviousMessageItem( MessageList::Core::MessageTypeFilter messageTypeFilter, bool centerItem, bool loop )
 138 {
 139   return view()->focusNextMessageItem( messageTypeFilter, centerItem, loop );
 140 }
 141
 142 void Widget::selectFocusedMessageItem( bool centerItem )
 143 {
 144   view()->selectFocusedMessageItem( centerItem );
 145 }
 146
 147 bool Widget::selectFirstMessageItem( MessageList::Core::MessageTypeFilter messageTypeFilter, bool centerItem )
 148 {
 149   return view()->selectFirstMessageItem( messageTypeFilter, centerItem );
 150 }
 151
 152 void Widget::selectAll()
 153 {
 154   view()->setAllGroupsExpanded( true );
 155   view()->selectAll();
 156 }
 157
 158 void Widget::setCurrentThreadExpanded( bool expand )
 159 {
 160   view()->setCurrentThreadExpanded(expand );
 161 }
 162
 163 void Widget::setAllThreadsExpanded( bool expand )
 164 {
 165   view()->setAllThreadsExpanded( expand );
 166 }
 167
 168 void Widget::setAllGroupsExpanded( bool expand )
 169 {
 170   view()->setAllGroupsExpanded(expand);
 171 }
 172
 173 void Widget::focusQuickSearch()
 174 {
 175   view()->focusQuickSearch();
 176 }
 177
 178
 179 void Widget::fillMessageTagCombo( KComboBox * combo )
 180 {
 181   foreach( const Nepomuk::Tag &nepomukTag, Nepomuk::Tag::allTags() ) {
 182     QString iconName = "mail-tagged";
 183     const QString label = nepomukTag.label();
 184     if ( !nepomukTag.symbols().isEmpty() )
 185       iconName = nepomukTag.symbols().first();
 186     const QString id = nepomukTag.resourceUri().toString();
 187     combo->addItem( SmallIcon( iconName ), label, QVariant( id ) );
 188   }
 189 }
 190
 191 void Widget::viewMessageSelected( MessageList::Core::MessageItem *msg )
 192 {
 193   int row = -1;
 194   if ( msg ) {
 195     row = msg->currentModelIndexRow();
 196   }
 197
 198   if ( !msg || !msg->isValid() || !storageModel() ) {
 199     d->mLastSelectedMessage = -1;
 200     emit messageSelected( Item() );
 201     return;
 202   }
 203
 204   Q_ASSERT( row >= 0 );
 205
 206   d->mLastSelectedMessage = row;
 207
 208   emit messageSelected( d->itemForRow( row ) ); // this MAY be null
 209 }
 210
 211 void Widget::viewMessageActivated( MessageList::Core::MessageItem *msg )
 212 {
 213   Q_ASSERT( msg ); // must not be null
 214   Q_ASSERT( storageModel() );
 215
 216   if ( !msg->isValid() ) {
 217     return;
 218   }
 219
 220   int row = msg->currentModelIndexRow();
 221   Q_ASSERT( row >= 0 );
 222
 223   // The assert below may fail when quickly opening and closing a non-selected thread.
 224   // This will actually activate the item without selecting it...
 225   //Q_ASSERT( d->mLastSelectedMessage == row );
 226
 227   if ( d->mLastSelectedMessage != row ) {
 228     // Very ugly. We are activating a non selected message.
 229     // This is very likely a double click on the plus sign near a thread leader.
 230     // Dealing with mLastSelectedMessage here would be expensive: it would involve releasing the last selected,
 231     // emitting signals, handling recursion... ugly.
 232     // We choose a very simple solution: double clicking on the plus sign near a thread leader does
 233     // NOT activate the message (i.e open it in a toplevel window) if it isn't previously selected.
 234     return;
 235   }
 236
 237   emit messageActivated( d->itemForRow( row ) ); // this MAY be null
 238 }
 239
 240 void Widget::viewSelectionChanged()
 241 {
 242   emit selectionChanged();
 243   if ( !currentMessageItem() ) {
 244     emit messageSelected( Item() );
 245   }
 246 }
 247
 248 void Widget::viewMessageListContextPopupRequest( const QList< MessageList::Core::MessageItem * > &selectedItems,
 249                                                  const QPoint &globalPos )
 250 {
 251   if ( !d->mXmlGuiClient )
 252     return;
 253
 254   QMenu *popup = static_cast<QMenu*>( d->mXmlGuiClient->factory()->container(
 255                                         QLatin1String( "akonadi_messagelist_contextmenu" ),
 256                                         d->mXmlGuiClient ) );
 257   if ( popup ) {
 258     popup->exec( globalPos );
 259   }
 260 }
 261
 262 void Widget::viewMessageStatusChangeRequest( MessageList::Core::MessageItem *msg, const KPIM::MessageStatus &set, const KPIM::MessageStatus &clear )
 263 {
 264   Q_ASSERT( msg ); // must not be null
 265   Q_ASSERT( storageModel() );
 266
 267   if ( !msg->isValid() ) {
 268     return;
 269   }
 270
 271   int row = msg->currentModelIndexRow();
 272   Q_ASSERT( row >= 0 );
 273
 274   Item item = d->itemForRow( row );
 275   Q_ASSERT( item.isValid() );
 276
 277   emit messageStatusChangeRequest( item, set, clear );
 278 }
 279
 280 void Widget::viewGroupHeaderContextPopupRequest( MessageList::Core::GroupHeaderItem *ghi, const QPoint &globalPos )
 281 {
 282   Q_UNUSED( ghi );
 283
 284   KMenu menu( this );
 285
 286   QAction *act;
 287
 288   menu.addSeparator();
 289
 290   act = menu.addAction( i18n( "Expand All Groups" ) );
 291   connect( act, SIGNAL( triggered( bool ) ),
 292            view(), SLOT( slotExpandAllGroups() ) );
 293
 294   act = menu.addAction( i18n( "Collapse All Groups" ) );
 295   connect( act, SIGNAL( triggered( bool ) ),
 296            view(), SLOT( slotCollapseAllGroups() ) );
 297
 298   menu.exec( globalPos );
 299 }
 300
 301 void Widget::viewDragEnterEvent( QDragEnterEvent *e )
 302 {
 303   if ( !canAcceptDrag( e ) ) {
 304     e->ignore();
 305     return;
 306   }
 307
 308   e->accept();
 309 }
 310
 311 void Widget::viewDragMoveEvent( QDragMoveEvent *e )
 312 {
 313   if ( !canAcceptDrag( e ) ) {
 314     e->ignore();
 315     return;
 316   }
 317
 318   e->accept();
 319 }
 320
 321 enum DragMode
 322 {
 323   DragCopy,
 324   DragMove,
 325   DragCancel
 326 };
 327
 328 void Widget::viewDropEvent( QDropEvent *e )
 329 {
 330   if ( !canAcceptDrag( e ) ) {
 331     e->ignore();
 332     return;
 333   }
 334
 335   KUrl::List urls = KUrl::List::fromMimeData( e->mimeData() );
 336   if ( urls.isEmpty() ) {
 337     kWarning() << "Could not decode drag data!";
 338     e->ignore();
 339     return;
 340   }
 341
 342   e->accept();
 343
 344   int action;
 345   if ( ( e->possibleActions() & Qt::MoveAction ) == 0 ) { // We can't move anyway
 346     action = DragCopy;
 347   } else {
 348     action = DragCancel;
 349     int keybstate = QApplication::keyboardModifiers();
 350     if ( keybstate & Qt::CTRL ) {
 351       action = DragCopy;
 352
 353     } else if ( keybstate & Qt::SHIFT ) {
 354       action = DragMove;
 355
 356     } else {
 357       KMenu menu;
 358       QAction *moveAction = menu.addAction( KIcon( "go-jump"), i18n( "&Move Here" ) );
 359       QAction *copyAction = menu.addAction( KIcon( "edit-copy" ), i18n( "&Copy Here" ) );
 360       menu.addSeparator();
 361       menu.addAction( KIcon( "dialog-cancel" ), i18n( "C&ancel" ) );
 362
 363       QAction *menuChoice = menu.exec( QCursor::pos() );
 364       if ( menuChoice == moveAction ) {
 365         action = DragMove;
 366       } else if ( menuChoice == copyAction ) {
 367         action = DragCopy;
 368       } else {
 369         action = DragCancel;
 370       }
 371     }
 372   }
 373
 374   Collection::List collections = static_cast<const StorageModel*>( storageModel() )->displayedCollections();
 375   Collection target = collections.first();
 376   Item::List items;
 377   foreach ( const KUrl &url, urls ) {
 378     items << Item::fromUrl( url );
 379   }
 380
 381   if ( action == DragCopy ) {
 382     new ItemCopyJob( items, target, this );
 383   } else if ( action == DragMove ) {
 384     new ItemMoveJob( items, target, this );
 385   }
 386 }
 387
 388
 389 void Widget::viewStartDragRequest()
 390 {
 391   Collection::List collections = static_cast<const StorageModel*>( storageModel() )->displayedCollections();
 392
 393   if ( collections.isEmpty() )
 394     return; // no folder here
 395
 396   QList<Item> items = d->selectionAsItems();
 397   if ( items.isEmpty() )
 398     return;
 399
 400   bool readOnly = false;
 401
 402   foreach ( const Collection c, collections ) {
 403     // We won't be able to remove items from this collection
 404     if ( ( c.rights() & Collection::CanDeleteItem ) == 0 ) {
 405       // So the drag will be read-only
 406       readOnly = true;
 407     }
 408   }
 409
 410   KUrl::List urls;
 411   foreach ( const Item i, items ) {
 412     urls << i.url( Item::UrlWithMimeType );
 413   }
 414
 415   QMimeData *mimeData = new QMimeData;
 416   urls.populateMimeData( mimeData );
 417
 418   QDrag *drag = new QDrag( view()->viewport() );
 419   drag->setMimeData( mimeData );
 420
 421   // Set pixmap
 422   QPixmap pixmap;
 423   if( items.size() == 1 ) {
 424     pixmap = QPixmap( DesktopIcon("mail-message", KIconLoader::SizeSmall) );
 425   } else {
 426     pixmap = QPixmap( DesktopIcon("document-multiple", KIconLoader::SizeSmall) );
 427   }
 428
 429   // Calculate hotspot (as in Konqueror)
 430   if( !pixmap.isNull() ) {
 431     drag->setHotSpot( QPoint( pixmap.width() / 2, pixmap.height() / 2 ) );
 432     drag->setPixmap( pixmap );
 433   }
 434
 435   if ( readOnly )
 436     drag->exec( Qt::CopyAction );
 437   else
 438     drag->exec( Qt::CopyAction | Qt::MoveAction );
 439 }
 440
 441 Item::List Widget::Private::selectionAsItems() const
 442 {
 443   Item::List res;
 444   QList<Core::MessageItem *> selection = q->view()->selectionAsMessageItemList();
 445
 446   foreach ( Core::MessageItem *mi, selection ) {
 447     Item i = itemForRow( mi->currentModelIndexRow() );
 448     Q_ASSERT( i.isValid() );
 449     res << i;
 450   }
 451
 452   return res;
 453 }
 454
 455 Item Widget::Private::itemForRow( int row ) const
 456 {
 457   return static_cast<const StorageModel*>( q->storageModel() )->itemForRow( row );
 458 }
 459
 460 KMime::Message::Ptr Widget::Private::messageForRow( int row ) const
 461 {
 462   return static_cast<const StorageModel*>( q->storageModel() )->messageForRow( row );
 463 }
 464
 465 Item Widget::currentItem() const
 466 {
 467   Core::MessageItem *mi = view()->currentMessageItem();
 468
 469   if ( mi == 0 ) {
 470     return Item();
 471   }
 472
 473   return d->itemForRow( mi->currentModelIndexRow() );
 474 }
 475
 476 KMime::Message::Ptr Widget::currentMessage() const
 477 {
 478   Core::MessageItem *mi = view()->currentMessageItem();
 479
 480   if ( mi == 0 ) {
 481     return KMime::Message::Ptr();
 482   }
 483
 484   return d->messageForRow( mi->currentModelIndexRow() );
 485 }
 486
 487
 488 QList<KMime::Message::Ptr > Widget::selectionAsMessageList( bool includeCollapsedChildren ) const
 489 {
 490   QList<KMime::Message::Ptr> lstMiPtr;
 491   QList<Core::MessageItem *> lstMi = view()->selectionAsMessageItemList( includeCollapsedChildren );
 492   if ( lstMi.isEmpty() ) {
 493      return lstMiPtr;
 494   }
 495   foreach( Core::MessageItem *it, lstMi ) {
 496     lstMiPtr.append( d->messageForRow( it->currentModelIndexRow() ) );
 497   }
 498   return lstMiPtr;
 499 }
 500
 501 QList<Akonadi::Item> Widget::selectionAsMessageItemList( bool includeCollapsedChildren ) const
 502 {
 503   QList<Item> lstMiPtr;
 504   QList<Core::MessageItem *> lstMi = view()->selectionAsMessageItemList( includeCollapsedChildren );
 505   if ( lstMi.isEmpty() ) {
 506      return lstMiPtr;
 507   }
 508   foreach( Core::MessageItem *it, lstMi ) {
 509     lstMiPtr.append( d->itemForRow( it->currentModelIndexRow() ) );
 510   }
 511   return lstMiPtr;
 512 }
 513
 514 QList<Akonadi::Item> Widget::currentThreadAsMessageList() const
 515 {
 516   QList<Item> lstMiPtr;
 517   QList<Core::MessageItem *> lstMi = view()->currentThreadAsMessageItemList();
 518   if ( lstMi.isEmpty() ) {
 519     return lstMiPtr;
 520   }
 521   foreach( Core::MessageItem *it, lstMi ) {
 522     lstMiPtr.append( d->itemForRow( it->currentModelIndexRow() ) );
 523   }
 524   return lstMiPtr;
 525 }
 526
 527
 528 KPIM::MessageStatus Widget::currentFilterStatus() const
 529 {
 530   return view()->currentFilterStatus();
 531 }
 532
 533 QString Widget::currentFilterSearchString() const
 534 {
 535   return view()->currentFilterSearchString();
 536 }
 537
 538
 539 bool Widget::isThreaded() const
 540 {
 541   return view()->isThreaded();
 542 }
 543
 544 bool Widget::selectionEmpty() const
 545 {
 546   return view()->selectionEmpty();
 547 }
 548
 549 bool Widget::getSelectionStats(
 550   Akonadi::Item::List &selectedItems,
 551   Akonadi::Item::List &selectedVisibleItems,
 552   bool * allSelectedBelongToSameThread,
 553   bool includeCollapsedChildren ) const
 554 {
 555   if ( !storageModel() )
 556     return false;
 557
 558   selectedItems.clear();
 559   selectedVisibleItems.clear();
 560
 561   QList< Core::MessageItem * > selected = view()->selectionAsMessageItemList( includeCollapsedChildren );
 562
 563   Core::MessageItem * topmost = 0;
 564
 565   *allSelectedBelongToSameThread = true;
 566
 567   foreach( Core::MessageItem *it, selected ) {
 568     const Item item = d->itemForRow( it->currentModelIndexRow() );
 569     selectedItems.append( item );
 570     if ( view()->isDisplayedWithParentsExpanded( it ) )
 571       selectedVisibleItems.append( item );
 572     if ( topmost == 0 )
 573       topmost = ( *it ).topmostMessage();
 574     else {
 575       if ( topmost != ( *it ).topmostMessage() )
 576         *allSelectedBelongToSameThread = false;
 577     }
 578   }
 579   return true;
 580 }
 581
 582 void Widget::deletePersistentSet( MessageList::Core::MessageItemSetReference ref )
 583 {
 584   view()->deletePersistentSet( ref );
 585 }
 586
 587 void Widget::markMessageItemsAsAboutToBeRemoved( MessageList::Core::MessageItemSetReference ref, bool bMark )
 588 {
 589   QList< Core::MessageItem * > lstPersistent = view()->persistentSetCurrentMessageItemList( ref );
 590   if ( !lstPersistent.isEmpty() )
 591     view()->markMessageItemsAsAboutToBeRemoved( lstPersistent, bMark );
 592 }
 593
 594 QList<Akonadi::Item> Widget::itemListFromPersistentSet( MessageList::Core::MessageItemSetReference ref )
 595 {
 596   QList<Akonadi::Item> lstItem;
 597   QList< Core::MessageItem * > refList = view()->persistentSetCurrentMessageItemList( ref );
 598   if ( !refList.isEmpty() ) {
 599     foreach( Core::MessageItem *it, refList ) {
 600       lstItem.append( d->itemForRow( it->currentModelIndexRow() ) );
 601     }
 602   }
 603   return lstItem;
 604 }
 605
 606
 607 MessageList::Core::MessageItemSetReference Widget::selectionAsPersistentSet( bool includeCollapsedChildren ) const
 608 {
 609   QList<Core::MessageItem *> lstMi = view()->selectionAsMessageItemList( includeCollapsedChildren );
 610   if ( lstMi.isEmpty() ) {
 611      return -1;
 612   }
 613   return view()->createPersistentSet( lstMi );
 614 }
 615
 616 MessageList::Core::MessageItemSetReference Widget::currentThreadAsPersistentSet() const
 617 {
 618   QList<Item> lstMiPtr;
 619   QList<Core::MessageItem *> lstMi = view()->currentThreadAsMessageItemList();
 620   if ( lstMi.isEmpty() ) {
 621     return -1;
 622   }
 623   return view()->createPersistentSet( lstMi );
 624 }