You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
709 lines
26 KiB
709 lines
26 KiB
/* |
|
Copyright (c) 2007 Volker Krause <vkrause@kde.org> |
|
|
|
This program is free software; you can redistribute it and/or modify |
|
it under the terms of the GNU 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 General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program; if not, write to the Free Software |
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|
*/ |
|
|
|
#include "messageactions.h" |
|
|
|
#include "settings/globalsettings.h" |
|
#include "kmreaderwin.h" |
|
#include "kmkernel.h" |
|
#include "kernel/mailkernel.h" |
|
#include "kmmainwidget.h" |
|
#include "util.h" |
|
#include "kmcommands.h" |
|
#include "customtemplatesmenu.h" |
|
|
|
#include "messagecore/widgets/annotationdialog.h" |
|
#include "messagecore/settings/globalsettings.h" |
|
#include "messagecore/misc/mailinglist.h" |
|
#include "messagecore/helpers/messagehelpers.h" |
|
#include "messageviewer/viewer/csshelper.h" |
|
#include "messageviewer/settings/globalsettings.h" |
|
|
|
#include <Nepomuk2/Resource> |
|
|
|
#include <akonadi/itemfetchjob.h> |
|
#include <akonadi/kmime/messageparts.h> |
|
#include <KAction> |
|
#include <KActionMenu> |
|
#include <KActionCollection> |
|
#include <KToggleAction> |
|
#include <KDebug> |
|
#include <KLocale> |
|
#include <KXMLGUIClient> |
|
#include <KStandardDirs> |
|
#include <KRun> |
|
#include <KMenu> |
|
#include <KUriFilterData> |
|
#include <KToolInvocation> |
|
#include <KUriFilter> |
|
#include <KStringHandler> |
|
#include <KPrintPreview> |
|
|
|
#include <QVariant> |
|
#include <qwidget.h> |
|
#include <akonadi/collection.h> |
|
#include <Akonadi/Monitor> |
|
#include <util/mailutil.h> |
|
#include <nepomukutil/asyncnepomukresourceretriever.h> |
|
#include <nepomuk2/resourcemanager.h> |
|
#include <Soprano/Vocabulary/NAO> |
|
|
|
using namespace KMail; |
|
|
|
MessageActions::MessageActions( KActionCollection *ac, QWidget *parent ) |
|
: QObject( parent ), |
|
mParent( parent ), |
|
mMessageView( 0 ), |
|
mRedirectAction( 0 ), |
|
mPrintPreviewAction( 0 ), |
|
mAsynNepomukRetriever( new MessageCore::AsyncNepomukResourceRetriever( QVector<QUrl>() << Soprano::Vocabulary::NAO::annotation().toString() |
|
<< Soprano::Vocabulary::NAO::description().toString(), this ) ), |
|
mCustomTemplatesMenu( 0 ) |
|
{ |
|
mReplyActionMenu = new KActionMenu( KIcon("mail-reply-sender"), i18nc("Message->","&Reply"), this ); |
|
ac->addAction( "message_reply_menu", mReplyActionMenu ); |
|
connect( mReplyActionMenu, SIGNAL(triggered(bool)), |
|
this, SLOT(slotReplyToMsg()) ); |
|
|
|
mReplyAction = new KAction( KIcon("mail-reply-sender"), i18n("&Reply..."), this ); |
|
ac->addAction( "reply", mReplyAction ); |
|
mReplyAction->setShortcut(Qt::Key_R); |
|
connect( mReplyAction, SIGNAL(triggered(bool)), |
|
this, SLOT(slotReplyToMsg()) ); |
|
mReplyActionMenu->addAction( mReplyAction ); |
|
|
|
mReplyAuthorAction = new KAction( KIcon("mail-reply-sender"), i18n("Reply to A&uthor..."), this ); |
|
ac->addAction( "reply_author", mReplyAuthorAction ); |
|
mReplyAuthorAction->setShortcut(Qt::SHIFT+Qt::Key_A); |
|
connect( mReplyAuthorAction, SIGNAL(triggered(bool)), |
|
this, SLOT(slotReplyAuthorToMsg()) ); |
|
mReplyActionMenu->addAction( mReplyAuthorAction ); |
|
|
|
mReplyAllAction = new KAction( KIcon("mail-reply-all"), i18n("Reply to &All..."), this ); |
|
ac->addAction( "reply_all", mReplyAllAction ); |
|
mReplyAllAction->setShortcut( Qt::Key_A ); |
|
connect( mReplyAllAction, SIGNAL(triggered(bool)), |
|
this, SLOT(slotReplyAllToMsg()) ); |
|
mReplyActionMenu->addAction( mReplyAllAction ); |
|
|
|
mReplyListAction = new KAction( KIcon("mail-reply-list"), i18n("Reply to Mailing-&List..."), this ); |
|
ac->addAction( "reply_list", mReplyListAction ); |
|
mReplyListAction->setShortcut( Qt::Key_L ); |
|
connect( mReplyListAction, SIGNAL(triggered(bool)), |
|
this, SLOT(slotReplyListToMsg()) ); |
|
mReplyActionMenu->addAction( mReplyListAction ); |
|
|
|
mNoQuoteReplyAction = new KAction( i18n("Reply Without &Quote..."), this ); |
|
ac->addAction( "noquotereply", mNoQuoteReplyAction ); |
|
mNoQuoteReplyAction->setShortcut( Qt::SHIFT+Qt::Key_R ); |
|
connect( mNoQuoteReplyAction, SIGNAL(triggered(bool)), |
|
this, SLOT(slotNoQuoteReplyToMsg()) ); |
|
|
|
|
|
mListFilterAction = new KAction(i18n("Filter on Mailing-&List..."), this); |
|
ac->addAction("mlist_filter", mListFilterAction ); |
|
connect(mListFilterAction, SIGNAL(triggered(bool)), SLOT(slotMailingListFilter())); |
|
|
|
mCreateTodoAction = new KAction( KIcon( "task-new" ), i18n( "Create To-do/Reminder..." ), this ); |
|
mCreateTodoAction->setIconText( i18n( "Create To-do" ) ); |
|
mCreateTodoAction->setHelpText( i18n( "Allows you to create a calendar to-do or reminder from this message" ) ); |
|
mCreateTodoAction->setWhatsThis( i18n( "This option starts the KOrganizer to-do editor with initial values taken from the currently selected message. Then you can edit the to-do to your liking before saving it to your calendar." ) ); |
|
ac->addAction( "create_todo", mCreateTodoAction ); |
|
connect( mCreateTodoAction, SIGNAL(triggered(bool)), |
|
this, SLOT(slotCreateTodo()) ); |
|
mKorganizerIsOnSystem = !KStandardDirs::findExe("korganizer").isEmpty(); |
|
mCreateTodoAction->setEnabled( mKorganizerIsOnSystem ); |
|
|
|
mStatusMenu = new KActionMenu ( i18n( "Mar&k Message" ), this ); |
|
ac->addAction( "set_status", mStatusMenu ); |
|
|
|
|
|
KMMainWidget* mainwin = kmkernel->getKMMainWidget(); |
|
if ( mainwin ) { |
|
KAction * action = mainwin->akonadiStandardAction( Akonadi::StandardMailActionManager::MarkMailAsRead ); |
|
mStatusMenu->addAction( action ); |
|
|
|
action = mainwin->akonadiStandardAction( Akonadi::StandardMailActionManager::MarkMailAsUnread ); |
|
mStatusMenu->addAction( action ); |
|
|
|
mStatusMenu->addSeparator(); |
|
action = mainwin->akonadiStandardAction( Akonadi::StandardMailActionManager::MarkMailAsImportant ); |
|
mStatusMenu->addAction( action ); |
|
|
|
action = mainwin->akonadiStandardAction( Akonadi::StandardMailActionManager::MarkMailAsActionItem ); |
|
mStatusMenu->addAction( action ); |
|
|
|
} |
|
|
|
mEditAction = new KAction( KIcon("accessories-text-editor"), i18n("&Edit Message"), this ); |
|
ac->addAction( "edit", mEditAction ); |
|
connect( mEditAction, SIGNAL(triggered(bool)), |
|
this, SLOT(editCurrentMessage()) ); |
|
mEditAction->setShortcut( Qt::Key_T ); |
|
|
|
mAnnotateAction = new KAction( KIcon( "view-pim-notes" ), i18n( "Add Note..."), this ); |
|
ac->addAction( "annotate", mAnnotateAction ); |
|
connect( mAnnotateAction, SIGNAL(triggered(bool)), |
|
this, SLOT(annotateMessage()) ); |
|
|
|
mPrintAction = KStandardAction::print( this, SLOT(slotPrintMsg()), ac ); |
|
if(KPrintPreview::isAvailable()) |
|
mPrintPreviewAction = KStandardAction::printPreview( this, SLOT(slotPrintPreviewMsg()), ac ); |
|
|
|
mForwardActionMenu = new KActionMenu(KIcon("mail-forward"), i18nc("Message->","&Forward"), this); |
|
ac->addAction("message_forward", mForwardActionMenu ); |
|
|
|
mForwardAttachedAction = new KAction( KIcon("mail-forward"), |
|
i18nc( "@action:inmenu Message->Forward->", |
|
"As &Attachment..." ), |
|
this ); |
|
connect( mForwardAttachedAction, SIGNAL(triggered(bool)), |
|
parent, SLOT(slotForwardAttachedMsg()) ); |
|
ac->addAction( "message_forward_as_attachment", mForwardAttachedAction ); |
|
|
|
mForwardInlineAction = new KAction( KIcon( "mail-forward" ), |
|
i18nc( "@action:inmenu Message->Forward->", |
|
"&Inline..." ), |
|
this ); |
|
connect( mForwardInlineAction, SIGNAL(triggered(bool)), |
|
parent, SLOT(slotForwardInlineMsg()) ); |
|
ac->addAction( "message_forward_inline", mForwardInlineAction ); |
|
|
|
setupForwardActions(); |
|
|
|
mRedirectAction = new KAction(i18nc("Message->Forward->", "&Redirect..."), this ); |
|
ac->addAction( "message_forward_redirect", mRedirectAction ); |
|
connect( mRedirectAction, SIGNAL(triggered(bool)), |
|
parent, SLOT(slotRedirectMsg()) ); |
|
mRedirectAction->setShortcut( QKeySequence( Qt::Key_E ) ); |
|
mForwardActionMenu->addAction( mRedirectAction ); |
|
|
|
//FIXME add KIcon("mail-list") as first arguement. Icon can be derived from |
|
// mail-reply-list icon by removing top layers off svg |
|
mMailingListActionMenu = new KActionMenu( i18nc( "Message->", "Mailing-&List" ), this ); |
|
connect( mMailingListActionMenu->menu(), SIGNAL(triggered(QAction*)), |
|
this, SLOT(slotRunUrl(QAction*)) ); |
|
ac->addAction( "mailing_list", mMailingListActionMenu ); |
|
mMailingListActionMenu->setEnabled(false); |
|
|
|
mMonitor = new Akonadi::Monitor( this ); |
|
//FIXME: Attachment fetching is not needed here, but on-demand loading is not supported ATM |
|
mMonitor->itemFetchScope().fetchPayloadPart( Akonadi::MessagePart::Header ); |
|
connect( mMonitor, SIGNAL(itemChanged(Akonadi::Item,QSet<QByteArray>)), SLOT(slotItemModified(Akonadi::Item,QSet<QByteArray>))); |
|
connect( mMonitor, SIGNAL(itemRemoved(Akonadi::Item)), SLOT(slotItemRemoved(Akonadi::Item))); |
|
|
|
connect( mAsynNepomukRetriever, SIGNAL(resourceReceived(QUrl,Nepomuk2::Resource)), SLOT(updateAnnotateAction(QUrl,Nepomuk2::Resource)) ); |
|
|
|
mCustomTemplatesMenu = new TemplateParser::CustomTemplatesMenu( parent, ac ); |
|
|
|
connect( mCustomTemplatesMenu, SIGNAL(replyTemplateSelected(QString)), |
|
parent, SLOT(slotCustomReplyToMsg(QString)) ); |
|
connect( mCustomTemplatesMenu, SIGNAL(replyAllTemplateSelected(QString)), |
|
parent, SLOT(slotCustomReplyAllToMsg(QString)) ); |
|
connect( mCustomTemplatesMenu, SIGNAL(forwardTemplateSelected(QString)), |
|
parent, SLOT(slotCustomForwardMsg(QString)) ); |
|
connect( KMKernel::self(), SIGNAL(customTemplatesChanged()), mCustomTemplatesMenu, SLOT(update()) ); |
|
|
|
forwardMenu()->addSeparator(); |
|
forwardMenu()->addAction( mCustomTemplatesMenu->forwardActionMenu() ); |
|
replyMenu()->addSeparator(); |
|
replyMenu()->addAction( mCustomTemplatesMenu->replyActionMenu() ); |
|
replyMenu()->addAction( mCustomTemplatesMenu->replyAllActionMenu() ); |
|
|
|
updateActions(); |
|
} |
|
|
|
MessageActions::~MessageActions() |
|
{ |
|
delete mCustomTemplatesMenu; |
|
} |
|
|
|
TemplateParser::CustomTemplatesMenu* MessageActions::customTemplatesMenu() const |
|
{ |
|
return mCustomTemplatesMenu; |
|
} |
|
|
|
void MessageActions::setCurrentMessage( const Akonadi::Item &msg, const Akonadi::Item::List &items ) |
|
{ |
|
mMonitor->setItemMonitored( mCurrentItem, false ); |
|
mCurrentItem = msg; |
|
|
|
if (!items.isEmpty()) { |
|
Q_FOREACH( const Akonadi::Item& item, mVisibleItems ) { |
|
mMonitor->setItemMonitored( item, false ); |
|
} |
|
if (!msg.isValid()) { |
|
mVisibleItems.clear(); |
|
} else { |
|
mVisibleItems = items; |
|
Q_FOREACH( const Akonadi::Item& item, items ) { |
|
mMonitor->setItemMonitored( item, true ); |
|
} |
|
} |
|
} |
|
|
|
if ( !msg.isValid() ) { |
|
mVisibleItems.clear(); |
|
clearMailingListActions(); |
|
} |
|
|
|
mMonitor->setItemMonitored( mCurrentItem, true ); |
|
updateActions(); |
|
} |
|
|
|
void MessageActions::slotItemRemoved(const Akonadi::Item& item) |
|
{ |
|
if ( item == mCurrentItem ) { |
|
mCurrentItem = Akonadi::Item(); |
|
updateActions(); |
|
} |
|
} |
|
|
|
void MessageActions::slotItemModified( const Akonadi::Item & item, const QSet< QByteArray > & partIdentifiers ) |
|
{ |
|
Q_UNUSED( partIdentifiers ); |
|
if ( item == mCurrentItem ) { |
|
mCurrentItem = item; |
|
const int numberOfVisibleItems = mVisibleItems.count(); |
|
for ( int i = 0; i < numberOfVisibleItems; ++i ) { |
|
Akonadi::Item it = mVisibleItems.at(i); |
|
if ( item == it ) { |
|
mVisibleItems[i] = item; |
|
} |
|
} |
|
updateActions(); |
|
} |
|
} |
|
|
|
void MessageActions::updateActions() |
|
{ |
|
const bool hasPayload = mCurrentItem.hasPayload<KMime::Message::Ptr>(); |
|
bool itemValid = mCurrentItem.isValid(); |
|
Akonadi::Collection parent; |
|
if ( itemValid ) //=> valid |
|
parent = mCurrentItem.parentCollection(); |
|
if ( parent.isValid() ) { |
|
if ( CommonKernel->folderIsTemplates(parent) ) |
|
itemValid = false; |
|
} |
|
|
|
const bool multiVisible = mVisibleItems.count() > 0 || mCurrentItem.isValid(); |
|
const bool uniqItem = ( itemValid||hasPayload ) && ( mVisibleItems.count()<=1 ); |
|
mCreateTodoAction->setEnabled( itemValid && ( mVisibleItems.count()<=1 ) && mKorganizerIsOnSystem); |
|
mReplyActionMenu->setEnabled( hasPayload ); |
|
mReplyAction->setEnabled( hasPayload ); |
|
mNoQuoteReplyAction->setEnabled( hasPayload ); |
|
mReplyAuthorAction->setEnabled( hasPayload ); |
|
mReplyAllAction->setEnabled( hasPayload ); |
|
mReplyListAction->setEnabled( hasPayload ); |
|
mNoQuoteReplyAction->setEnabled( hasPayload ); |
|
|
|
if ( Nepomuk2::ResourceManager::instance()->initialized() ) { |
|
mAnnotateAction->setEnabled( uniqItem ); |
|
mAsynNepomukRetriever->requestResource( mCurrentItem.url() ); |
|
} else { |
|
mAnnotateAction->setEnabled( false ); |
|
} |
|
|
|
mStatusMenu->setEnabled( multiVisible ); |
|
|
|
if ( mCurrentItem.hasPayload<KMime::Message::Ptr>() ) { |
|
if ( mCurrentItem.loadedPayloadParts().contains("RFC822") ) { |
|
updateMailingListActions( mCurrentItem ); |
|
} else { |
|
Akonadi::ItemFetchJob *job = new Akonadi::ItemFetchJob( mCurrentItem ); |
|
job->fetchScope().fetchAllAttributes(); |
|
job->fetchScope().fetchFullPayload( true ); |
|
job->fetchScope().fetchPayloadPart( Akonadi::MessagePart::Header ); |
|
connect( job, SIGNAL(result(KJob*)), SLOT(slotUpdateActionsFetchDone(KJob*)) ); |
|
} |
|
} |
|
mEditAction->setEnabled( uniqItem ); |
|
} |
|
|
|
void MessageActions::slotUpdateActionsFetchDone(KJob* job) |
|
{ |
|
if ( job->error() ) |
|
return; |
|
|
|
Akonadi::ItemFetchJob *fetchJob = static_cast<Akonadi::ItemFetchJob*>( job ); |
|
if ( fetchJob->items().isEmpty() ) |
|
return; |
|
Akonadi::Item messageItem = fetchJob->items().first(); |
|
if ( messageItem == mCurrentItem ) { |
|
mCurrentItem = messageItem; |
|
updateMailingListActions( messageItem ); |
|
} |
|
} |
|
|
|
void MessageActions::clearMailingListActions() |
|
{ |
|
mMailingListActionMenu->setEnabled( false ); |
|
mListFilterAction->setEnabled( false ); |
|
mListFilterAction->setText( i18n("Filter on Mailing-List...") ); |
|
} |
|
|
|
void MessageActions::updateMailingListActions( const Akonadi::Item& messageItem ) |
|
{ |
|
KMime::Message::Ptr message = messageItem.payload<KMime::Message::Ptr>(); |
|
const MessageCore::MailingList mailList = MessageCore::MailingList::detect( message ); |
|
|
|
if ( mailList.features() == MessageCore::MailingList::None ) { |
|
clearMailingListActions(); |
|
} else { |
|
// A mailing list menu with only a title is pretty boring |
|
// so make sure theres at least some content |
|
QString listId; |
|
if ( mailList.features() & MessageCore::MailingList::Id ) { |
|
// From a list-id in the form, "Birds of France <bof.yahoo.com>", |
|
// take "Birds of France" if it exists otherwise "bof.yahoo.com". |
|
listId = mailList.id(); |
|
const int start = listId.indexOf( QLatin1Char( '<' ) ); |
|
if ( start > 0 ) { |
|
listId.truncate( start - 1 ); |
|
} else if ( start == 0 ) { |
|
const int end = listId.lastIndexOf( QLatin1Char( '>' ) ); |
|
if ( end < 1 ) { // shouldn't happen but account for it anyway |
|
listId.remove( 0, 1 ); |
|
} else { |
|
listId = listId.mid( 1, end-1 ); |
|
} |
|
} |
|
} |
|
mMailingListActionMenu->menu()->clear(); |
|
qDeleteAll(mMailListActionList); |
|
mMailListActionList.clear(); |
|
if ( !listId.isEmpty() ) |
|
mMailingListActionMenu->menu()->addTitle( listId ); |
|
|
|
if ( mailList.features() & MessageCore::MailingList::ArchivedAt ) |
|
// IDEA: this may be something you want to copy - "Copy in submenu"? |
|
addMailingListActions( i18n( "Open Message in List Archive" ), mailList.archivedAtUrls() ); |
|
if ( mailList.features() & MessageCore::MailingList::Post ) |
|
addMailingListActions( i18n( "Post New Message" ), mailList.postUrls() ); |
|
if ( mailList.features() & MessageCore::MailingList::Archive ) |
|
addMailingListActions( i18n( "Go to Archive" ), mailList.archiveUrls() ); |
|
if ( mailList.features() & MessageCore::MailingList::Help ) |
|
addMailingListActions( i18n( "Request Help" ), mailList.helpUrls() ); |
|
if ( mailList.features() & MessageCore::MailingList::Owner ) |
|
addMailingListActions( i18nc( "Contact the owner of the mailing list", "Contact Owner" ), mailList.ownerUrls() ); |
|
if ( mailList.features() & MessageCore::MailingList::Subscribe ) |
|
addMailingListActions( i18n( "Subscribe to List" ), mailList.subscribeUrls() ); |
|
if ( mailList.features() & MessageCore::MailingList::Unsubscribe ) |
|
addMailingListActions( i18n( "Unsubscribe from List" ), mailList.unsubscribeUrls() ); |
|
mMailingListActionMenu->setEnabled( true ); |
|
|
|
QByteArray name; |
|
QString value; |
|
const QString lname = MailingList::name( message, name, value ); |
|
if ( !lname.isEmpty() ) { |
|
mListFilterAction->setEnabled( true ); |
|
mListFilterAction->setText( i18n( "Filter on Mailing-List %1...", lname ) ); |
|
} |
|
} |
|
} |
|
|
|
|
|
void MessageActions::replyCommand(MessageComposer::ReplyStrategy strategy) |
|
{ |
|
if ( !mCurrentItem.hasPayload<KMime::Message::Ptr>() ) return; |
|
|
|
const QString text = mMessageView ? mMessageView->copyText() : QString(); |
|
KMCommand *command = new KMReplyCommand( mParent, mCurrentItem, strategy, text ); |
|
connect( command, SIGNAL(completed(KMCommand*)), |
|
this, SIGNAL(replyActionFinished()) ); |
|
command->start(); |
|
} |
|
|
|
void MessageActions::slotCreateTodo() |
|
{ |
|
if ( !mCurrentItem.isValid() ) |
|
return; |
|
|
|
MailCommon::Util::createTodoFromMail( mCurrentItem ); |
|
} |
|
|
|
void MessageActions::setMessageView(KMReaderWin * msgView) |
|
{ |
|
mMessageView = msgView; |
|
} |
|
|
|
void MessageActions::setupForwardActions() |
|
{ |
|
disconnect( mForwardActionMenu, SIGNAL(triggered(bool)), 0, 0 ); |
|
mForwardActionMenu->removeAction( mForwardInlineAction ); |
|
mForwardActionMenu->removeAction( mForwardAttachedAction ); |
|
|
|
if ( GlobalSettings::self()->forwardingInlineByDefault() ) { |
|
mForwardActionMenu->insertAction( mRedirectAction, mForwardInlineAction ); |
|
mForwardActionMenu->insertAction( mRedirectAction, mForwardAttachedAction ); |
|
mForwardInlineAction->setShortcut(QKeySequence(Qt::Key_F)); |
|
mForwardAttachedAction->setShortcut(QKeySequence(Qt::SHIFT+Qt::Key_F)); |
|
QObject::connect( mForwardActionMenu, SIGNAL(triggered(bool)), |
|
mParent, SLOT(slotForwardInlineMsg()) ); |
|
} else { |
|
mForwardActionMenu->insertAction( mRedirectAction, mForwardAttachedAction ); |
|
mForwardActionMenu->insertAction( mRedirectAction, mForwardInlineAction ); |
|
mForwardInlineAction->setShortcut(QKeySequence(Qt::Key_F)); |
|
mForwardAttachedAction->setShortcut(QKeySequence(Qt::SHIFT+Qt::Key_F)); |
|
QObject::connect( mForwardActionMenu, SIGNAL(triggered(bool)), |
|
mParent, SLOT(slotForwardAttachedMsg()) ); |
|
} |
|
} |
|
|
|
void MessageActions::setupForwardingActionsList( KXMLGUIClient *guiClient ) |
|
{ |
|
QList<QAction*> forwardActionList; |
|
guiClient->unplugActionList( "forward_action_list" ); |
|
if ( GlobalSettings::self()->forwardingInlineByDefault() ) { |
|
forwardActionList.append( mForwardInlineAction ); |
|
forwardActionList.append( mForwardAttachedAction ); |
|
} else { |
|
forwardActionList.append( mForwardAttachedAction ); |
|
forwardActionList.append( mForwardInlineAction ); |
|
} |
|
forwardActionList.append( mRedirectAction ); |
|
guiClient->plugActionList( "forward_action_list", forwardActionList ); |
|
} |
|
|
|
|
|
void MessageActions::slotReplyToMsg() |
|
{ |
|
replyCommand( MessageComposer::ReplySmart ); |
|
} |
|
|
|
void MessageActions::slotReplyAuthorToMsg() |
|
{ |
|
replyCommand( MessageComposer::ReplyAuthor ); |
|
} |
|
|
|
void MessageActions::slotReplyListToMsg() |
|
{ |
|
replyCommand( MessageComposer::ReplyList ); |
|
} |
|
|
|
void MessageActions::slotReplyAllToMsg() |
|
{ |
|
replyCommand( MessageComposer::ReplyAll ); |
|
} |
|
|
|
void MessageActions::slotNoQuoteReplyToMsg() |
|
{ |
|
if ( !mCurrentItem.hasPayload<KMime::Message::Ptr>() ) |
|
return; |
|
KMCommand *command = new KMReplyCommand( mParent, mCurrentItem, MessageComposer::ReplySmart, QString(), true ); |
|
command->start(); |
|
} |
|
|
|
void MessageActions::slotRunUrl( QAction *urlAction ) |
|
{ |
|
const QVariant q = urlAction->data(); |
|
if ( q.type() == QVariant::String ) { |
|
new KRun( KUrl( q.toString() ) , mParent ); |
|
} |
|
} |
|
|
|
void MessageActions::slotMailingListFilter() |
|
{ |
|
if ( !mCurrentItem.hasPayload<KMime::Message::Ptr>() ) |
|
return; |
|
|
|
KMCommand *command = new KMMailingListFilterCommand( mParent, mCurrentItem ); |
|
command->start(); |
|
} |
|
|
|
void MessageActions::printMessage(bool preview) |
|
{ |
|
bool result = false; |
|
if ( mMessageView ) { |
|
if (MessageViewer::GlobalSettings::self()->printSelectedText()) { |
|
result = mMessageView->printSelectedText(preview); |
|
} |
|
} |
|
if (!result) { |
|
const bool useFixedFont = MessageViewer::GlobalSettings::self()->useFixedFont(); |
|
const QString overrideEncoding = MessageCore::GlobalSettings::self()->overrideCharacterEncoding(); |
|
|
|
const Akonadi::Item message = mCurrentItem; |
|
KMPrintCommand *command = |
|
new KMPrintCommand( mParent, message, |
|
0, |
|
0, |
|
mMessageView->viewer()->htmlOverride(), mMessageView->viewer()->htmlLoadExternal(), |
|
useFixedFont, overrideEncoding ); |
|
command->setPrintPreview(preview); |
|
command->start(); |
|
} |
|
} |
|
|
|
void MessageActions::slotPrintPreviewMsg() |
|
{ |
|
printMessage(true); |
|
} |
|
|
|
void MessageActions::slotPrintMsg() |
|
{ |
|
printMessage(false); |
|
} |
|
|
|
/** |
|
* This adds a list of actions to mMailingListActionMenu mapping the identifier item to |
|
* the url. |
|
* |
|
* e.g.: item = "Contact Owner" |
|
* "Contact Owner (email)" -> KRun( "mailto:bob@arthouseflowers.example.com" ) |
|
* "Contact Owner (web)" -> KRun( "http://arthouseflowers.example.com/contact-owner.php" ) |
|
*/ |
|
void MessageActions::addMailingListActions( const QString &item, const KUrl::List &list ) |
|
{ |
|
foreach ( const KUrl& url, list ) { |
|
addMailingListAction( item, url ); |
|
} |
|
} |
|
|
|
/** |
|
* This adds a action to mMailingListActionMenu mapping the identifier item to |
|
* the url. See addMailingListActions above. |
|
*/ |
|
void MessageActions::addMailingListAction( const QString &item, const KUrl &url ) |
|
{ |
|
QString protocol = url.protocol().toLower(); |
|
QString prettyUrl = url.prettyUrl(); |
|
if ( protocol == QLatin1String("mailto") ) { |
|
protocol = i18n( "email" ); |
|
prettyUrl.remove( 0, 7 ); // length( "mailto:" ) |
|
} else if ( protocol.startsWith( QLatin1String( "http" ) ) ) { |
|
protocol = i18n( "web" ); |
|
} |
|
// item is a mailing list url description passed from the updateActions method above. |
|
KAction *act = new KAction( i18nc( "%1 is a 'Contact Owner' or similar action. %2 is a protocol normally web or email though could be irc/ftp or other url variant", "%1 (%2)", item, protocol ) , this ); |
|
mMailListActionList.append(act); |
|
const QVariant v( url.url() ); |
|
act->setData( v ); |
|
act->setHelpText( prettyUrl ); |
|
mMailingListActionMenu->addAction( act ); |
|
} |
|
|
|
void MessageActions::editCurrentMessage() |
|
{ |
|
KMCommand *command = 0; |
|
if ( mCurrentItem.isValid() ) { |
|
Akonadi::Collection col = mCurrentItem.parentCollection(); |
|
// edit, unlike send again, removes the message from the folder |
|
// we only want that for templates and drafts folders |
|
if ( col.isValid() |
|
&& ( CommonKernel->folderIsDraftOrOutbox( col ) || |
|
CommonKernel->folderIsTemplates( col ) ) |
|
) |
|
command = new KMEditItemCommand( mParent, mCurrentItem, true ); |
|
else |
|
command = new KMEditItemCommand( mParent, mCurrentItem, false ); |
|
command->start(); |
|
} else if ( mCurrentItem.hasPayload<KMime::Message::Ptr>() ) { |
|
command = new KMEditMessageCommand( mParent, mCurrentItem.payload<KMime::Message::Ptr>() ); |
|
command->start(); |
|
} |
|
} |
|
|
|
void MessageActions::annotateMessage() |
|
{ |
|
if ( !mCurrentItem.isValid() ) |
|
return; |
|
|
|
const QUrl url = mCurrentItem.url(); |
|
MessageCore::AnnotationEditDialog *dialog = new MessageCore::AnnotationEditDialog( url ); |
|
dialog->setAttribute( Qt::WA_DeleteOnClose ); |
|
if ( dialog->exec() ) |
|
mAsynNepomukRetriever->requestResource( url ); |
|
} |
|
|
|
void MessageActions::updateAnnotateAction( const QUrl &url, const Nepomuk2::Resource &resource ) |
|
{ |
|
if( mCurrentItem.isValid() && mCurrentItem.url() == url ) { |
|
if ( resource.description().isEmpty() ) |
|
mAnnotateAction->setText( i18n( "Add Note..." ) ); |
|
else |
|
mAnnotateAction->setText( i18n( "Edit Note...") ); |
|
} |
|
} |
|
|
|
void MessageActions::addWebShortcutsMenu( KMenu *menu, const QString & text ) |
|
{ |
|
if ( text.isEmpty() ) |
|
return; |
|
|
|
QString searchText = text; |
|
searchText = searchText.replace( QLatin1Char('\n'), QLatin1Char(' ') ).replace( QLatin1Char('\r'), QLatin1Char(' ') ).simplified(); |
|
|
|
if ( searchText.isEmpty() ) |
|
return; |
|
|
|
KUriFilterData filterData( searchText ); |
|
|
|
filterData.setSearchFilteringOptions( KUriFilterData::RetrievePreferredSearchProvidersOnly ); |
|
|
|
if ( KUriFilter::self()->filterSearchUri( filterData, KUriFilter::NormalTextFilter ) ) { |
|
const QStringList searchProviders = filterData.preferredSearchProviders(); |
|
|
|
if ( !searchProviders.isEmpty() ) { |
|
KMenu *webShortcutsMenu = new KMenu( menu ); |
|
webShortcutsMenu->setIcon( KIcon( "preferences-web-browser-shortcuts" ) ); |
|
|
|
const QString squeezedText = KStringHandler::rsqueeze( searchText, 21 ); |
|
webShortcutsMenu->setTitle( i18n( "Search for '%1' with", squeezedText ) ); |
|
|
|
KAction *action = 0; |
|
|
|
foreach( const QString &searchProvider, searchProviders ) { |
|
action = new KAction( searchProvider, webShortcutsMenu ); |
|
action->setIcon( KIcon( filterData.iconNameForPreferredSearchProvider( searchProvider ) ) ); |
|
action->setData( filterData.queryForPreferredSearchProvider( searchProvider ) ); |
|
connect( action, SIGNAL(triggered()), this, SLOT(slotHandleWebShortcutAction()) ); |
|
webShortcutsMenu->addAction( action ); |
|
} |
|
|
|
webShortcutsMenu->addSeparator(); |
|
|
|
action = new KAction( i18n( "Configure Web Shortcuts..." ), webShortcutsMenu ); |
|
action->setIcon( KIcon( "configure" ) ); |
|
connect( action, SIGNAL(triggered()), this, SLOT(slotConfigureWebShortcuts()) ); |
|
webShortcutsMenu->addAction( action ); |
|
|
|
menu->addMenu(webShortcutsMenu); |
|
} |
|
} |
|
} |
|
|
|
void MessageActions::slotHandleWebShortcutAction() |
|
{ |
|
KAction *action = qobject_cast<KAction*>( sender() ); |
|
|
|
if (action) { |
|
KUriFilterData filterData( action->data().toString() ); |
|
if ( KUriFilter::self()->filterSearchUri( filterData, KUriFilter::WebShortcutFilter ) ) { |
|
KToolInvocation::invokeBrowser( filterData.uri().url() ); |
|
} |
|
} |
|
} |
|
|
|
void MessageActions::slotConfigureWebShortcuts() |
|
{ |
|
KToolInvocation::kdeinitExec( QLatin1String("kcmshell4"), QStringList() << QLatin1String("ebrowsing") ); |
|
} |
|
|
|
#include "messageactions.moc"
|
|
|