|
1 /**************************************************************************** |
|
2 ** |
|
3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
4 ** All rights reserved. |
|
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
|
6 ** |
|
7 ** This file is part of the Qt Mobility Components. |
|
8 ** |
|
9 ** $QT_BEGIN_LICENSE:LGPL$ |
|
10 ** No Commercial Usage |
|
11 ** This file contains pre-release code and may not be distributed. |
|
12 ** You may use this file in accordance with the terms and conditions |
|
13 ** contained in the Technology Preview License Agreement accompanying |
|
14 ** this package. |
|
15 ** |
|
16 ** GNU Lesser General Public License Usage |
|
17 ** Alternatively, this file may be used under the terms of the GNU Lesser |
|
18 ** General Public License version 2.1 as published by the Free Software |
|
19 ** Foundation and appearing in the file LICENSE.LGPL included in the |
|
20 ** packaging of this file. Please review the following information to |
|
21 ** ensure the GNU Lesser General Public License version 2.1 requirements |
|
22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
|
23 ** |
|
24 ** In addition, as a special exception, Nokia gives you certain additional |
|
25 ** rights. These rights are described in the Nokia Qt LGPL Exception |
|
26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
|
27 ** |
|
28 ** If you have questions regarding the use of this file, please contact |
|
29 ** Nokia at qt-info@nokia.com. |
|
30 ** |
|
31 ** |
|
32 ** |
|
33 ** |
|
34 ** |
|
35 ** |
|
36 ** |
|
37 ** |
|
38 ** $QT_END_LICENSE$ |
|
39 ** |
|
40 ****************************************************************************/ |
|
41 #include "maemohelpers_p.h" |
|
42 #include "qmessagefilter_p.h" |
|
43 #include "qmessagesortorder_p.h" |
|
44 #include "qmessageaccountfilter_p.h" |
|
45 #include "qmessageaccountsortorder_p.h" |
|
46 #include "qmessagefolderfilter_p.h" |
|
47 #include "qmessagefoldersortorder_p.h" |
|
48 #include "qmessagestore.h" |
|
49 |
|
50 QTM_BEGIN_NAMESPACE |
|
51 |
|
52 Q_GLOBAL_STATIC(MessagingHelper, messagingHelper); |
|
53 |
|
54 MessagingHelper* MessagingHelper::instance() |
|
55 { |
|
56 return messagingHelper(); |
|
57 } |
|
58 |
|
59 MessagingHelper::MessagingHelper() |
|
60 { |
|
61 } |
|
62 |
|
63 MessagingHelper::~MessagingHelper() |
|
64 { |
|
65 } |
|
66 |
|
67 |
|
68 void MessagingHelper::filterAccounts(QMessageAccountIdList& accountIds, const QMessageAccountFilter& filter) |
|
69 { |
|
70 if (accountIds.count() && !filter.isEmpty()) { |
|
71 QMessageAccountFilterPrivate* pf = QMessageAccountFilterPrivate::implementation(filter); |
|
72 if ((pf->_field == QMessageAccountFilterPrivate::None) && |
|
73 (pf->_filterList.count() == 0)) { |
|
74 if (pf->_notFilter) { |
|
75 // There is only one filter: empty ~QMessageFilter() |
|
76 // => accountIds must be cleared |
|
77 accountIds.clear(); |
|
78 return; |
|
79 } else { |
|
80 // There is only one filter: empty QMessageFilter() |
|
81 // => accountIds list can remain intact |
|
82 return; |
|
83 } |
|
84 } |
|
85 |
|
86 if (pf->_valid) { |
|
87 QMessageStore* store = QMessageStore::instance(); |
|
88 for (int i=accountIds.count()-1; i >= 0; i--) { |
|
89 QMessageAccount account = store->account(accountIds[i]); |
|
90 if (!pf->filter(account)) { |
|
91 accountIds.removeAt(i); |
|
92 } |
|
93 } |
|
94 } |
|
95 } |
|
96 } |
|
97 |
|
98 bool MessagingHelper::accountLessThan(const QMessageAccountId accountId1, const QMessageAccountId accountId2) |
|
99 { |
|
100 QMessageStore* store = QMessageStore::instance(); |
|
101 return QMessageAccountSortOrderPrivate::lessThan(*messagingHelper()->m_AccountSortOrder, |
|
102 store->account(accountId1), |
|
103 store->account(accountId2)); |
|
104 } |
|
105 |
|
106 void MessagingHelper::orderAccounts(QMessageAccountIdList& accountIds, const QMessageAccountSortOrder &sortOrder) |
|
107 { |
|
108 if (!sortOrder.isEmpty()) { |
|
109 messagingHelper()->m_AccountSortOrder = (QMessageAccountSortOrder*)&sortOrder; |
|
110 qSort(accountIds.begin(), accountIds.end(), MessagingHelper::accountLessThan); |
|
111 } |
|
112 } |
|
113 |
|
114 void MessagingHelper::applyOffsetAndLimitToAccountIdList(QMessageAccountIdList& accountIds, int limit, int offset) |
|
115 { |
|
116 if (accountIds.count() == 0) { |
|
117 return; |
|
118 } |
|
119 |
|
120 if (offset > 0) { |
|
121 if (offset > accountIds.count()) { |
|
122 accountIds.clear(); |
|
123 } else { |
|
124 for (int i = 0; i < offset; i++) { |
|
125 accountIds.removeFirst(); |
|
126 } |
|
127 } |
|
128 } |
|
129 if (limit > 0) { |
|
130 for (int i = accountIds.count()-1; i >= limit; i--) { |
|
131 accountIds.removeAt(i); |
|
132 } |
|
133 } |
|
134 } |
|
135 |
|
136 void MessagingHelper::filterFolders(QMessageFolderIdList& folderIds, const QMessageFolderFilter& filter) |
|
137 { |
|
138 if (folderIds.count() && !filter.isEmpty()) { |
|
139 QMessageFolderFilterPrivate* pf = QMessageFolderFilterPrivate::implementation(filter); |
|
140 if ((pf->_field == QMessageFolderFilterPrivate::None) && |
|
141 (pf->_filterList.count() == 0)) { |
|
142 if (pf->_notFilter) { |
|
143 // There is only one filter: empty ~QMessageFilter() |
|
144 // => accountIds must be cleared |
|
145 folderIds.clear(); |
|
146 return; |
|
147 } else { |
|
148 // There is only one filter: empty QMessageFilter() |
|
149 // => accountIds list can remain intact |
|
150 return; |
|
151 } |
|
152 } |
|
153 |
|
154 if (pf->_valid) { |
|
155 QMessageStore* store = QMessageStore::instance(); |
|
156 for (int i=folderIds.count()-1; i >= 0; i--) { |
|
157 QMessageFolder folder = store->folder(folderIds[i]); |
|
158 if (!pf->filter(folder)) { |
|
159 folderIds.removeAt(i); |
|
160 } |
|
161 } |
|
162 } |
|
163 } |
|
164 } |
|
165 |
|
166 bool MessagingHelper::folderLessThan(const QMessageFolderId folderId1, const QMessageFolderId folderId2) |
|
167 { |
|
168 QMessageStore* store = QMessageStore::instance(); |
|
169 return QMessageFolderSortOrderPrivate::lessThan(*messagingHelper()->m_FolderSortOrder, |
|
170 store->folder(folderId1), |
|
171 store->folder(folderId2)); |
|
172 } |
|
173 |
|
174 void MessagingHelper::orderFolders(QMessageFolderIdList& folderIds, const QMessageFolderSortOrder &sortOrder) |
|
175 { |
|
176 if (!sortOrder.isEmpty()) { |
|
177 messagingHelper()->m_FolderSortOrder = (QMessageFolderSortOrder*)&sortOrder; |
|
178 qSort(folderIds.begin(), folderIds.end(), MessagingHelper::folderLessThan); |
|
179 } |
|
180 } |
|
181 |
|
182 void MessagingHelper::applyOffsetAndLimitToFolderIdList(QMessageFolderIdList& folderIds, int limit, int offset) |
|
183 { |
|
184 if (folderIds.count() == 0) { |
|
185 return; |
|
186 } |
|
187 |
|
188 if (offset > 0) { |
|
189 if (offset > folderIds.count()) { |
|
190 folderIds.clear(); |
|
191 } else { |
|
192 for (int i = 0; i < offset; i++) { |
|
193 folderIds.removeFirst(); |
|
194 } |
|
195 } |
|
196 } |
|
197 if (limit > 0) { |
|
198 for (int i = folderIds.count()-1; i >= limit; i--) { |
|
199 folderIds.removeAt(i); |
|
200 } |
|
201 } |
|
202 } |
|
203 |
|
204 void MessagingHelper::filterMessages(QMessageIdList& messageIds, const QMessageFilter& filter) |
|
205 { |
|
206 if (messageIds.count() && !filter.isEmpty()) { |
|
207 QMessageFilterPrivate* pf = QMessageFilterPrivate::implementation(filter); |
|
208 if ((pf->_field == QMessageFilterPrivate::None) && |
|
209 (pf->_filterList.count() == 0)) { |
|
210 if (pf->_notFilter) { |
|
211 // There is only one filter: empty ~QMessageFilter() |
|
212 // => accountIds must be cleared |
|
213 messageIds.clear(); |
|
214 return; |
|
215 } else { |
|
216 // There is only one filter: empty QMessageFilter() |
|
217 // => accountIds list can remain intact |
|
218 return; |
|
219 } |
|
220 } |
|
221 |
|
222 if (pf->_valid) { |
|
223 QMessageStore* store = QMessageStore::instance(); |
|
224 for (int i=messageIds.count()-1; i >= 0; i--) { |
|
225 QMessage message = store->message(messageIds[i]); |
|
226 if (!pf->filter(message)) { |
|
227 messageIds.removeAt(i); |
|
228 } |
|
229 } |
|
230 } |
|
231 } |
|
232 } |
|
233 |
|
234 bool MessagingHelper::messageLessThan(const QMessageId messageId1, const QMessageId messageId2) |
|
235 { |
|
236 QMessageStore* store = QMessageStore::instance(); |
|
237 return QMessageSortOrderPrivate::lessThan(*messagingHelper()->m_MessageSortOrder, |
|
238 store->message(messageId1), |
|
239 store->message(messageId2)); |
|
240 } |
|
241 |
|
242 void MessagingHelper::orderMessages(QMessageIdList& messageIds, const QMessageSortOrder &sortOrder) |
|
243 { |
|
244 if (!sortOrder.isEmpty()) { |
|
245 messagingHelper()->m_MessageSortOrder = (QMessageSortOrder*)&sortOrder; |
|
246 qSort(messageIds.begin(), messageIds.end(), MessagingHelper::messageLessThan); |
|
247 } |
|
248 } |
|
249 |
|
250 void MessagingHelper::applyOffsetAndLimitToMessageIdList(QMessageIdList& messageIds, int limit, int offset) |
|
251 { |
|
252 if (messageIds.count() == 0) { |
|
253 return; |
|
254 } |
|
255 |
|
256 if (offset > 0) { |
|
257 if (offset > messageIds.count()) { |
|
258 messageIds.clear(); |
|
259 } else { |
|
260 for (int i = 0; i < offset; i++) { |
|
261 messageIds.removeFirst(); |
|
262 } |
|
263 } |
|
264 } |
|
265 if (limit > 0) { |
|
266 for (int i = messageIds.count()-1; i >= limit; i--) { |
|
267 messageIds.removeAt(i); |
|
268 } |
|
269 } |
|
270 } |
|
271 |
|
272 void MessagingHelper::handleNestedFiltersFromFolderFilter(QMessageFolderFilter &filter) |
|
273 { |
|
274 QMessageStore* store = QMessageStore::instance(); |
|
275 |
|
276 QMessageFolderFilterPrivate* pMFFilter = QMessageFolderFilterPrivate::implementation(filter); |
|
277 if (pMFFilter->_filterList.count() > 0) { |
|
278 int filterListCount = pMFFilter->_filterList.count(); |
|
279 for (int i=0; i < filterListCount; i++) { |
|
280 for (int j=0; j < pMFFilter->_filterList[i].count(); j++) { |
|
281 QMessageFolderFilterPrivate* pMFFilter2 = QMessageFolderFilterPrivate::implementation(pMFFilter->_filterList[i][j]); |
|
282 if (pMFFilter2->_field == QMessageFolderFilterPrivate::ParentAccountIdFilter) { |
|
283 QMessageAccountIdList accountIds = store->queryAccounts(*pMFFilter2->_accountFilter, QMessageAccountSortOrder(), 0, 0); |
|
284 QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter2->_comparatorValue)); |
|
285 if (accountIds.count() > 0) { |
|
286 pMFFilter->_filterList[i].removeAt(j); |
|
287 if (cmp == QMessageDataComparator::Includes) { |
|
288 for (int x = 0; x < accountIds.count(); x++) { |
|
289 if (x == 0) { |
|
290 if (x+1 < accountIds.count()) { |
|
291 pMFFilter->_filterList.append(pMFFilter->_filterList[i]); |
|
292 } |
|
293 pMFFilter->_filterList[i].append(QMessageFolderFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal)); |
|
294 qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFolderFilterPrivate::lessThan); |
|
295 } else { |
|
296 if (x+1 < accountIds.count()) { |
|
297 pMFFilter->_filterList.append(pMFFilter->_filterList[pMFFilter->_filterList.count()-1]); |
|
298 pMFFilter->_filterList[pMFFilter->_filterList.count()-2].append(QMessageFolderFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal)); |
|
299 qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-2].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-2].end(), QMessageFolderFilterPrivate::lessThan); |
|
300 } else { |
|
301 pMFFilter->_filterList[pMFFilter->_filterList.count()-1].append(QMessageFolderFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal)); |
|
302 qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-1].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-1].end(), QMessageFolderFilterPrivate::lessThan); |
|
303 } |
|
304 } |
|
305 } |
|
306 } else { // Excludes |
|
307 for (int x = 0; x < accountIds.count(); x++) { |
|
308 pMFFilter->_filterList[i].append(QMessageFolderFilter::byParentAccountId(accountIds[x],QMessageDataComparator::NotEqual)); |
|
309 } |
|
310 qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFolderFilterPrivate::lessThan); |
|
311 } |
|
312 } else { |
|
313 delete pMFFilter2->_accountFilter; |
|
314 pMFFilter2->_accountFilter = 0; |
|
315 pMFFilter2->_field = QMessageFolderFilterPrivate::Id; |
|
316 qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFolderFilterPrivate::lessThan); |
|
317 } |
|
318 } else { |
|
319 break; |
|
320 } |
|
321 } |
|
322 } |
|
323 } else { |
|
324 if (pMFFilter->_field == QMessageFolderFilterPrivate::ParentAccountIdFilter) { |
|
325 QMessageAccountIdList accountIds = store->queryAccounts(*pMFFilter->_accountFilter, QMessageAccountSortOrder(), 0, 0); |
|
326 QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter->_comparatorValue)); |
|
327 if (accountIds.count() > 0) { |
|
328 for (int i=0; i < accountIds.count(); i++) { |
|
329 if (i == 0) { |
|
330 delete pMFFilter->_accountFilter; |
|
331 pMFFilter->_accountFilter = 0; |
|
332 pMFFilter->_field = QMessageFolderFilterPrivate::ParentAccountId; |
|
333 pMFFilter->_value = accountIds[0].toString(); |
|
334 pMFFilter->_comparatorType = QMessageFolderFilterPrivate::Equality; |
|
335 if (cmp == QMessageDataComparator::Includes) { |
|
336 pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::Equal); |
|
337 } else { // Excludes |
|
338 pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::NotEqual); |
|
339 } |
|
340 } else { |
|
341 if (cmp == QMessageDataComparator::Includes) { |
|
342 filter |= QMessageFolderFilter::byParentAccountId(accountIds[i],QMessageDataComparator::Equal); |
|
343 } else { // Excludes |
|
344 filter &= QMessageFolderFilter::byParentAccountId(accountIds[i],QMessageDataComparator::NotEqual); |
|
345 } |
|
346 } |
|
347 } |
|
348 } else { |
|
349 delete pMFFilter->_accountFilter; |
|
350 pMFFilter->_accountFilter = 0; |
|
351 pMFFilter->_field = QMessageFolderFilterPrivate::Id; |
|
352 } |
|
353 } |
|
354 } |
|
355 } |
|
356 |
|
357 void MessagingHelper::handleNestedFiltersFromMessageFilter(QMessageFilter &filter) |
|
358 { |
|
359 QMessageStore* store = QMessageStore::instance(); |
|
360 |
|
361 QMessageFilterPrivate* pMFFilter = QMessageFilterPrivate::implementation(filter); |
|
362 if (pMFFilter->_filterList.count() > 0) { |
|
363 int filterListCount = pMFFilter->_filterList.count(); |
|
364 for (int i=0; i < filterListCount; i++) { |
|
365 for (int j=0; j < pMFFilter->_filterList[i].count(); j++) { |
|
366 QMessageFilterPrivate* pMFFilter2 = QMessageFilterPrivate::implementation(pMFFilter->_filterList[i][j]); |
|
367 if (pMFFilter2->_field == QMessageFilterPrivate::ParentAccountIdFilter) { |
|
368 QMessageAccountIdList accountIds = store->queryAccounts(*pMFFilter2->_accountFilter, QMessageAccountSortOrder(), 0, 0); |
|
369 QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter2->_comparatorValue)); |
|
370 if (accountIds.count() > 0) { |
|
371 pMFFilter->_filterList[i].removeAt(j); |
|
372 if (cmp == QMessageDataComparator::Includes) { |
|
373 for (int x = 0; x < accountIds.count(); x++) { |
|
374 if (x == 0) { |
|
375 if (x+1 < accountIds.count()) { |
|
376 pMFFilter->_filterList.append(pMFFilter->_filterList[i]); |
|
377 } |
|
378 pMFFilter->_filterList[i].append(QMessageFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal)); |
|
379 qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan); |
|
380 } else { |
|
381 if (x+1 < accountIds.count()) { |
|
382 pMFFilter->_filterList.append(pMFFilter->_filterList[pMFFilter->_filterList.count()-1]); |
|
383 pMFFilter->_filterList[pMFFilter->_filterList.count()-2].append(QMessageFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal)); |
|
384 qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-2].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-2].end(), QMessageFilterPrivate::lessThan); |
|
385 } else { |
|
386 pMFFilter->_filterList[pMFFilter->_filterList.count()-1].append(QMessageFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal)); |
|
387 qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-1].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-1].end(), QMessageFilterPrivate::lessThan); |
|
388 } |
|
389 } |
|
390 } |
|
391 } else { // Excludes |
|
392 for (int x = 0; x < accountIds.count(); x++) { |
|
393 pMFFilter->_filterList[i].append(QMessageFilter::byParentAccountId(accountIds[x],QMessageDataComparator::NotEqual)); |
|
394 } |
|
395 qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan); |
|
396 } |
|
397 } else { |
|
398 delete pMFFilter2->_accountFilter; |
|
399 pMFFilter2->_accountFilter = 0; |
|
400 pMFFilter2->_field = QMessageFilterPrivate::Id; |
|
401 qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan); |
|
402 } |
|
403 } else if (pMFFilter2->_field == QMessageFilterPrivate::ParentFolderIdFilter) { |
|
404 QMessageFolderIdList folderIds = store->queryFolders(*pMFFilter2->_folderFilter, QMessageFolderSortOrder(), 0, 0); |
|
405 QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter2->_comparatorValue)); |
|
406 if (folderIds.count() > 0) { |
|
407 pMFFilter->_filterList[i].removeAt(j); |
|
408 if (cmp == QMessageDataComparator::Includes) { |
|
409 for (int x = 0; x < folderIds.count(); x++) { |
|
410 if (x == 0) { |
|
411 if (x+1 < folderIds.count()) { |
|
412 pMFFilter->_filterList.append(pMFFilter->_filterList[i]); |
|
413 } |
|
414 pMFFilter->_filterList[i].append(QMessageFilter::byParentFolderId(folderIds[x],QMessageDataComparator::Equal)); |
|
415 qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan); |
|
416 } else { |
|
417 if (x+1 < folderIds.count()) { |
|
418 pMFFilter->_filterList.append(pMFFilter->_filterList[pMFFilter->_filterList.count()-1]); |
|
419 pMFFilter->_filterList[pMFFilter->_filterList.count()-2].append(QMessageFilter::byParentFolderId(folderIds[x],QMessageDataComparator::Equal)); |
|
420 qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-2].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-2].end(), QMessageFilterPrivate::lessThan); |
|
421 } else { |
|
422 pMFFilter->_filterList[pMFFilter->_filterList.count()-1].append(QMessageFilter::byParentFolderId(folderIds[x],QMessageDataComparator::Equal)); |
|
423 qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-1].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-1].end(), QMessageFilterPrivate::lessThan); |
|
424 } |
|
425 } |
|
426 } |
|
427 } else { // Excludes |
|
428 for (int x = 0; x < folderIds.count(); x++) { |
|
429 pMFFilter->_filterList[i].append(QMessageFilter::byParentFolderId(folderIds[x],QMessageDataComparator::NotEqual)); |
|
430 } |
|
431 qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan); |
|
432 } |
|
433 } else { |
|
434 delete pMFFilter2->_folderFilter; |
|
435 pMFFilter2->_folderFilter = 0; |
|
436 pMFFilter2->_field = QMessageFilterPrivate::Id; |
|
437 qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan); |
|
438 } |
|
439 } else { |
|
440 break; |
|
441 } |
|
442 } |
|
443 } |
|
444 } else { |
|
445 if (pMFFilter->_field == QMessageFilterPrivate::ParentAccountIdFilter) { |
|
446 QMessageAccountIdList accountIds = store->queryAccounts(*pMFFilter->_accountFilter, QMessageAccountSortOrder(), 0, 0); |
|
447 QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter->_comparatorValue)); |
|
448 if (accountIds.count() > 0) { |
|
449 for (int i=0; i < accountIds.count(); i++) { |
|
450 if (i == 0) { |
|
451 delete pMFFilter->_accountFilter; |
|
452 pMFFilter->_accountFilter = 0; |
|
453 pMFFilter->_field = QMessageFilterPrivate::ParentAccountId; |
|
454 pMFFilter->_value = accountIds[0].toString(); |
|
455 pMFFilter->_comparatorType = QMessageFilterPrivate::Equality; |
|
456 if (cmp == QMessageDataComparator::Includes) { |
|
457 pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::Equal); |
|
458 } else { // Excludes |
|
459 pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::NotEqual); |
|
460 } |
|
461 } else { |
|
462 if (cmp == QMessageDataComparator::Includes) { |
|
463 filter |= QMessageFilter::byParentAccountId(accountIds[i],QMessageDataComparator::Equal); |
|
464 } else { // Excludes |
|
465 filter &= QMessageFilter::byParentAccountId(accountIds[i],QMessageDataComparator::NotEqual); |
|
466 } |
|
467 } |
|
468 } |
|
469 } else { |
|
470 delete pMFFilter->_accountFilter; |
|
471 pMFFilter->_accountFilter = 0; |
|
472 pMFFilter->_field = QMessageFilterPrivate::Id; |
|
473 } |
|
474 } else if (pMFFilter->_field == QMessageFilterPrivate::ParentFolderIdFilter) { |
|
475 QMessageFolderIdList folderIds = store->queryFolders(*pMFFilter->_folderFilter, QMessageFolderSortOrder(), 0, 0); |
|
476 QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter->_comparatorValue)); |
|
477 if (folderIds.count() > 0) { |
|
478 for (int i=0; i < folderIds.count(); i++) { |
|
479 if (i == 0) { |
|
480 delete pMFFilter->_folderFilter; |
|
481 pMFFilter->_folderFilter = 0; |
|
482 pMFFilter->_field = QMessageFilterPrivate::ParentFolderId; |
|
483 pMFFilter->_value = folderIds[0].toString(); |
|
484 pMFFilter->_comparatorType = QMessageFilterPrivate::Equality; |
|
485 if (cmp == QMessageDataComparator::Includes) { |
|
486 pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::Equal); |
|
487 } else { // Excludes |
|
488 pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::NotEqual); |
|
489 } |
|
490 } else { |
|
491 if (cmp == QMessageDataComparator::Includes) { |
|
492 filter |= QMessageFilter::byParentFolderId(folderIds[i],QMessageDataComparator::Equal); |
|
493 } else { // Excludes |
|
494 filter &= QMessageFilter::byParentFolderId(folderIds[i],QMessageDataComparator::NotEqual); |
|
495 } |
|
496 } |
|
497 } |
|
498 } else { |
|
499 delete pMFFilter->_folderFilter; |
|
500 pMFFilter->_folderFilter = 0; |
|
501 pMFFilter->_field = QMessageFilterPrivate::Id; |
|
502 } |
|
503 } |
|
504 } |
|
505 } |
|
506 |
|
507 QTM_END_NAMESPACE |