Messagelib

filter.cpp
1/******************************************************************************
2 *
3 * SPDX-FileCopyrightText: 2008 Szymon Tomasz Stefanek <pragma@kvirc.net>
4 *
5 * SPDX-License-Identifier: GPL-2.0-or-later
6 *
7 *******************************************************************************/
8
9#include "core/filter.h"
10#include "config-messagelist.h"
11#include "core/messageitem.h"
12#include "tagmanager.h"
13#include <MessageCore/StringUtil>
14#include <TextUtils/ConvertText>
15
16#include <KRandom>
17#if !FORCE_DISABLE_AKONADI_SEARCH
18#include <PIM/emailquery.h>
19#include <PIM/resultiterator.h>
20#endif
21using namespace MessageList::Core;
22
23Filter::Filter(QObject *parent)
24 : QObject(parent)
25{
26 generateRandomIdentifier();
27}
28
29bool Filter::containString(const QString &searchInString) const
30{
31 bool found = false;
32 const QString searchInStringNormalize{TextUtils::ConvertText::normalize(searchInString)};
33 for (const QString &str : std::as_const(mSearchList)) {
34 if (searchInStringNormalize.contains(TextUtils::ConvertText::normalize(str), Qt::CaseInsensitive)) {
35 found = true;
36 } else {
37 found = false;
38 break;
39 }
40 }
41 return found;
42}
43
44const QString &Filter::iconName() const
45{
46 return mIconName;
47}
48
49void Filter::setIconName(const QString &newIconName)
50{
51 mIconName = newIconName;
52}
53
54void Filter::setOptions(SearchMessageByButtons::SearchOptions newOptions)
55{
56 mOptions = newOptions;
57}
58
59const QString &Filter::filterName() const
60{
61 return mFilterName;
62}
63
64void Filter::setFilterName(const QString &newFilterName)
65{
66 mFilterName = newFilterName;
67}
68
69void Filter::setIdentifier(const QString &newIdentifier)
70{
71 mIdentifier = newIdentifier;
72}
73
74bool Filter::match(const MessageItem *item) const
75{
76 if (!mStatus.isEmpty()) {
77 for (Akonadi::MessageStatus status : std::as_const(mStatus)) {
78 if (!(status & item->status())) {
79 return false;
80 }
81 }
82 }
83
84 if (!mSearchString.isEmpty()) {
85 if (mMatchingItemIds.contains(item->itemId())) {
86 return true;
87 }
88
89 bool searchMatches = false;
90 bool searchEveryWhere = (mOptions & SearchMessageByButtons::SearchEveryWhere);
91 if (containString(item->subject()) && ((mOptions & SearchMessageByButtons::SearchAgainstSubject) || searchEveryWhere)) {
92 searchMatches = true;
93 } else if (containString(item->sender()) && ((mOptions & SearchMessageByButtons::SearchAgainstFrom) || searchEveryWhere)) {
94 searchMatches = true;
95 } else if (containString(item->receiver()) && ((mOptions & SearchMessageByButtons::SearchAgainstTo) || searchEveryWhere)) {
96 searchMatches = true;
97 }
98 if (!searchMatches) {
99 return false;
100 }
101 }
102
103 if (!mTagIds.isEmpty()) {
104 // mTagIds is a Akonadi::Tag::url
105 for (const auto &tag : mTagIds) {
106 const bool tagMatches = item->findTag(tag) != nullptr;
107 if (!tagMatches) {
108 return false;
109 }
110 }
111 }
112
113 return true;
114}
115
116QList<Akonadi::MessageStatus> Filter::status() const
117{
118 return mStatus;
119}
120
121void Filter::setStatus(const QList<Akonadi::MessageStatus> &lstStatus)
122{
123 mStatus = lstStatus;
124}
125
126bool Filter::isEmpty() const
127{
128 if (!mStatus.isEmpty()) {
129 return false;
130 }
131
132 if (!mSearchString.isEmpty()) {
133 return false;
134 }
135
136 if (!mTagIds.isEmpty()) {
137 return false;
138 }
139
140 return true;
141}
142
143void Filter::clear()
144{
145 mStatus.clear();
146 mSearchString.clear();
147 mTagIds.clear();
148 mMatchingItemIds.clear();
149 mSearchList.clear();
150}
151
152void Filter::setCurrentFolder(const Akonadi::Collection &folder)
153{
154 mCurrentFolder = folder;
155}
156
157QList<SearchLineCommand::SearchLineInfo> Filter::searchLineCommands() const
158{
159 const QString text = mSearchString;
160 QList<SearchLineCommand::SearchLineInfo> infos;
161 if (mOptions & SearchMessageByButtons::SearchAgainstBody) {
162 SearchLineCommand::SearchLineInfo i;
163 i.type = SearchLineCommand::SearchLineType::Body;
164 i.argument = mSearchString;
165 if (i.isValid()) {
166 infos.append(std::move(i));
167 }
168 }
169 if (mOptions & SearchMessageByButtons::SearchAgainstSubject) {
170 SearchLineCommand::SearchLineInfo i;
171 i.type = SearchLineCommand::SearchLineType::Subject;
172 i.argument = mSearchString;
173 if (i.isValid()) {
174 infos.append(std::move(i));
175 }
176 }
177 if (mOptions & SearchMessageByButtons::SearchAgainstBcc) {
178 SearchLineCommand::SearchLineInfo i;
179 i.type = SearchLineCommand::SearchLineType::Bcc;
180 i.argument = mSearchString;
181 if (i.isValid()) {
182 infos.append(std::move(i));
183 }
184 }
185 if (mOptions & SearchMessageByButtons::SearchAgainstCc) {
186 SearchLineCommand::SearchLineInfo i;
187 i.type = SearchLineCommand::SearchLineType::Cc;
188 i.argument = mSearchString;
189 if (i.isValid()) {
190 infos.append(std::move(i));
191 }
192 }
193
194 for (Akonadi::MessageStatus status : status()) {
195 if (status.hasAttachment()) {
196 SearchLineCommand::SearchLineInfo i;
197 i.type = SearchLineCommand::SearchLineType::HasAttachment;
198 if (i.isValid()) {
199 infos.append(std::move(i));
200 }
201 } else if (status.hasInvitation()) {
202 SearchLineCommand::SearchLineInfo i;
203 i.type = SearchLineCommand::SearchLineType::HasInvitation;
204 if (i.isValid()) {
205 infos.append(std::move(i));
206 }
207 } else if (status.isImportant()) {
208 SearchLineCommand::SearchLineInfo i;
209 i.type = SearchLineCommand::SearchLineType::IsImportant;
210 if (i.isValid()) {
211 infos.append(std::move(i));
212 }
213 } else if (status.isEncrypted()) {
214 SearchLineCommand::SearchLineInfo i;
215 i.type = SearchLineCommand::SearchLineType::IsEncrypted;
216 if (i.isValid()) {
217 infos.append(std::move(i));
218 }
219 } else if (status.isReplied()) {
220 SearchLineCommand::SearchLineInfo i;
221 i.type = SearchLineCommand::SearchLineType::IsReplied;
222 if (i.isValid()) {
223 infos.append(std::move(i));
224 }
225 } else if (status.isForwarded()) {
226 SearchLineCommand::SearchLineInfo i;
227 i.type = SearchLineCommand::SearchLineType::IsForwarded;
228 if (i.isValid()) {
229 infos.append(std::move(i));
230 }
231 } else if (status.isRead()) {
232 SearchLineCommand::SearchLineInfo i;
233 i.type = SearchLineCommand::SearchLineType::IsRead;
234 if (i.isValid()) {
235 infos.append(std::move(i));
236 }
237 } else if (status.isIgnored()) {
238 SearchLineCommand::SearchLineInfo i;
239 i.type = SearchLineCommand::SearchLineType::IsIgnored;
240 if (i.isValid()) {
241 infos.append(std::move(i));
242 }
243 } else if (status.isSpam()) {
244 SearchLineCommand::SearchLineInfo i;
245 i.type = SearchLineCommand::SearchLineType::IsSpam;
246 if (i.isValid()) {
247 infos.append(std::move(i));
248 }
249 } else if (status.isHam()) {
250 SearchLineCommand::SearchLineInfo i;
251 i.type = SearchLineCommand::SearchLineType::IsHam;
252 if (i.isValid()) {
253 infos.append(std::move(i));
254 }
255 } else if (status.isQueued()) {
256 SearchLineCommand::SearchLineInfo i;
257 i.type = SearchLineCommand::SearchLineType::IsQueued;
258 if (i.isValid()) {
259 infos.append(std::move(i));
260 }
261 } else if (status.isSent()) {
262 SearchLineCommand::SearchLineInfo i;
263 i.type = SearchLineCommand::SearchLineType::IsSent;
264 if (i.isValid()) {
265 infos.append(std::move(i));
266 }
267 } else if (status.isDeleted()) {
268 SearchLineCommand::SearchLineInfo i;
269 i.type = SearchLineCommand::SearchLineType::IsDeleted;
270 if (i.isValid()) {
271 infos.append(std::move(i));
272 }
273 } else if (status.isWatched()) {
274 SearchLineCommand::SearchLineInfo i;
275 i.type = SearchLineCommand::SearchLineType::IsWatched;
276 if (i.isValid()) {
277 infos.append(std::move(i));
278 }
279 } else if (status.isToAct()) {
280 SearchLineCommand::SearchLineInfo i;
281 i.type = SearchLineCommand::SearchLineType::IsAction;
282 if (i.isValid()) {
283 infos.append(std::move(i));
284 }
285 }
286 }
287
288#if 0
289
290 if (mContainsOutboundMessages) {
291 mButtonGroup->button(SearchMessageByButtons::SearchAgainstTo)->setChecked(opts & SearchMessageByButtons::SearchAgainstTo);
292 } else {
293 mButtonGroup->button(SearchMessageByButtons::SearchAgainstTo)->setChecked(opts & SearchMessageByButtons::SearchAgainstFrom);
294 }
295#endif
296 SearchLineCommand command;
297 command.parseSearchLineCommand(text);
298 infos += command.searchLineInfo();
299 return infos;
300}
301
302const QString &Filter::searchString() const
303{
304 return mSearchString;
305}
306
307SearchMessageByButtons::SearchOptions Filter::currentOptions() const
308{
309 return mOptions;
310}
311
312void Filter::save(const KSharedConfig::Ptr &config, const QString &filtername, const QString &iconName, int numFilter)
313{
314 KConfigGroup grp(config, QStringLiteral("General"));
315 int numberFilter = (numFilter == -1) ? grp.readEntry("NumberFilter").toInt() : numFilter;
316 KConfigGroup newGroup(config, QStringLiteral("Filter_%1").arg(numberFilter++));
317 newGroup.writeEntry("name", filtername);
318 if (!iconName.isEmpty()) {
319 newGroup.writeEntry("iconName", iconName);
320 }
321 newGroup.writeEntry("searchString", mSearchString);
322 newGroup.writeEntry("searchOptions", static_cast<int>(mOptions));
323 newGroup.writeEntry("tagId", mTagIds);
324 newGroup.writeEntry("identifier", mIdentifier);
325 QList<qint32> lst;
326 lst.reserve(mStatus.count());
327 for (const auto s : std::as_const(mStatus)) {
328 lst << s.toQInt32();
329 }
330 newGroup.writeEntry("status", lst);
331 newGroup.sync();
332 grp.writeEntry("NumberFilter", numberFilter);
333 grp.sync();
334 config->reparseConfiguration();
335}
336
337Filter *Filter::load(const KSharedConfig::Ptr &config, int filternumber)
338{
339 KConfigGroup grp(config, QStringLiteral("General"));
340 int numberFilter = grp.readEntry("NumberFilter").toInt();
341 if (filternumber < numberFilter) {
342 KConfigGroup newGroup(config, QStringLiteral("Filter_%1").arg(filternumber));
343 return loadFromConfigGroup(newGroup);
344 }
345 return nullptr;
346}
347
348Filter *Filter::loadFromConfigGroup(const KConfigGroup &newGroup)
349{
350 auto filter = new Filter();
351 filter->setSearchString(newGroup.readEntry("searchString"),
352 static_cast<SearchMessageByButtons::SearchOptions>(newGroup.readEntry("searchOptions").toInt()));
353 filter->setTagId(newGroup.readEntry("tagId", QStringList()));
354 filter->setIdentifier(newGroup.readEntry("identifier"));
355 filter->setFilterName(newGroup.readEntry("name"));
356 filter->setIconName(newGroup.readEntry("iconName"));
357 const QList<qint32> lst = newGroup.readEntry("status", QList<qint32>());
358 QList<Akonadi::MessageStatus> messageStatusLst;
359 messageStatusLst.reserve(lst.count());
360 for (const auto s : std::as_const(lst)) {
361 Akonadi::MessageStatus status;
362 status.fromQInt32(s);
363 messageStatusLst << status;
364 }
365 filter->setStatus(messageStatusLst);
366 filter->setOptions(static_cast<SearchMessageByButtons::SearchOptions>(newGroup.readEntry("searchOptions").toInt()));
367 return filter;
368}
369
370void Filter::setSearchString(const SearchLineCommand &command)
371{
372#if !FORCE_DISABLE_AKONADI_SEARCH
373 mMatchingItemIds.clear();
374 if (command.isEmpty()) {
375 return;
376 }
377 const QList<SearchLineCommand::SearchLineInfo> infos = command.searchLineInfo();
378 QList<Akonadi::MessageStatus> lstStatus;
379 Akonadi::Search::PIM::EmailQuery query;
380 for (const auto &info : infos) {
381 switch (info.type) {
382 case SearchLineCommand::Literal: {
383 QString newStr;
384 const QStringList searchListTmp = info.argument.split(QLatin1Char(' '), Qt::SkipEmptyParts);
385 bool needToSplitString = false;
386 for (const QString &text : searchListTmp) {
387 if (text.size() >= 3) {
388 if (!newStr.isEmpty()) {
389 newStr += QLatin1Char(' ');
390 }
391 newStr += text;
392 }
393 }
394 needToSplitString = true;
395
396 mSearchString = newStr;
397 query.matches(newStr);
398 query.setSplitSearchMatchString(needToSplitString);
399 break;
400 }
401 case SearchLineCommand::Subject: {
402 mSearchString = info.argument;
403 query.subjectMatches(mSearchString);
404 break;
405 }
406 case SearchLineCommand::Body: {
407 mSearchString = info.argument;
408 query.bodyMatches(mSearchString);
409 break;
410 }
411 case SearchLineCommand::Unknown:
412 case SearchLineCommand::HasStateOrAttachment:
413 // Nothing
414 break;
415 case SearchLineCommand::Larger:
416 case SearchLineCommand::Smaller:
417 case SearchLineCommand::OlderThan:
418 case SearchLineCommand::NewerThan:
419 case SearchLineCommand::Date:
420 case SearchLineCommand::Size:
421 break;
422 case SearchLineCommand::Category: {
423 const QString tagUrl = TagManager::self()->tagFromName(info.argument);
424 addTagId(tagUrl.isEmpty() ? info.argument : tagUrl);
425 break;
426 }
427 case SearchLineCommand::HasAttachment: {
428 Akonadi::MessageStatus status;
429 status.setHasAttachment(true);
430 lstStatus.append(status);
431 break;
432 }
433 case SearchLineCommand::HasInvitation: {
434 Akonadi::MessageStatus status;
435 status.setHasInvitation(true);
436 lstStatus.append(status);
437 break;
438 }
439 case SearchLineCommand::IsImportant: {
440 Akonadi::MessageStatus status;
441 status.setImportant(true);
442 lstStatus.append(status);
443 break;
444 }
445 case SearchLineCommand::IsRead: {
446 Akonadi::MessageStatus status;
447 status.setRead(true);
448 lstStatus.append(status);
449 break;
450 }
451 case SearchLineCommand::IsUnRead: {
452 // TODO verify
453 Akonadi::MessageStatus status;
454 status.setRead(false);
455 lstStatus.append(status);
456 break;
457 }
458 case SearchLineCommand::IsIgnored: {
459 Akonadi::MessageStatus status;
460 status.setIgnored(true);
461 lstStatus.append(status);
462 break;
463 }
464 case SearchLineCommand::IsHam: {
465 Akonadi::MessageStatus status;
466 status.setHam(true);
467 lstStatus.append(status);
468 break;
469 }
470 case SearchLineCommand::IsSpam: {
471 Akonadi::MessageStatus status;
472 status.setSpam(true);
473 lstStatus.append(status);
474 break;
475 }
476 case SearchLineCommand::IsWatched: {
477 Akonadi::MessageStatus status;
478 status.setWatched(true);
479 lstStatus.append(status);
480 break;
481 }
482 case SearchLineCommand::IsReplied: {
483 Akonadi::MessageStatus status;
484 status.setReplied(true);
485 lstStatus.append(status);
486 break;
487 }
488 case SearchLineCommand::IsEncrypted: {
489 Akonadi::MessageStatus status;
490 status.setEncrypted(true);
491 lstStatus.append(status);
492 break;
493 }
494 case SearchLineCommand::IsQueued: {
495 Akonadi::MessageStatus status;
496 status.setQueued(true);
497 lstStatus.append(status);
498 break;
499 }
500 case SearchLineCommand::IsAction: {
501 Akonadi::MessageStatus status;
502 status.setToAct(true);
503 lstStatus.append(status);
504 break;
505 }
506 case SearchLineCommand::IsDeleted: {
507 Akonadi::MessageStatus status;
508 status.setDeleted(true);
509 lstStatus.append(status);
510 break;
511 }
512 case SearchLineCommand::IsSent: {
513 Akonadi::MessageStatus status;
514 status.setSent(true);
515 lstStatus.append(status);
516 break;
517 }
518 case SearchLineCommand::IsForwarded: {
519 Akonadi::MessageStatus status;
520 status.setForwarded(true);
521 lstStatus.append(status);
522 break;
523 }
524 case SearchLineCommand::To: {
525 mSearchString = info.argument;
526 query.addTo(info.argument);
527 break;
528 }
529 case SearchLineCommand::Bcc: {
530 mSearchString = info.argument;
531 query.addBcc(info.argument);
532 break;
533 }
534 case SearchLineCommand::From: {
535 mSearchString = info.argument;
536 query.addFrom(info.argument);
537 break;
538 }
539 case SearchLineCommand::Cc: {
540 mSearchString = info.argument;
541 query.addCc(info.argument);
542 break;
543 }
544 }
545 }
546
547 setStatus(lstStatus);
548 // If the collection is virtual we're probably trying to filter the search collection, so we just search globally
549 if (mCurrentFolder.isValid() && !mCurrentFolder.isVirtual()) {
550 query.addCollection(mCurrentFolder.id());
551 }
552
553 Akonadi::Search::PIM::ResultIterator it = query.exec();
554 while (it.next()) {
555 mMatchingItemIds << it.id();
556 }
557 Q_EMIT finished();
558#endif
559}
560
561void Filter::setSearchString(const QString &search, SearchMessageByButtons::SearchOptions options)
562{
563#if !FORCE_DISABLE_AKONADI_SEARCH
564 const QString trimStr = search.trimmed();
565 if ((mSearchString == trimStr) && (mOptions == options)) {
566 return;
567 }
568 mOptions = options;
569 mSearchString = trimStr;
570 mMatchingItemIds.clear();
571
572 if (mSearchString.isEmpty()) {
573 return;
574 }
575 bool needToSplitString = false;
576 QString newStr = mSearchString;
577 if (mSearchString.startsWith(QLatin1Char('"')) && mSearchString.startsWith(QLatin1Char('"'))) {
578 newStr.remove(0, 1);
579 newStr.remove(newStr.length() - 1, 1);
580 mSearchList = QStringList() << newStr;
581 } else {
582 const QStringList searchListTmp = mSearchString.split(QLatin1Char(' '), Qt::SkipEmptyParts);
583 mSearchList.clear();
584 newStr.clear();
585 for (const QString &text : searchListTmp) {
586 if (text.size() >= 3) {
587 mSearchList << text;
588 if (!newStr.isEmpty()) {
589 newStr += QLatin1Char(' ');
590 }
591 newStr += text;
592 }
593 }
594 needToSplitString = true;
595 }
596 if (!newStr.trimmed().isEmpty()) {
597 Akonadi::Search::PIM::EmailQuery query;
598 if (options & SearchMessageByButtons::SearchEveryWhere) {
599 query.matches(newStr);
600 query.setSplitSearchMatchString(needToSplitString);
601 } else if (options & SearchMessageByButtons::SearchAgainstSubject) {
602 query.subjectMatches(newStr);
603 } else if (options & SearchMessageByButtons::SearchAgainstBody) {
604 query.bodyMatches(newStr);
605 } else if (options & SearchMessageByButtons::SearchAgainstFrom) {
606 query.setFrom(newStr);
607 } else if (options & SearchMessageByButtons::SearchAgainstBcc) {
608 query.setBcc(QStringList() << newStr);
609 } else if (options & SearchMessageByButtons::SearchAgainstCc) {
610 query.setCc(QStringList() << newStr);
611 } else if (options & SearchMessageByButtons::SearchAgainstTo) {
612 query.setTo(QStringList() << newStr);
613 }
614
615 // If the collection is virtual we're probably trying to filter the search collection, so we just search globally
616 if (mCurrentFolder.isValid() && !mCurrentFolder.isVirtual()) {
617 query.addCollection(mCurrentFolder.id());
618 }
619
620 Akonadi::Search::PIM::ResultIterator it = query.exec();
621 while (it.next()) {
622 mMatchingItemIds << it.id();
623 }
624 }
625 Q_EMIT finished();
626#endif
627}
628
629const QStringList &Filter::tagId() const
630{
631 return mTagIds;
632}
633
634void Filter::setTagId(const QStringList &tagId)
635{
636 mTagIds = tagId;
637}
638
639void Filter::addTagId(const QString &tagId)
640{
641 mTagIds.append(tagId);
642}
643
644void Filter::generateRandomIdentifier()
645{
646 mIdentifier = KRandom::randomString(16);
647}
648
649QString Filter::identifier() const
650{
651 return mIdentifier;
652}
653
654QDebug operator<<(QDebug d, const MessageList::Core::Filter &t)
655{
656 d << "filtername " << t.filterName();
657 d << "identifier " << t.identifier();
658 d << "search string " << t.searchString();
659 d << "search option " << t.currentOptions();
660 d << "status " << t.status();
661 return d;
662}
663
664#include "moc_filter.cpp"
KConfigGroup::readEntry
QString readEntry(const char *key, const char *aDefault=nullptr) const
MessageList::Core::Filter
This class is responsible of matching messages that should be displayed in the View.
Definition filter.h:34
MessageList::Core::Filter::isEmpty
bool isEmpty() const
Returns true if this filter is empty (0 status mask, empty search string and empty tag) and it's usel...
Definition filter.cpp:126
MessageList::Core::Filter::status
QList< Akonadi::MessageStatus > status() const
Returns the currently set status mask.
Definition filter.cpp:116
MessageList::Core::Filter::clear
void clear()
Clears this filter (sets status to 0, search string and tag id to empty strings)
Definition filter.cpp:143
MessageList::Core::Filter::searchString
const QString & searchString() const
Returns the currently set search string.
Definition filter.cpp:302
MessageList::Core::Filter::setTagId
void setTagId(const QStringList &tagId)
Sets the id of a MessageItem::Tag that the matching messages must contain.
Definition filter.cpp:634
MessageList::Core::Filter::match
bool match(const MessageItem *item) const
Returns true if the specified parameters match this filter and false otherwise.
Definition filter.cpp:74
MessageList::Core::Filter::setStatus
void setStatus(const QList< Akonadi::MessageStatus > &lstStatus)
Sets the status mask for this filter.
Definition filter.cpp:121
MessageList::Core::Filter::setCurrentFolder
void setCurrentFolder(const Akonadi::Collection &collection)
Sets the current folder of this filter.
Definition filter.cpp:152
MessageList::Core::Filter::setSearchString
void setSearchString(const QString &search, SearchMessageByButtons::SearchOptions options)
Sets the search string for this filter.
Definition filter.cpp:561
MessageList::Core::Filter::tagId
const QStringList & tagId() const
Returns the currently set MessageItem::Tag id.
Definition filter.cpp:629
MessageList::Core::Item::receiver
const QString & receiver() const
Returns the receiver associated to this item.
Definition item.cpp:504
MessageList::Core::Item::status
const Akonadi::MessageStatus & status() const
Returns the status associated to this Item.
Definition item.cpp:449
MessageList::Core::Item::sender
const QString & sender() const
Returns the sender associated to this item.
Definition item.cpp:489
MessageList::Core::Item::subject
const QString & subject() const
Returns the subject associated to this Item.
Definition item.cpp:534
MessageList::Core::MessageItem
The MessageItem class.
Definition messageitem.h:36
MessageList::Core::MessageItem::findTag
const Tag * findTag(const QString &szTagId) const
Returns Tag associated to this message that has the specified id or 0 if no such tag exists.
Definition messageitem.cpp:250
status
Q_SCRIPTABLE CaptureState status()
KApplicationTrader::query
KSERVICE_EXPORT KService::List query(FilterFunc filterFunc)
KRandom::randomString
KCOREADDONS_EXPORT QString randomString(int length)
MessageList::Core
The implementation independent part of the MessageList library.
Definition aggregation.h:22
QList::append
void append(QList< T > &&value)
QList::clear
void clear()
QList::count
qsizetype count() const const
QList::reserve
void reserve(qsizetype size)
QObject::Q_EMIT
Q_EMITQ_EMIT
QString::clear
void clear()
QString::isEmpty
bool isEmpty() const const
QString::length
qsizetype length() const const
QString::remove
QString & remove(QChar ch, Qt::CaseSensitivity cs)
QString::toInt
int toInt(bool *ok, int base) const const
QString::trimmed
QString trimmed() const const
Qt::CaseInsensitive
CaseInsensitive
Qt::SkipEmptyParts
SkipEmptyParts
QtConcurrent::filter
QFuture< void > filter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Apr 25 2025 11:46:36 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.