viewer_p.h 27.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
  Copyright (c) 1997 Markus Wuebben <markus.wuebben@kde.org>
  Copyright (C) 2009 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.net
  Copyright (c) 2009 Andras Mantia <andras@kdab.net>

  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.
*/

#ifndef MAILVIEWER_P_H
#define MAILVIEWER_P_H

24
#include <MimeTreeParser/NodeHelper>
25
#include "config-messageviewer.h"
26
27
28
29
30
31
32
#include "viewer.h" //not so nice, it is actually for the enums from MailViewer
#include "PimCommon/ShareServiceUrlManager"
#include "messageviewer/viewerplugininterface.h"

#include <AkonadiCore/item.h>
#include <AkonadiCore/monitor.h>
#include <kio/job.h>
33
#include <KMime/Message>
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <kservice.h>
#include <ksharedconfig.h>
#include <QUrl>

#include <QObject>
#include <QTimer>

namespace KIO
{
class Job;
}

class QAction;
class KActionCollection;
class KSelectAction;
class KToggleAction;
class QMenu;
class KActionMenu;

class QPoint;
class QSplitter;
class QModelIndex;

namespace KPIMTextEdit
{
class SlideContainer;
class TextToSpeechWidget;
}
namespace PimCommon
{
class ShareServiceUrlManager;
}

67
68
69
70
71
72
73
namespace MimeTreeParser
{
class AttachmentStrategy;
class HtmlWriter;
class ObjectTreeParser;
}

74
75
76
77
namespace MessageViewer
{
class HeaderStylePlugin;
class CSSHelper;
78
79
80
81
#ifdef MESSAGEVIEWER_USE_QTWEBENGINE
class FindBarWebEngineView;
class MailWebEngineView;
class WebEnginePartHtmlWriter;
Laurent Montel's avatar
Laurent Montel committed
82
class WebHitTestResult;
83
#else
84
class FindBarWebView;
85
class MailWebView;
86
class WebKitPartHtmlWriter;
87
#endif
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
class HtmlStatusBar;
class ScamDetectionWarningWidget;
class MimePartTreeView;
class OpenAttachmentFolderWidget;
class HeaderStyleMenuManager;
class ViewerPluginToolManager;
class ViewerPluginInterface;
class ZoomActionMenu;
/**
\brief Private class for the Viewer, the main widget in the messageviewer library.

This class creates all subwidgets, like the MailWebView, the HtmlStatusBar and the FindBarMailWebView.

Also, ViewerPrivate creates and exposes all actions.

\par Displaying a message

Before displaying a message, a message needs to be set. This can be done in two ways, with
setMessageItem() and with setMessage(). setMessageItem() is the preferred way, as the viewer can
then remember the Akonadi::Item belonging to the message. The Akonadi::Item is needed when modifying
the message, for example when editing or deleting an attachment.
Sometimes passing an Akonadi::Item to the viewer is not possible, for example when double-clicking
an attached message, in which case a new KMime::Message is constructed out of the attachment, and a
separate window is opened for it. In this case, the KMime::Message has no associated Akonadi::Item.
If there is an Akonadi::Item available, it will be monitored for changes and the viewer
automatically updated on external changes.

Once a message is set, update() is called. update() can also be called after the message has already
been displayed. As an example, this is the case when the user decides to decrypt the message. The
decryption can happen async, and once the decryption is finished, update() is called to display the
118
now decrypted content. See the documentation of MimeTreeParser::ObjectTreeParser on how exactly decryption is
119
120
121
122
123
handled.
update() is just a thin wrapper that calls updateReaderWin(). The only difference is that update()
has a timer that prevents too many slow calls to updateReaderWin() in a short time frame.
updateReaderWin() again is only a thin wrapper that resets some state and then calls
displayMessage().
124
displayMessage() itself is again a thin wrapper, which starts the MimeTreeParser::HtmlWriter and then calls
125
parseMsg().
126
127
128
129
Finally, parseMsg() does the real work. It uses MimeTreeParser::ObjectTreeParser ::parseObjectTree() to let the
MimeTreeParser::ObjectTreeParser parse the message and generate the HTML code for it.
As mentioned before, it can happen that the MimeTreeParser::ObjectTreeParser needs to do some operation that happens
async, for example decrypting. In this case, the MimeTreeParser::ObjectTreeParser will create a BodyPartMemento,
130
131
which basically is a wrapper around the job that does the async operation. Once the async operation
is finished. the BodyPartMemento will trigger an update() of ViewerPrivate, so that
132
133
MimeTreeParser::ObjectTreeParser ::parseObjectTree() gets called again and the MimeTreeParser::ObjectTreeParser then can generate
HTML which has the decrypted content of the message. Again, see the documentation of MimeTreeParser::ObjectTreeParser for the details.
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
Additionally, parseMsg() does some evil hack for saving unencrypted messages should the config
option for that be set.

\par Displaying a MIME part of the message

The viewer can show only a part of the message, for example by clicking on a MIME part in the
message structure viewer or by double-clicking an attached message. In this case, setMessagePart()
is called. There are two of these functions. One even has special handling for images, special
handling for binary attachments and special handling of attached messages. In the last case, a new
KMime::Message is constructed and set as the main message with setMessage().

\par Attachment Handling

Some of those actions are actions that operate on a single attachment. For those, there is usually
a slot, like slotAttachmentCopy(). These actions are triggered from the attachment context menu,
which is shown in showAttachmentPopup(). The actions are connected to slotHandleAttachment() when
they are activated.
The action to edit an attachment uses the EditorWatcher to detect when editing with an external
editor is finished. Upon finishing, slotAttachmentEditDone() is called, which then creates an
ItemModifyJob to store the changes of the attachment. A map of currently active EditorWatcher and
their KMime::Content is available in mEditorWatchers.
For most attachment actions, the attachment is first written to a temp file. The action is then
executed on this temp file. Writing the attachment to a temp file is done with
157
158
159
MimeTreeParser::NodeHelper::writeNodeToTempFile(). This method is called before opening or copying an attachment or
when rendering the attachment list. The MimeTreeParser::ObjectTreeParser also calls MimeTreeParser::NodeHelper::writeNodeToTempFile()
in some places. Once the temp file is written, MimeTreeParser::NodeHelper::tempFileUrlFromNode() can be used to get
160
161
162
163
164
165
166
the file name of the temp file for a specific MIME part. This is for example used by the handler for
'attachment:' URLs, AttachmentURLHandler.

Since URLs for attachments are in the "attachment:" scheme, dragging them as-is to outside applications
wouldn't work, since other applications don't understand this scheme. Therefore, the viewer has
special handling for dragging URLs: In eventFilter(), drags are detected, and the URL handler is
called to deal with the drag. The attachment URL handler then starts a drag with the file:// URL
167
of the temp file of the attachment, which it gets with MimeTreeParser::NodeHelper::tempFileUrlFromNode().
168
169
170
171
172
173
174
175
176

TODO: How are attachment handled that are loaded on demand? How does prepareHandleAttachment() work?
TODO: This temp file handling is a big mess and could use a rewrite, especially in the face of load
      on demand. There shouldn't be the need to write out tempfiles until really needed.

Some header styles display an attachment list in the header. The HTML code for the attachment list
cannot be generated by the HeaderStyle itself, since that does not know about all attachments.
Therefore, the attachment list needs to be created by ViewerPrivate. For this, the HeaderStyle
writes out a placeholder for the attachment list when it creates the HTML for the header. Once the
177
MimeTreeParser::ObjectTreeParser is finished with the message, injectAttachments() is called. injectAttachments()
178
179
180
181
182
searches for the placeholder and replaces that with the real HTML code for the attachments.

One of the attachment actions is to scoll to the attachment. That action is only available when
right-clicking the header. The action scrolls to the attachment in the body and draws a yellow frame
around the attachment. This is done in scrollToAttachment(). The attachment in the body and the div
183
which is used for the colored frame are both created by the MimeTreeParser::ObjectTreeParser .
184
185
186

\par Misc

187
188
189
ViewerPrivate holds the MimeTreeParser::NodeHelper, which is passed on to the MimeTreeParser::ObjectTreeParser when it needs it.
It also holds the HeaderStyle, HeaderStrategy, MimeTreeParser::AttachmentStrategy, CSSHelper, MimeTreeParser::HtmlWriter and more,
some of them again passed to the MimeTreeParser::ObjectTreeParser when it needs it.
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222

@author andras@kdab.net
 */
class ViewerPrivate : public QObject
{
    Q_OBJECT
public:

    ViewerPrivate(Viewer *aParent, QWidget *mainWindow, KActionCollection *actionCollection);

    virtual ~ViewerPrivate();

    /** Returns message part from given URL or null if invalid. The URL's path is a KMime::ContentIndex path, or an index for the extra nodes,
    followed by : and the ContentIndex path. */
    KMime::Content *nodeFromUrl(const QUrl &url) const;

    /** Open the attachment pointed to the node.
    * @param fileName - if not empty, use this file to load the attachment content
    */
    void openAttachment(KMime::Content *node, const QString &fileName);

    /** Delete the attachment the @param node points to. Returns false if the user
    cancelled the deletion, true in all other cases (including failure to delete
    the attachment!) */
    bool deleteAttachment(KMime::Content *node, bool showWarning = true);

    void attachmentProperties(KMime::Content *node);
    void attachmentCopy(const KMime::Content::List &contents);

    /** Edit the attachment the @param node points to. Returns false if the user
    cancelled the editing, true in all other cases! */
    void editAttachment(KMime::Content *node, bool showWarning = true);

Laurent Montel's avatar
Laurent Montel committed
223
    void scrollToAnchor(const QString &anchor);
224
225
226
227
228
229
230
231
232
233

    void showAttachmentPopup(KMime::Content *node, const QString &name, const QPoint &p);

    /**
    * Sets the current attachment ID and the current attachment temporary filename
    * to the given values.
    * Call this so that slotHandleAttachment() knows which attachment to handle.
    */
    void prepareHandleAttachment(KMime::Content *node, const QString &fileName);

234
    void postProcessMessage(MimeTreeParser::ObjectTreeParser *otp, MimeTreeParser::KMMsgEncryptionState encryptionState);
235
236
237
238
239
240
241

    QString createAtmFileLink(const QString &atmFileName) const;
    KService::Ptr getServiceOffer(KMime::Content *content);
    KMime::Content::List selectedContents();
    void attachmentOpenWith(KMime::Content *node, const KService::Ptr &offer = KService::Ptr());
    void attachmentOpen(KMime::Content *node);

242
243
    /** Return the MimeTreeParser::HtmlWriter connected to the MailWebView we use */
    MimeTreeParser::HtmlWriter *htmlWriter() const;
244
245
246
247
248

    HeaderStylePlugin *headerStylePlugin() const;

    CSSHelper *cssHelper() const;

249
    MimeTreeParser::NodeHelper *nodeHelper() const;
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287

    Viewer *viewer() const;

    Akonadi::Item messageItem() const;

    KMime::Message::Ptr message() const;

    /** Returns whether the message should be decryted. */
    bool decryptMessage() const;

    /** Calculate the pixel size */
    int pointsToPixel(int pointSize) const;

    /** Display a generic HTML splash page instead of a message. */
    void displaySplashPage(const QString &templateName, const QVariantHash &data);

    void displaySplashPage(const QString &message);

    /** Enable the displaying of messages again after an splash (or other) page was displayed */
    void enableMessageDisplay();

    /** Feeds the HTML viewer with the contents of the given message.
    HTML begin/end parts are written around the message. */
    void displayMessage();

    /** Parse the given content and generate HTML out of it for display */
    void parseContent(KMime::Content *content);

    /** Creates a nice mail header depending on the current selected
    header style. */
    QString writeMsgHeader(KMime::Message *aMsg, KMime::Content *vCardNode = Q_NULLPTR,
                           bool topLevel = false);

    /** show window containing information about a vCard. */
    void showVCard(KMime::Content *msgPart);

    void saveMainFrameScreenshotInFile(const QString &filename);

288
    void setMailAction(MessageViewer::Viewer::MailAction type);
Laurent Montel's avatar
Laurent Montel committed
289

290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
private:
    /** HTML initialization. */
    void initHtmlWidget();
    void createOpenWithMenu(QMenu *topMenu, const QString &contentTypeStr, bool fromCurrentContent);
public:
    /** Event filter */
    bool eventFilter(QObject *obj, QEvent *ev) Q_DECL_OVERRIDE;

    /** Read settings from app's config file. */
    void readConfig();

    /** Write settings to app's config file. Calls sync() if withSync is true. */
    void writeConfig(bool withSync = true);

    /** Get/set the message attachment strategy. */
305
306
    const MimeTreeParser::AttachmentStrategy *attachmentStrategy() const;
    void setAttachmentStrategy(const MimeTreeParser::AttachmentStrategy *strategy);
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324

    /** Get selected override character encoding.
      @return The encoding selected by the user or an empty string if auto-detection
      is selected. */
    QString overrideEncoding() const;

    /** Set the override character encoding. */
    void setOverrideEncoding(const QString &encoding);

    /** Set printing mode */
    virtual void setPrinting(bool enable);

    /** Print message. */
    void printMessage(const Akonadi::Item &msg);
    void printPreviewMessage(const Akonadi::Item &message);

    void resetStateForNewMessage();

325
    void setMessageInternal(const KMime::Message::Ptr &message, MimeTreeParser::UpdateMode updateMode);
326
327
328
329
330
331

    /** Set the Akonadi item that will be displayed.
    *  @param item - the Akonadi item to be displayed. If it doesn't hold a mail (KMime::Message::Ptr as payload data),
    *                an empty page is shown.
    *  @param updateMode - update the display immediately or not. See MailViewer::UpdateMode.
    */
332
    void setMessageItem(const Akonadi::Item &item, MimeTreeParser::UpdateMode updateMode = MimeTreeParser::Delayed);
333
334
335
336
337

    /** Set the message that shall be shown.
    * @param msg - the message to be shown. If 0, an empty page is displayed.
    * @param updateMode - update the display immediately or not. See MailViewer::UpdateMode.
    */
338
    void setMessage(const KMime::Message::Ptr &msg, MimeTreeParser::UpdateMode updateMode = MimeTreeParser::Delayed);
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358

    /** Instead of settings a message to be shown sets a message part
      to be shown */
    void setMessagePart(KMime::Content *node);

    /** Show or hide the Mime Tree Viewer if configuration
      is set to smart mode.  */
    void showHideMimeTree();

    /** View message part of type message/RFC822 in extra viewer window. */
    void atmViewMsg(const KMime::Message::Ptr &message);

    void setExternalWindow(bool b);

    void adjustLayout();
    void createWidgets();
    void createActions();

    void showContextMenu(KMime::Content *content, const QPoint &point);

359
    KToggleAction *actionForAttachmentStrategy(const MimeTreeParser::AttachmentStrategy *);
360
361
362
363
364
365
366
367
368
    /** Read override codec from configuration */
    void readGlobalOverrideCodec();

    /** Get codec corresponding to the currently selected override character encoding.
      @return The override codec or 0 if auto-detection is selected. */
    const QTextCodec *overrideCodec() const;

    QString renderAttachments(KMime::Content *node, const QColor &bgColor) const;

369
    KMime::Content *findContentByType(KMime::Content *content, const QByteArray &type); //TODO(Andras) move to MimeTreeParser::NodeHelper
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440

    /** Return a QTextCodec for the specified charset.
    * This function is a bit more tolerant, than QTextCodec::codecForName */
    static const QTextCodec *codecForName(const QByteArray &_str); //TODO(Andras) move to a utility class?

    /** Saves the relative position of the scroll view. Call this before calling update()
      if you want to preserve the current view. */
    void saveRelativePosition();

    bool htmlMail() const;
    bool htmlLoadExternal() const;

    /** Get the html override setting */
    Viewer::DisplayFormatMessage displayFormatMessageOverwrite() const;

    /** Override default html mail setting */
    void setDisplayFormatMessageOverwrite(Viewer::DisplayFormatMessage format);

    /** Get the load external references override setting */
    bool htmlLoadExtOverride() const;

    /** Override default load external references setting */
    void setHtmlLoadExtOverride(bool override);

    /** Enforce message decryption. */
    void setDecryptMessageOverwrite(bool overwrite = true);

    /** Show signature details. */
    bool showSignatureDetails() const;

    /** Show signature details. */
    void setShowSignatureDetails(bool showDetails = true);

    /* show or hide the list that points to the attachments */
    bool showAttachmentQuicklist() const;

    /* show or hide the list that points to the attachments */
    void setShowAttachmentQuicklist(bool showAttachmentQuicklist = true);

    void scrollToAttachment(KMime::Content *node);
    void setUseFixedFont(bool useFixedFont);

    void attachmentView(KMime::Content *atmNode);

    /** Return weather to show or hide the full list of "To" addresses */
    bool showFullToAddressList() const;

    /** Show or hide the full list of "To" addresses */
    void setShowFullToAddressList(bool showFullToAddressList = true);

    /** Return weather to show or hide the full list of "To" addresses */
    bool showFullCcAddressList() const;

    /** Show or hide the full list of "To" addresses */
    void setShowFullCcAddressList(bool showFullCcAddressList = true);

    /** Show/Hide the field with id "field" */
    void toggleFullAddressList(const QString &field);

    void setZoomFactor(qreal zoomFactor);

    void goOnline();
    void goResourceOnline();

    void showOpenAttachmentFolderWidget(const QUrl &url);

    bool mimePartTreeIsEmpty() const;

    void setPluginName(const QString &pluginName);

    QList<QAction *> viewerPluginActionList(MessageViewer::ViewerPluginInterface::SpecificFeatureTypes features);
Laurent Montel's avatar
Laurent Montel committed
441
442
443
#ifdef MESSAGEVIEWER_USE_QTWEBENGINE
    QList<QAction *> interceptorUrlActions(const MessageViewer::WebHitTestResult &result) const;
#endif
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486

private Q_SLOTS:
    void slotActivatePlugin(MessageViewer::ViewerPluginInterface *interface);
    void slotModifyItemDone(KJob *job);
    void slotMessageMayBeAScam();
    void slotMessageIsNotAScam();
    void slotAddToWhiteList();

    /** Show hide all fields specified inside this function */
    void toggleFullAddressList();

    void itemFetchResult(KJob *job);

    void slotItemChanged(const Akonadi::Item &item, const QSet<QByteArray> &partIdentifiers);
    void slotItemMoved(const Akonadi::Item &, const Akonadi::Collection &, const Akonadi::Collection &);

    void itemModifiedResult(KJob *job);

    void collectionFetchedForStoringDecryptedMessage(KJob *job);

    void slotClear();

    void slotMessageRendered();

    void slotOpenWithAction(QAction *act);

    void slotOpenWithActionCurrentContent(QAction *act);

    void slotOpenWithDialog();

    void slotOpenWithDialogCurrentContent();

    void saveSplitterSizes() const;

    void slotRefreshMessage(const Akonadi::Item &item);
    void slotServiceUrlSelected(PimCommon::ShareServiceUrlManager::ServiceType serviceType);
    void slotStyleChanged(MessageViewer::HeaderStylePlugin *plugin);
    void slotStyleUpdated();
public Q_SLOTS:
    /** An URL has been activate with a click. */
    void slotUrlOpen(const QUrl &url = QUrl());

    /** The mouse has moved on or off an URL. */
Laurent Montel's avatar
Laurent Montel committed
487
    void slotUrlOn(const QString &link);
488
489

    /** The user presses the right mouse button on an URL. */
Laurent Montel's avatar
Laurent Montel committed
490
491
492
#ifdef MESSAGEVIEWER_USE_QTWEBENGINE
    void slotUrlPopup(const MessageViewer::WebHitTestResult &result);
#else
493
    void slotUrlPopup(const QUrl &, const QUrl &imageUrl, const QPoint &mousePos);
Laurent Montel's avatar
Laurent Montel committed
494
#endif
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566

    /** The user selected "Find" from the menu. */
    void slotFind();

    /** The user toggled the "Fixed Font" flag from the view menu. */
    void slotToggleFixedFont();
    void slotToggleMimePartTree();

    /** Show the message source */
    void slotShowMessageSource();

    /** Refresh the reader window */
    void updateReaderWin();

    void slotMimePartSelected(const QModelIndex &index);

    void slotIconicAttachments();
    void slotSmartAttachments();
    void slotInlineAttachments();
    void slotHideAttachments();
    void slotHeaderOnlyAttachments();

    /** Some attachment operations. */
    void slotDelayedResize();

    /** Print message. Called on as a response of finished() signal of mPartHtmlWriter
      after rendering is finished.
      In the very end it deletes the KMReaderWin window that was created
      for the purpose of rendering. */
    void slotPrintMsg();
    void slotPrintPreview();

    void slotSetEncoding();
    void injectAttachments();
    void slotSettingsChanged();
    void slotMimeTreeContextMenuRequested(const QPoint &pos);
    void slotAttachmentOpenWith();
    void slotAttachmentOpen();
    void slotAttachmentSaveAs();
    void slotAttachmentSaveAll();
    void slotAttachmentView();
    void slotAttachmentProperties();
    void slotAttachmentCopy();
    void slotAttachmentDelete();
    void slotAttachmentEdit();
    void slotLevelQuote(int l);

    /** Toggle display mode between HTML and plain text. */
    void slotToggleHtmlMode();
    void slotLoadExternalReference();

    /**
    * Does an action for the current attachment.
    * The action is defined by the KMHandleAttachmentCommand::AttachmentAction
    * enum.
    * prepareHandleAttachment() needs to be called before calling this to set the
    * correct attachment ID.
    */
    void slotHandleAttachment(int action);
    /** Copy the selected text to the clipboard */
    void slotCopySelectedText();

    void viewerSelectionChanged();

    /** Select message body. */
    void selectAll();

    /** Copy URL in mUrlCurrent to clipboard. Removes "mailto:" at
      beginning of URL before copying. */
    void slotUrlCopy();
    void slotSaveMessage();
    /** Re-parse the current message. */
567
    void update(MimeTreeParser::UpdateMode updateMode = MimeTreeParser::Delayed);
568
569
570
571
572
573
574
575
576
577
578
579
580
581

    void slotSpeakText();
    void slotCopyImageLocation();
    void slotSaveMessageDisplayFormat();
    void slotResetMessageDisplayFormat();
    void slotBlockImage();
    void slotOpenBlockableItems();

    void slotGeneralFontChanged();

Q_SIGNALS:
    void showStatusBarMessage(const QString &message);
    void replaceMsgByUnencryptedVersion();
    void popupMenu(const Akonadi::Item &msg, const QUrl &url, const QUrl &imageUrl, const QPoint &mousePos);
582
583
584
585
#ifdef MESSAGEVIEWER_USE_QTWEBENGINE
    void displayPopupMenu(const Akonadi::Item &msg, const MessageViewer::WebHitTestResult &result, const QPoint &mousePos);
#endif

586
587
588
589
590
591
592
593
594
    void urlClicked(const Akonadi::Item &msg, const QUrl &url);
    void requestConfigSync();
    void showReader(KMime::Content *aMsgPart, bool aHTML, const QString &encoding);
    void showMessage(const KMime::Message::Ptr &message, const QString &encoding);
    void itemRemoved();
    void makeResourceOnline(MessageViewer::Viewer::ResourceOnlineMode mode);

    void changeDisplayMail(Viewer::DisplayFormatMessage, bool);
    void moveMessageToTrash();
Laurent Montel's avatar
Laurent Montel committed
595
    void executeMailAction(MessageViewer::Viewer::MailAction type);
596
597
598
599
600
601
602
603
604
605
private:
    QString attachmentInjectionHtml();
    QString recipientsQuickListLinkHtml(bool, const QString &);

    Akonadi::Relation relatedNoteRelation() const;
    void addHelpTextAction(QAction *act, const QString &text);
    void readGravatarConfig();

    QString picsPath();
public:
606
    MimeTreeParser::NodeHelper *mNodeHelper;
607
608
609
610
611
612
613
614
615
616
617
618
    bool mHtmlMailGlobalSetting;
    bool mHtmlLoadExternalGlobalSetting;
    bool mHtmlLoadExtOverride;
    KMime::Message::Ptr mMessage; //the current message, if it was set manually
    Akonadi::Item mMessageItem; //the message item from Akonadi
    // widgets:
    QSplitter *mSplitter;
    QWidget *mBox;
    HtmlStatusBar *mColorBar;
#ifndef QT_NO_TREEVIEW
    MimePartTreeView *mMimePartTree;
#endif
619
620
#ifdef MESSAGEVIEWER_USE_QTWEBENGINE
    MailWebEngineView *mViewer;
Laurent Montel's avatar
Laurent Montel committed
621
    FindBarWebEngineView *mFindBar;
622
#else
623
    MailWebView *mViewer;
624
    FindBarWebView *mFindBar;
625
#endif
626

627
    const MimeTreeParser::AttachmentStrategy *mAttachmentStrategy;
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
    QTimer mUpdateReaderWinTimer;
    QTimer mResizeTimer;
    QString mOverrideEncoding;
    QString mOldGlobalOverrideEncoding; // used to detect changes of the global override character encoding
    QString mPicsPath;

    /// This is true if the viewer currently is displaying a message. Can be false, for example when
    /// the splash/busy page is displayed.
    bool mMsgDisplay;

    CSSHelper *mCSSHelper;
    bool mUseFixedFont;
    bool mPrinting;
    QWidget *mMainWindow;
    KActionCollection *mActionCollection;
    QAction *mCopyAction;
    QAction *mCopyURLAction;
    QAction *mUrlOpenAction;
    QAction *mSelectAllAction;
    QAction *mScrollUpAction;
    QAction *mScrollDownAction;
    QAction *mScrollUpMoreAction;
    QAction *mScrollDownMoreAction;
    QAction *mViewSourceAction;
    QAction *mSaveMessageAction;
    QAction *mFindInMessageAction;
    QAction *mSaveMessageDisplayFormat;
    QAction *mResetMessageDisplayFormat;
    KToggleAction *mHeaderOnlyAttachmentsAction;
    KSelectAction *mSelectEncodingAction;
    KToggleAction *mToggleFixFontAction;
    KToggleAction *mToggleDisplayModeAction;
    KToggleAction *mToggleMimePartTreeAction;
    QAction *mSpeakTextAction;
    QAction *mCopyImageLocation;
    QAction *mBlockImage;
    QAction *mBlockableItems;
    QUrl mHoveredUrl;
    QUrl mClickedUrl;
    QUrl mImageUrl;
    QPoint mLastClickPosition;
    bool mCanStartDrag;
670
    MimeTreeParser::HtmlWriter *mHtmlWriter;
671
672
    /** Used only to be able to connect and disconnect finished() signal
      in printMsg() and slotPrintMsg() since mHtmlWriter points only to abstract non-QObject class. */
673
674
675
#ifdef MESSAGEVIEWER_USE_QTWEBENGINE
    QPointer<WebEnginePartHtmlWriter> mPartHtmlWriter;
#else
676
    QPointer<WebKitPartHtmlWriter> mPartHtmlWriter;
677
#endif
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714

    float mSavedRelativePosition;
    int mLevelQuote;
    bool mDecrytMessageOverwrite;
    bool mShowSignatureDetails;
    bool mShowAttachmentQuicklist;
    bool mExternalWindow;
    bool mZoomTextOnly;
    int mRecursionCountForDisplayMessage;
    KMime::Content *mCurrentContent;
    KMime::Content *mMessagePartNode;
    QString mCurrentFileName;
    QString mMessagePath;
    Viewer *const q;
    bool mShowFullToAddressList;
    bool mShowFullCcAddressList;
    Akonadi::Monitor mMonitor;
    QString mAppName;
    QSet<AbstractMessageLoadedHandler *> mMessageLoadedHandlers;
    Akonadi::Item::Id mPreviouslyViewedItem;

    MessageViewer::ScamDetectionWarningWidget *mScamDetectionWarning;
    MessageViewer::OpenAttachmentFolderWidget *mOpenAttachmentFolderWidget;
    KPIMTextEdit::TextToSpeechWidget *mTextToSpeechWidget;
    Viewer::DisplayFormatMessage mDisplayFormatMessageOverwrite;
    KPIMTextEdit::SlideContainer *mSliderContainer;
    PimCommon::ShareServiceUrlManager *mShareServiceManager;
    KActionMenu *mShareServiceUrlMenu;
    MessageViewer::HeaderStylePlugin *mHeaderStylePlugin;
    MessageViewer::HeaderStyleMenuManager *mHeaderStyleMenuManager;
    MessageViewer::ViewerPluginToolManager *mViewerPluginToolManager;
    MessageViewer::ZoomActionMenu *mZoomActionMenu;
};

}

#endif