1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/*
* kmail: KDE mail client
* Copyright (c) 1996-1998 Stefan Taferner <taferner@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.
*
*/
#ifndef kmfiltermgr_h
#define kmfiltermgr_h
#include "kmfilteraction.h" // for KMFilterAction::ReturnCode
#include "kmfolder.h"
#include <tqguardedptr.h>
#include <tqobject.h>
class KMFilter;
class KMFilterDlg;
template <typename T> class TQValueVector;
template <typename T> class TQValueList;
class KMFilterMgr: public QObject
{
Q_OBJECT
public:
KMFilterMgr(bool popFilter = false);
virtual ~KMFilterMgr();
/** Clears the list of filters and deletes them. */
void clear();
enum FilterSet { NoSet = 0x0, Inbound = 0x1, Outbound = 0x2, Explicit = 0x4,
All = Inbound|Outbound|Explicit };
/** Reload filter rules from config file. */
void readConfig(void);
/** Store filter rules in config file. */
void writeConfig(bool withSync=TRUE);
/** Open an edit dialog. If checkForEmptyFilterList is true, an empty filter
is created to improve the visibility of the dialog in case no filter
has been defined so far. */
void openDialog( TQWidget *parent, bool checkForEmptyFilterList = true );
/** Open an edit dialog, create a new filter and preset the first
rule with "field equals value" */
void createFilter( const TQCString & field, const TQString & value );
bool beginFiltering(KMMsgBase *msgBase) const;
int moveMessage(KMMessage *msg) const;
void endFiltering(KMMsgBase *msgBase) const;
/**
* Returns whether at least one filter applies to this account,
* which means that mail must be downloaded in order to be filtered,
* for example;
* */
bool atLeastOneFilterAppliesTo( unsigned int accountID ) const;
/**
* Returns whether at least one incoming filter applies to this account,
* which means that mail must be downloaded in order to be filtered,
* for example;
* */
bool atLeastOneIncomingFilterAppliesTo( unsigned int accountID ) const;
/** Returns whether at least one filter targets a folder on an
* online IMAP account.
* */
bool atLeastOneOnlineImapFolderTarget();
/** Check for existing filters with the &p name and extend the
"name" to "name (i)" until no match is found for i=1..n */
const TQString createUniqueName( const TQString & name );
/** Append the list of filters to the current list of filters and
write everything back into the configuration. The filter manager
takes ownership of the filters in the list. */
void appendFilters( const TQValueList<KMFilter*> &filters,
bool tqreplaceIfNameExists = false );
/** Replace the list of filters under control of the filter manager.
* The manager takes ownershipt of the filters. */
void setFilters( const TQValueList<KMFilter*> &filters );
/** @return the list of filters managed by this object */
const TQValueList<KMFilter*> & filters() const { return mFilters; }
/** Process given message by applying the filter rules one by
one. You can select which set of filters (incoming or outgoing)
should be used.
@param msg The message to process.
@param aSet Select the filter set to use.
@param account true if an account id is specified else false
@param accountId The id of the KMAccount that the message was
retrieved from
@return 2 if a critical error occurred (eg out of disk space)
1 if the caller is still owner of the message and
0 otherwise. If the caller does not any longer own the message
he *must* not delete the message or do similar stupid things. ;-)
*/
int process( KMMessage * msg, FilterSet aSet = Inbound,
bool account = false, uint accountId = 0 );
/** For ad-hoc filters. Applies @p filter to @p msg. Return codes
are as with the above method.
@deprecated Use int process( quint32, const KMFilter * )
*/
int process( KMMessage * msg, const KMFilter * filter );
/** For ad-hoc filters. Applies @p filter to message with @p serNum .
Return codes are as with the above method. */
int process( TQ_UINT32 serNum, const KMFilter * filter );
void cleanup();
/** Increment the reference count for the filter manager.
Call this method before processing messages with process() */
void ref();
/** Decrement the reference count for the filter manager.
Call this method after processing messages with process().
Shall be called after all messages are processed.
If the reference count is zero then this method closes all folders
that have been temporarily opened with tempOpenFolder(). */
void deref(bool force = false);
/** Open given folder and mark it as temporarily open. The folder
will be closed upon next call of cleanip(). This method is
usually only called from within filter actions during process().
Returns returncode from KMFolder::open() call. */
int tempOpenFolder(KMFolder* aFolder);
/** Called at the beginning of an filter list update. Currently a
no-op */
void beginUpdate() {}
/** Called at the end of an filter list update. */
void endUpdate();
/** Output all rules to stdout */
#ifndef NDEBUG
void dump() const;
#endif
/** Called from the folder manager when a folder is removed.
Tests if the folder aFolder is used in any action. Changes
to aNewFolder folder in this case. Returns TRUE if a change
occurred. */
bool folderRemoved(KMFolder* aFolder, KMFolder* aNewFolder);
/** Called from the folder manager when a new folder has been
created. Forwards this to the filter dialog if that is open. */
void folderCreated(KMFolder*) {}
/** Set the global option 'Show Download Later Messages' */
void setShowLaterMsgs( bool show ) {
mShowLater = show;
}
/** Get the global option 'Show Download Later Messages' */
bool showLaterMsgs() const {
return mShowLater;
}
public slots:
void slotFolderRemoved( KMFolder *aFolder );
signals:
void filterListUpdated();
private:
int processPop( KMMessage *msg ) const;
/** Find out if a message matches the filter criteria */
bool isMatching( TQ_UINT32 serNum, const KMFilter *filter );
TQGuardedPtr<KMFilterDlg> mEditDialog;
TQValueVector<KMFolder *> mOpenFolders;
TQValueList<KMFilter *> mFilters;
bool bPopFilter;
bool mShowLater;
bool mDirtyBufferedFolderTarget;
bool mBufferedFolderTarget;
int mRefCount;
};
#endif /*kmfiltermgr_h*/
|
