• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdepim API Reference
  • KDE Home
  • Contact Us
 

messagelist

  • sources
  • kde-4.12
  • kdepim
  • messagelist
  • core
sortorder.cpp
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Copyright 2009 Thomas McGuire <mcguire@kde.org>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  *******************************************************************************/
20 #include "core/sortorder.h"
21 
22 #include "messagelistutil.h"
23 
24 #include <KLocale>
25 
26 #include <QMetaEnum>
27 
28 using namespace MessageList::Core;
29 
30 SortOrder::SortOrder()
31  : mMessageSorting( SortMessagesByDateTime ),
32  mMessageSortDirection( Descending ),
33  mGroupSorting( NoGroupSorting ),
34  mGroupSortDirection( Ascending )
35 {
36 }
37 
38 QList< QPair< QString, int > > SortOrder::enumerateMessageSortingOptions( Aggregation::Threading t )
39 {
40  QList< QPair< QString, int > > ret;
41  ret.append( QPair< QString, int >( i18n( "None (Storage Order)" ), SortOrder::NoMessageSorting ) );
42  ret.append( QPair< QString, int >( i18n( "By Date/Time" ), SortOrder::SortMessagesByDateTime ) );
43  if ( t != Aggregation::NoThreading )
44  ret.append( QPair< QString, int >( i18n( "By Date/Time of Most Recent in Subtree" ), SortOrder::SortMessagesByDateTimeOfMostRecent ) );
45  ret.append( QPair< QString, int >( i18n( "By Sender" ), SortOrder::SortMessagesBySender ) );
46  ret.append( QPair< QString, int >( i18n( "By Receiver" ), SortOrder::SortMessagesByReceiver ) );
47  ret.append( QPair< QString, int >( i18n( "By Smart Sender/Receiver" ), SortOrder::SortMessagesBySenderOrReceiver ) );
48  ret.append( QPair< QString, int >( i18n( "By Subject" ), SortOrder::SortMessagesBySubject ) );
49  ret.append( QPair< QString, int >( i18n( "By Size" ), SortOrder::SortMessagesBySize ) );
50  ret.append( QPair< QString, int >( i18n( "By Action Item Status" ), SortOrder::SortMessagesByActionItemStatus ) );
51  ret.append( QPair< QString, int >( i18n( "By Unread Status" ), SortOrder::SortMessagesByUnreadStatus ) );
52  ret.append( QPair< QString, int >( i18n( "By Important Status" ), SortOrder::SortMessagesByImportantStatus ) );
53  return ret;
54 }
55 
56 QList< QPair< QString, int > > SortOrder::enumerateMessageSortDirectionOptions( MessageSorting ms )
57 {
58  QList< QPair< QString, int > > ret;
59  if ( ms == SortOrder::NoMessageSorting )
60  return ret;
61 
62  if (
63  ( ms == SortOrder::SortMessagesByDateTime ) ||
64  ( ms == SortOrder::SortMessagesByDateTimeOfMostRecent )
65  )
66  {
67  ret.append( QPair< QString, int >( i18n( "Least Recent on Top" ), SortOrder::Ascending ) );
68  ret.append( QPair< QString, int >( i18n( "Most Recent on Top" ), SortOrder::Descending ) );
69  return ret;
70  }
71 
72  ret.append( QPair< QString, int >( i18nc( "Sort order for messages", "Ascending" ), SortOrder::Ascending ) );
73  ret.append( QPair< QString, int >( i18nc( "Sort order for messages", "Descending" ), SortOrder::Descending ) );
74  return ret;
75 }
76 
77 
78 QList< QPair< QString, int > > SortOrder::enumerateGroupSortingOptions( Aggregation::Grouping g )
79 {
80  QList< QPair< QString, int > > ret;
81  if ( g == Aggregation::NoGrouping )
82  return ret;
83  if ( ( g == Aggregation::GroupByDate ) || ( g == Aggregation::GroupByDateRange ) )
84  ret.append( QPair< QString, int >( i18n( "by Date/Time" ), SortOrder::SortGroupsByDateTime ) );
85  else {
86  ret.append( QPair< QString, int >( i18n( "None (Storage Order)" ), SortOrder::NoGroupSorting ) );
87  ret.append( QPair< QString, int >( i18n( "by Date/Time of Most Recent Message in Group" ), SortOrder::SortGroupsByDateTimeOfMostRecent ) );
88  }
89 
90  if ( g == Aggregation::GroupBySenderOrReceiver )
91  ret.append( QPair< QString, int >( i18n( "by Sender/Receiver" ), SortOrder::SortGroupsBySenderOrReceiver ) );
92  else if ( g == Aggregation::GroupBySender )
93  ret.append( QPair< QString, int >( i18n( "by Sender" ), SortOrder::SortGroupsBySender ) );
94  else if ( g == Aggregation::GroupByReceiver )
95  ret.append( QPair< QString, int >( i18n( "by Receiver" ), SortOrder::SortGroupsByReceiver ) );
96 
97  return ret;
98 }
99 
100 QList< QPair< QString, int > > SortOrder::enumerateGroupSortDirectionOptions( Aggregation::Grouping g,
101  GroupSorting gs )
102 {
103  QList< QPair< QString, int > > ret;
104  if ( g == Aggregation::NoGrouping || gs == SortOrder::NoGroupSorting)
105  return ret;
106 
107  if ( gs == SortOrder::SortGroupsByDateTimeOfMostRecent )
108  {
109  ret.append( QPair< QString, int >( i18n( "Least Recent on Top" ), SortOrder::Ascending ) );
110  ret.append( QPair< QString, int >( i18n( "Most Recent on Top" ), SortOrder::Descending ) );
111  return ret;
112  }
113  ret.append( QPair< QString, int >( i18nc( "Sort order for mail groups", "Ascending" ), SortOrder::Ascending ) );
114  ret.append( QPair< QString, int >( i18nc( "Sort order for mail groups", "Descending" ), SortOrder::Descending ) );
115  return ret;
116 }
117 
118 typedef QPair< QString, int > Pair;
119 typedef QList< Pair > OptionList;
120 static bool optionListHasOption( const OptionList &optionList, int optionValue,
121  int defaultOptionValue )
122 {
123  foreach( const Pair &pair, optionList ) {
124  if ( pair.second == optionValue ) {
125  return true;
126  }
127  }
128  if ( optionValue != defaultOptionValue )
129  return false;
130  else return true;
131 }
132 
133 bool SortOrder::validForAggregation( const Aggregation *aggregation ) const
134 {
135  OptionList messageSortings = enumerateMessageSortingOptions( aggregation->threading() );
136  OptionList messageSortDirections = enumerateMessageSortDirectionOptions( mMessageSorting );
137  OptionList groupSortings = enumerateGroupSortingOptions( aggregation->grouping() );
138  OptionList groupSortDirections = enumerateGroupSortDirectionOptions( aggregation->grouping(),
139  mGroupSorting );
140  SortOrder defaultSortOrder = defaultForAggregation( aggregation, SortOrder() );
141  bool messageSortingOk = optionListHasOption( messageSortings,
142  mMessageSorting, defaultSortOrder.messageSorting() );
143  bool messageSortDirectionOk = optionListHasOption( messageSortDirections, mMessageSortDirection,
144  defaultSortOrder.messageSortDirection() );
145 
146  bool groupSortingOk = optionListHasOption( groupSortings, mGroupSorting,
147  defaultSortOrder.groupSorting() );
148  bool groupSortDirectionOk = optionListHasOption( groupSortDirections, mGroupSortDirection,
149  defaultSortOrder.groupSortDirection() );
150  return messageSortingOk && messageSortDirectionOk &&
151  groupSortingOk && groupSortDirectionOk;
152 }
153 
154 SortOrder SortOrder::defaultForAggregation( const Aggregation *aggregation,
155  const SortOrder &oldSortOrder )
156 {
157  SortOrder newSortOrder;
158 
159  //
160  // First check if we can adopt the message sorting and the message sort direction from
161  // the old sort order. This is mostly true, except, for example, when the old message sorting
162  // was "by most recent in subtree", and the aggregation doesn't use threading.
163  //
164  OptionList messageSortings = enumerateMessageSortingOptions( aggregation->threading() );
165  bool messageSortingOk = optionListHasOption( messageSortings,
166  oldSortOrder.messageSorting(),
167  SortOrder().messageSorting() );
168  bool messageSortDirectionOk = false;
169  if ( messageSortingOk ) {
170  OptionList messageSortDirections = enumerateMessageSortDirectionOptions(
171  oldSortOrder.messageSorting() );
172  messageSortDirectionOk = optionListHasOption( messageSortDirections, oldSortOrder.messageSortDirection(),
173  SortOrder().messageSortDirection() );
174  }
175 
176  //
177  // Ok, if we can partly adopt the old sort order, set the values now.
178  //
179  if ( messageSortingOk )
180  newSortOrder.setMessageSorting( oldSortOrder.messageSorting() );
181  else
182  newSortOrder.setMessageSorting( SortMessagesByDateTime );
183  if ( messageSortDirectionOk )
184  newSortOrder.setMessageSortDirection( oldSortOrder.messageSortDirection() );
185  else
186  newSortOrder.setMessageSortDirection( Descending );
187 
188  //
189  // Now set the group sorting and group sort direction, depending on the aggregation.
190  //
191  Aggregation::Grouping grouping = aggregation->grouping();
192  if ( grouping == Aggregation::GroupByDate ||
193  grouping == Aggregation::GroupByDateRange ) {
194  newSortOrder.setGroupSortDirection( Descending );
195  newSortOrder.setGroupSorting( SortGroupsByDateTime );
196 
197  }
198  else if ( grouping == Aggregation::GroupByReceiver || grouping == Aggregation::GroupBySender ||
199  grouping == Aggregation::GroupBySenderOrReceiver ) {
200  newSortOrder.setGroupSortDirection( Descending );
201  switch ( grouping ) {
202  case Aggregation::GroupByReceiver:
203  newSortOrder.setGroupSorting( SortGroupsByReceiver ); break;
204  case Aggregation::GroupBySender:
205  newSortOrder.setGroupSorting( SortGroupsBySender ); break;
206  case Aggregation::GroupBySenderOrReceiver:
207  newSortOrder.setGroupSorting( SortGroupsBySenderOrReceiver ); break;
208  default: break;
209  }
210  }
211 
212  return newSortOrder;
213 }
214 
215 bool SortOrder::readConfigHelper( KConfigGroup &conf, const QString &id )
216 {
217  if ( !conf.hasKey( id + MessageList::Util::messageSortingConfigName() ) )
218  return false;
219  mMessageSorting = messageSortingForName(
220  conf.readEntry( id + MessageList::Util::messageSortingConfigName() ) );
221  mMessageSortDirection = sortDirectionForName(
222  conf.readEntry( id + MessageList::Util::messageSortDirectionConfigName() ) );
223  mGroupSorting = groupSortingForName(
224  conf.readEntry( id + MessageList::Util::groupSortingConfigName() ) );
225  mGroupSortDirection = sortDirectionForName(
226  conf.readEntry( id + MessageList::Util::groupSortDirectionConfigName() ) );
227  return true;
228 }
229 
230 void SortOrder::readConfig( KConfigGroup &conf, const QString &storageId,
231  bool *storageUsesPrivateSortOrder )
232 {
233  SortOrder privateSortOrder, globalSortOrder;
234  globalSortOrder.readConfigHelper( conf, QLatin1String( "GlobalSortOrder" ) );
235  *storageUsesPrivateSortOrder = privateSortOrder.readConfigHelper( conf, storageId );
236  if ( *storageUsesPrivateSortOrder )
237  *this = privateSortOrder;
238  else
239  *this = globalSortOrder;
240 
241 }
242 
243 void SortOrder::writeConfig( KConfigGroup &conf, const QString &storageId,
244  bool storageUsesPrivateSortOrder ) const
245 {
246  QString id = storageId;
247  if ( !storageUsesPrivateSortOrder ) {
248  id = QLatin1String( "GlobalSortOrder" );
249  conf.deleteEntry( storageId + MessageList::Util::messageSortingConfigName() );
250  conf.deleteEntry( storageId + MessageList::Util::messageSortDirectionConfigName() );
251  conf.deleteEntry( storageId + MessageList::Util::groupSortingConfigName() );
252  conf.deleteEntry( storageId + MessageList::Util::groupSortDirectionConfigName() );
253  }
254 
255  conf.writeEntry( id + MessageList::Util::messageSortingConfigName(),
256  nameForMessageSorting( mMessageSorting ) );
257  conf.writeEntry( id + MessageList::Util::messageSortDirectionConfigName(),
258  nameForSortDirection( mMessageSortDirection ) );
259  conf.writeEntry( id + MessageList::Util::groupSortingConfigName(),
260  nameForGroupSorting( mGroupSorting ) );
261  conf.writeEntry( id + MessageList::Util::groupSortDirectionConfigName(),
262  nameForSortDirection( mGroupSortDirection ) );
263 
264 }
265 
266 bool SortOrder::isValidMessageSorting( SortOrder::MessageSorting ms )
267 {
268  switch( ms )
269  {
270  case SortOrder::NoMessageSorting:
271  case SortOrder::SortMessagesByDateTime:
272  case SortOrder::SortMessagesByDateTimeOfMostRecent:
273  case SortOrder::SortMessagesBySenderOrReceiver:
274  case SortOrder::SortMessagesBySender:
275  case SortOrder::SortMessagesByReceiver:
276  case SortOrder::SortMessagesBySubject:
277  case SortOrder::SortMessagesBySize:
278  case SortOrder::SortMessagesByActionItemStatus:
279  case SortOrder::SortMessagesByUnreadStatus:
280  case SortOrder::SortMessagesByImportantStatus:
281  // ok
282  break;
283  default:
284  // b0rken
285  return false;
286  break;
287  }
288 
289  return true;
290 }
291 
292 const QString SortOrder::nameForSortDirection( SortDirection sortDirection )
293 {
294  int index = staticMetaObject.indexOfEnumerator( "SortDirection" );
295  return QLatin1String( staticMetaObject.enumerator( index ).valueToKey( sortDirection ) );
296 }
297 
298 const QString SortOrder::nameForMessageSorting( MessageSorting messageSorting )
299 {
300  int index = staticMetaObject.indexOfEnumerator( "MessageSorting" );
301  return QLatin1String( staticMetaObject.enumerator( index ).valueToKey( messageSorting ) );
302 }
303 
304 const QString SortOrder::nameForGroupSorting( GroupSorting groupSorting )
305 {
306  int index = staticMetaObject.indexOfEnumerator( "GroupSorting" );
307  return QLatin1String( staticMetaObject.enumerator( index ).valueToKey( groupSorting ) );
308 }
309 
310 SortOrder::SortDirection SortOrder::sortDirectionForName( const QString& name )
311 {
312  int index = staticMetaObject.indexOfEnumerator( "SortDirection" );
313  return static_cast<SortDirection>( staticMetaObject.enumerator( index ).keyToValue(
314  name.toLatin1().constData() ) );
315 }
316 
317 SortOrder::MessageSorting SortOrder::messageSortingForName( const QString& name )
318 {
319  int index = staticMetaObject.indexOfEnumerator( "MessageSorting" );
320  return static_cast<MessageSorting>( staticMetaObject.enumerator( index ).keyToValue(
321  name.toLatin1().constData() ) );
322 }
323 
324 SortOrder::GroupSorting SortOrder::groupSortingForName( const QString& name )
325 {
326  int index = staticMetaObject.indexOfEnumerator( "GroupSorting" );
327  return static_cast<GroupSorting>( staticMetaObject.enumerator( index ).keyToValue(
328  name.toLatin1().constData() ) );
329 }
330 
331 #include "sortorder.moc"
MessageList::Core::SortOrder::SortMessagesByDateTimeOfMostRecent
Sort the messages by date and time of the most recent message in subtree.
Definition: sortorder.h:82
MessageList::Core::SortOrder
A class which holds information about sorting, e.g.
Definition: sortorder.h:37
MessageList::Core::SortOrder::SortMessagesBySubject
Sort the messages by subject.
Definition: sortorder.h:86
MessageList::Core::SortOrder::SortOrder
SortOrder()
Definition: sortorder.cpp:30
MessageList::Core::Aggregation
A set of aggregation options that can be applied to the MessageList::Model in a single shot...
Definition: aggregation.h:43
optionListHasOption
static bool optionListHasOption(const OptionList &optionList, int optionValue, int defaultOptionValue)
Definition: sortorder.cpp:120
MessageList::Core::SortOrder::SortGroupsByDateTime
Sort groups by date/time of the group.
Definition: sortorder.h:54
MessageList::Core::SortOrder::isValidMessageSorting
static bool isValidMessageSorting(SortOrder::MessageSorting ms)
Returns true if the ms parameter specifies a valid MessageSorting option.
Definition: sortorder.cpp:266
MessageList::Core::Aggregation::NoThreading
Perform no threading at all.
Definition: aggregation.h:85
MessageList::Core::Aggregation::grouping
Grouping grouping() const
Returns the currently set Grouping option.
Definition: aggregation.h:162
MessageList::Core::Aggregation::Threading
Threading
The available threading methods.
Definition: aggregation.h:83
MessageList::Core::Aggregation::GroupBySender
Group by sender, always.
Definition: aggregation.h:58
MessageList::Core::Aggregation::threading
Threading threading() const
Returns the current threading method.
Definition: aggregation.h:202
MessageList::Core::SortOrder::setGroupSortDirection
void setGroupSortDirection(SortDirection groupSortDirection)
Sets the SortDirection for the groups.
Definition: sortorder.h:120
MessageList::Core::Aggregation::GroupByDate
Group the messages by the date of the thread leader.
Definition: aggregation.h:55
MessageList::Core::SortOrder::SortGroupsByReceiver
Sort groups by receiver (makes sense only with GroupByReceiver)
Definition: sortorder.h:58
MessageList::Util::groupSortingConfigName
MESSAGELIST_EXPORT QString groupSortingConfigName()
Definition: messagelistutil.cpp:43
MessageList::Core::Aggregation::GroupByDateRange
Use smart (thread leader) date ranges ("Today","Yesterday","Last Week"...)
Definition: aggregation.h:56
MessageList::Util::messageSortingConfigName
MESSAGELIST_EXPORT QString messageSortingConfigName()
Definition: messagelistutil.cpp:33
OptionList
QList< Pair > OptionList
Definition: sortorder.cpp:119
MessageList::Core::Aggregation::NoGrouping
Don't group messages at all.
Definition: aggregation.h:54
MessageList::Core::SortOrder::SortDirection
SortDirection
The "generic" sort direction: used for groups and for messages If you add values here please look at ...
Definition: sortorder.h:67
MessageList::Core::SortOrder::SortMessagesByReceiver
Sort the messages by receiver.
Definition: sortorder.h:85
MessageList::Core::SortOrder::writeConfig
void writeConfig(KConfigGroup &conf, const QString &storageId, bool storageUsesPrivateSortOrder) const
Writes the sort order to a config group.
Definition: sortorder.cpp:243
MessageList::Core::SortOrder::NoGroupSorting
Don't sort the groups at all, add them as they come in.
Definition: sortorder.h:53
MessageList::Core::SortOrder::enumerateMessageSortDirectionOptions
static QList< QPair< QString, int > > enumerateMessageSortDirectionOptions(MessageSorting ms)
Enumerates the available message sorting directions for the specified MessageSorting option...
Definition: sortorder.cpp:56
MessageList::Core::SortOrder::messageSorting
MessageSorting messageSorting() const
Returns the current message sorting option.
Definition: sortorder.h:126
MessageList::Core::Aggregation::GroupByReceiver
Group by receiver, always.
Definition: aggregation.h:59
MessageList::Core::SortOrder::messageSortDirection
SortDirection messageSortDirection() const
Returns the current message SortDirection.
Definition: sortorder.h:138
MessageList::Core::SortOrder::MessageSorting
MessageSorting
The available message sorting options.
Definition: sortorder.h:78
Pair
QPair< QString, int > Pair
Definition: sortorder.cpp:118
MessageList::Util::groupSortDirectionConfigName
MESSAGELIST_EXPORT QString groupSortDirectionConfigName()
Definition: messagelistutil.cpp:48
MessageList::Core::SortOrder::enumerateGroupSortDirectionOptions
static QList< QPair< QString, int > > enumerateGroupSortDirectionOptions(Aggregation::Grouping g, GroupSorting groupSorting)
Enumerates the group sort direction options compatible with the specified Grouping and GroupSorting...
Definition: sortorder.cpp:100
MessageList::Core::SortOrder::Descending
Definition: sortorder.h:70
MessageList::Util::messageSortDirectionConfigName
MESSAGELIST_EXPORT QString messageSortDirectionConfigName()
Definition: messagelistutil.cpp:38
MessageList::Core::SortOrder::SortMessagesBySender
Sort the messages by sender.
Definition: sortorder.h:84
MessageList::Core::SortOrder::SortGroupsBySender
Sort groups by sender (makes sense only with GroupBySender)
Definition: sortorder.h:57
MessageList::Core::SortOrder::defaultForAggregation
static SortOrder defaultForAggregation(const Aggregation *aggregation, const SortOrder &oldSortOrder)
Returns the default sort order for the given aggregation.
Definition: sortorder.cpp:154
MessageList::Core::SortOrder::readConfig
void readConfig(KConfigGroup &conf, const QString &storageId, bool *storageUsesPrivateSortOrder)
Reads the sort order from a config group.
Definition: sortorder.cpp:230
MessageList::Core::Aggregation::Grouping
Grouping
Message grouping.
Definition: aggregation.h:52
MessageList::Core::SortOrder::NoMessageSorting
Don't sort the messages at all.
Definition: sortorder.h:80
MessageList::Core::SortOrder::setMessageSortDirection
void setMessageSortDirection(SortDirection messageSortDirection)
Sets the SortDirection for the message.
Definition: sortorder.h:145
sortorder.h
MessageList::Core::SortOrder::GroupSorting
GroupSorting
How to sort the groups If you add values here please look at the implementations of the enumerate* fu...
Definition: sortorder.h:51
MessageList::Core::SortOrder::SortMessagesBySenderOrReceiver
Sort the messages by sender or receiver.
Definition: sortorder.h:83
messagelistutil.h
MessageList::Core::SortOrder::Ascending
Definition: sortorder.h:69
MessageList::Core::SortOrder::SortMessagesByImportantStatus
Sort the messages By "Important" flags of status.
Definition: sortorder.h:90
MessageList::Core::SortOrder::enumerateMessageSortingOptions
static QList< QPair< QString, int > > enumerateMessageSortingOptions(Aggregation::Threading t)
Enumerates the message sorting options compatible with the specified Threading setting.
Definition: sortorder.cpp:38
MessageList::Core::SortOrder::setGroupSorting
void setGroupSorting(GroupSorting gs)
Sets the GroupSorting option.
Definition: sortorder.h:107
MessageList::Core::SortOrder::SortGroupsBySenderOrReceiver
Sort groups by sender or receiver (makes sense only with GroupBySenderOrReceiver) ...
Definition: sortorder.h:56
MessageList::Core::SortOrder::SortMessagesByUnreadStatus
Sort the messages by the "Unread" flags of status.
Definition: sortorder.h:89
MessageList::Core::SortOrder::SortMessagesBySize
Sort the messages by size.
Definition: sortorder.h:87
MessageList::Core::SortOrder::SortMessagesByDateTime
Sort the messages by date and time.
Definition: sortorder.h:81
MessageList::Core::SortOrder::setMessageSorting
void setMessageSorting(MessageSorting ms)
Sets the current message sorting option.
Definition: sortorder.h:132
MessageList::Core::Aggregation::GroupBySenderOrReceiver
Group by sender (incoming) or receiver (outgoing) field.
Definition: aggregation.h:57
MessageList::Core::SortOrder::SortMessagesByActionItemStatus
Sort the messages by the "Action Item" flag of status.
Definition: sortorder.h:88
MessageList::Core::SortOrder::validForAggregation
bool validForAggregation(const Aggregation *aggregation) const
Checks if this sort order can be used in combination with the given aggregation.
Definition: sortorder.cpp:133
MessageList::Core::SortOrder::SortGroupsByDateTimeOfMostRecent
Sort groups by date/time of the most recent message.
Definition: sortorder.h:55
MessageList::Core::SortOrder::enumerateGroupSortingOptions
static QList< QPair< QString, int > > enumerateGroupSortingOptions(Aggregation::Grouping g)
Enumerates the group sorting options compatible with the specified Grouping.
Definition: sortorder.cpp:78
This file is part of the KDE documentation.
Documentation copyright © 1996-2014 The KDE developers.
Generated on Tue Oct 14 2014 22:55:32 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

messagelist

Skip menu "messagelist"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members

kdepim API Reference

Skip menu "kdepim API Reference"
  • akonadi_next
  • akregator
  • blogilo
  • calendarsupport
  • console
  •   kabcclient
  •   konsolekalendar
  • kaddressbook
  • kalarm
  •   lib
  • kdgantt2
  • kjots
  • kleopatra
  • kmail
  • knode
  • knotes
  • kontact
  • korgac
  • korganizer
  • ktimetracker
  • libkdepim
  • libkleo
  • libkpgp
  • mailcommon
  • messagelist
  • messageviewer

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal