Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-12-12 09:01:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
cffd41b568
gecko-dev/lib/libmsg/msgdbvw.cpp

3124 lines
84 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
*/
#include "msg.h"
#include "msgdb.h"
#include "msgdbvw.h"
#include "thrdbvw.h"
#include "dberror.h"
#include "vwerror.h"
#include "newsdb.h"
#include "maildb.h"
#include "thrhead.h"
#include "grpinfo.h"
#include "chngntfy.h"
#include "msgmast.h"
#include "thrnewvw.h"
#include "xpgetstr.h"
#include "addrbook.h"
#include "dirprefs.h"
#include "msglpane.h"
#include "xp_qsort.h"
#include "intl_csi.h"
#include "msgimap.h"
extern "C" {
extern int MK_MSG_FIRST_MSG;
extern int MK_MSG_NEXT_MSG;
extern int MK_MSG_PREV_MSG;
extern int MK_MSG_LAST_MSG;
extern int MK_MSG_FIRST_UNREAD;
extern int MK_MSG_NEXT_UNREAD;
extern int MK_MSG_PREV_UNREAD;
extern int MK_MSG_LAST_UNREAD;
extern int MK_MSG_READ_MORE;
extern int MK_MSG_NEXTUNREAD_THREAD;
extern int MK_MSG_NEXTUNREAD_GROUP;
extern int MK_MSG_FIRST_FLAGGED;
extern int MK_MSG_NEXT_FLAGGED;
extern int MK_MSG_PREV_FLAGGED;
}
#ifdef WINDOWS
#include "windowsx.h"
#else
#define GlobalAllocPtr(a,b) XP_ALLOC(b)
#define GlobalFreePtr(p) XP_FREE(p)
#endif
ViewChangeListener::ViewChangeListener(MessageDBView *view)
{
m_dbView = view;
}
ViewChangeListener::~ViewChangeListener()
{
}
void ViewChangeListener::OnViewChange(MSG_ViewIndex startIndex,
int32 numChanged,
MSG_NOTIFY_CODE changeType, ChangeListener * instigator)
{
// propogate change to views' listeners
// if we're not the instigator, update flags if this key is in our view
if (instigator != &m_dbView->m_changeListener)
{
m_dbView->NotifyViewChangeAll(startIndex, numChanged, changeType,
instigator);
}
}
void ViewChangeListener::OnViewStartChange(MSG_ViewIndex startIndex,
int32 numChanged,
MSG_NOTIFY_CODE changeType, ChangeListener * instigator)
{
// propogate change to views' listeners
// if we're not the instigator, update flags if this key is in our view
if (instigator != &m_dbView->m_changeListener)
{
m_dbView->NotifyViewStartChangeAll(startIndex, numChanged, changeType,
instigator);
}
}
void ViewChangeListener::OnViewEndChange(MSG_ViewIndex startIndex,
int32 numChanged,
MSG_NOTIFY_CODE changeType, ChangeListener * instigator)
{
// propogate change to views' listeners
// if we're not the instigator, update flags if this key is in our view
if (instigator != &m_dbView->m_changeListener)
{
m_dbView->NotifyViewEndChangeAll(startIndex, numChanged, changeType,
instigator);
}
}
void ViewChangeListener::OnKeyChange(MessageKey keyChanged, int32 flags,
ChangeListener *instigator)
{
// if we're not the instigator, update flags if this key is in our view
if (instigator != &m_dbView->m_changeListener)
{
if (flags & kAdded) // message just downloaded
{
m_dbView->OnNewHeader(keyChanged, FALSE);
}
else
{
MSG_ViewIndex index = m_dbView->FindViewIndex(keyChanged);
if (index != kViewIndexNone)
{
char extraFlag;
m_dbView->SetExtraFlagsFromDBFlags(flags, index);
// tell the view the extra flag changed, so it can
// update the previous view, if any.
if (m_dbView->GetExtraFlag(index, &extraFlag) == eSUCCESS)
m_dbView->OnExtraFlagChanged(index, extraFlag);
if (flags & (kExpired|kExpunged))
m_dbView->DeleteMsgByIndex(index, FALSE);
else
m_dbView->NoteChange(index, 1, MSG_NotifyChanged);
}
else
{
MSG_ViewIndex threadIndex = m_dbView->ThreadIndexOfMsg(keyChanged);
// may need to fix thread counts
if (threadIndex != MSG_VIEWINDEXNONE)
m_dbView->NoteChange(threadIndex, 1, MSG_NotifyChanged);
}
}
}
// propogate change to views' listeners, even if we're not instigator
m_dbView->NotifyKeyChangeAll(keyChanged, flags, instigator);
}
void ViewChangeListener::OnAnnouncerGoingAway (ChangeAnnouncer * instigator)
{
m_dbView->NotifyAnnouncerGoingAway(instigator); // shout it to the world!
m_dbView->m_messageDB->RemoveListener(this);
m_dbView->m_messageDB = NULL;
}
/*static*/ uint32 MessageDBView::m_publicEquivOfExtraFlags;
MessageDBView::MessageDBView() : m_changeListener(this)
{
m_messageDB = NULL;
m_refCount = 1;
m_sortValid = TRUE;
m_sortOrder = SortTypeNone;
m_viewFlags = (ViewFlags) 0;
if (m_publicEquivOfExtraFlags == 0)
{
// first, find out what the 32 bit public equivalent of the extra flags is.
CopyExtraFlagsToDBFlags((char) 0xFF, &m_publicEquivOfExtraFlags);
MessageDB::ConvertDBFlagsToPublicFlags(&m_publicEquivOfExtraFlags);
}
}
MessageDBView::~MessageDBView()
{
NotifyAnnouncerGoingAway(this);
CacheRemove ();
XP_ASSERT(m_messageDB == NULL); // should be NULL if no errors closing the DB
}
// static method which given a URL string returns a view on that URL.
// For example, if url = "news:secnews-alt.music.alternative", and viewType = ViewOnlyThreadsWithNew
// We will return a threaded NewsDBView on the newsgroup alt.music.alternative on
// the host secnews with only threads with new.
MsgERR MessageDBView::OpenURL(const char * url, MSG_Master* master,
ViewType viewType, MessageDBView **view, XP_Bool openInForeground)
{
MailDB *mailDB = NULL;
NewsGroupDB *newsDB = NULL;
MessageDBView *retView = NULL;
MsgERR err = eSUCCESS;
*view = NULL;
const char *startFolder;
char *endFolder = NULL;
char *justFolder = NULL;
int urlType = NET_URL_Type(url);
switch (urlType)
{
case NEWS_TYPE_URL:
// news:alt.music.alternative - news group
// news:4agiou%24g7n@news.utdallas.edu - message-id
err = NewsGroupDB::Open(url, master, &newsDB);
if (newsDB != NULL && err == eSUCCESS)
{
if (viewType == ViewAny)
viewType = newsDB->GetViewType(); // use last opened view type.
// allow this view opening to run in the background. We should do this
// for mail and imap too, but that involves reworking msgtpane.cpp
// to deal with eBuildViewInBackground.
int32 numHeadersInDB = newsDB->GetDBFolderInfo()->GetNumMessages();
MSG_FolderInfoNews *newsFolder = newsDB->GetFolderInfoNews();
if (!openInForeground) // if caller doesn't care
openInForeground = (numHeadersInDB < 1000);
// always open category containers in background, so we can check for new categories.
err = OpenViewOnDB(newsDB, viewType, &retView, openInForeground);
newsDB->SetViewType(viewType); // remember this view type.
newsDB->Close(); // always close - above will addref.
*view = retView;
if (newsDB == NULL || retView == NULL)
return err;
}
break;
case IMAP_TYPE_URL:
{
switch (viewType)
{
case ViewWatchedThreadsWithNew:
case ViewOnlyThreadsWithNew:
case ViewAllThreads:
case ViewOnlyNewHeaders:
case ViewAny:
case ViewCacheless:
{
MailDB *mailDB = NULL;
// strip off id info to get just folder path
startFolder = url + strlen("IMAP:");
char *host = NET_ParseURL (url, GET_HOST_PART);
char *owner = NET_ParseURL (url, GET_USERNAME_PART);
char *path = NET_ParseURL (url, GET_PATH_PART);
if (!host || !path || !owner)
return eOUT_OF_MEMORY;
MSG_IMAPFolderInfoMail *folder = master->FindImapMailFolder(host, path + 1, owner, FALSE);
FREEIF(host);
FREEIF(owner);
FREEIF(path);
if (!folder)
return eOUT_OF_MEMORY; // ### dmb - what kind of error is this?
XP_Bool dbWasCreated=FALSE;
err = ImapMailDB::Open(folder->GetPathname(), TRUE , &mailDB, master,
&dbWasCreated);
if (mailDB != NULL && err == eSUCCESS)
{
if (viewType == ViewAny)
viewType = mailDB->GetViewType(); // use last opened view type.
err = OpenViewOnDB(mailDB, viewType, &retView, TRUE);
mailDB->SetViewType(viewType); // remember this view type.
mailDB->Close(); // always close - above will addref.
if (err != eSUCCESS)
return err;
*view = retView;
if (mailDB == NULL || retView == NULL)
return err;
}
if (justFolder)
XP_FREE (justFolder);
}
break;
case ViewCustom:
{
*view = new ThreadDBView(viewType);
if (!*view)
err = eOUT_OF_MEMORY;
else
err = eSUCCESS;
}
break;
}
}
break;
case MAILBOX_TYPE_URL:
// strip off id info to get just folder path
startFolder = url + strlen("mailbox:");
justFolder = XP_STRDUP (startFolder);
if (!justFolder)
return eOUT_OF_MEMORY;
endFolder = XP_STRSTR (justFolder, "?id=");
if (endFolder)
endFolder[0] = '\0';
err = MailDB::Open(justFolder, FALSE /* create? */, &mailDB);
if (mailDB != NULL && err == eSUCCESS)
{
retView = CacheLookup (mailDB, viewType);
if (retView)
{
retView->AddReference ();
mailDB->Close(); // adjust ref count down.
}
else
{
if (viewType == ViewAny)
viewType = mailDB->GetViewType(); // use last opened view type.
int32 numHeadersInDB = mailDB->GetDBFolderInfo()->GetNumMessages();
if (!openInForeground) // if caller doesn't care
openInForeground = (numHeadersInDB < 1000);
// try opening large mail dbs in background
err = OpenViewOnDB(mailDB, viewType, &retView, openInForeground);
mailDB->SetViewType(viewType); // remember this view type.
mailDB->Close(); // always close - above will addref.
if (retView == NULL)
{
mailDB->Close();
err = eOUT_OF_MEMORY;
}
}
*view = retView;
if (mailDB == NULL || retView == NULL)
return err;
}
if (justFolder)
XP_FREE (justFolder);
break;
default:
return eBAD_URL;
}
return err;
}
// static method which creates and opens a view of the passed type on the already open db
MsgERR MessageDBView::OpenViewOnDB(MessageDB *msgDB, ViewType viewType, MessageDBView ** pRetView, XP_Bool runInForeground /* = TRUE */)
{
MsgERR err = eSUCCESS;
*pRetView = CacheLookup (msgDB, viewType);
if (*pRetView)
(*pRetView)->AddReference ();
else
{
switch (viewType)
{
case ViewWatchedThreadsWithNew:
// this can just filter out non-watched threads...
case ViewOnlyThreadsWithNew:
*pRetView = new ThreadsWithNewView(viewType);
break;
case ViewOnlyNewHeaders:
case ViewAny:
case ViewAllThreads:
*pRetView = new ThreadDBView(viewType);
break;
case ViewCustom:
*pRetView = new ThreadDBView(viewType);
break;
case ViewCacheless:
*pRetView = new CachelessView(viewType);
default:
err = eInvalidViewType;
break;
}
if (*pRetView != NULL)
{
err = (*pRetView)->Open(msgDB, viewType, NULL, runInForeground);
msgDB->AddUseCount(); // add view as user of db.
}
}
return err;
}
MsgERR MessageDBView::Open(MessageDB *messageDB, ViewType viewType,
uint32* /*pCount*/, XP_Bool /* runInForeground = TRUE */)
{
m_messageDB = messageDB;
m_messageDB->AddListener(&m_changeListener);
if (viewType == ViewAny)
viewType = ViewAllThreads;
m_viewType = viewType;
if (messageDB && messageDB->GetDBFolderInfo()->GetFlags() & MSG_FOLDER_PREF_SHOWIGNORED)
m_viewFlags = (ViewFlags) ((int32) kShowIgnored | (int32) m_viewFlags);
if (messageDB && messageDB->GetDBFolderInfo()
&& (viewType == ViewOnlyNewHeaders))
m_viewFlags = (ViewFlags) ((int32) kUnreadOnly | (int32) m_viewFlags);
CacheAdd ();
return eSUCCESS;
}
MsgERR MessageDBView::Close()
{
//if it's zero or negative, we should already have been deleted
XP_ASSERT(m_refCount > 0);
MsgERR err = eSUCCESS;
// opening a view, even from cache, always adds a ref count to db,
// so we should always close it.
if (!--m_refCount)
{
if (m_messageDB != NULL)
{
m_messageDB->RemoveListener(&m_changeListener);
err = m_messageDB->Close();
m_messageDB = NULL;
}
delete this;
}
else if (m_messageDB != NULL)
{
err = m_messageDB->Close();
}
return err;
}
MsgERR MessageDBView::Init(uint32 * /*pCount*/, XP_Bool /*runInForeground = TRUE*/)
{
// MessageDBView is pure virtual in spirit. Subclasses need to override this.
XP_ASSERT(FALSE);
return eSUCCESS;
}
MsgERR MessageDBView::InitSort(SortType /*sortType*/, SortOrder /*sortOrder*/)
{
return eSUCCESS;
}
int32 MessageDBView::AddKeys(MessageKey * /*pOutput*/, int32 * /*pFlags*/, char * /*pLevels*/, SortType /*sortType*/, int /*numListed*/)
{
XP_ASSERT(FALSE);
return 0;
}
XP_Bool MessageDBView::GetShowingIgnored()
{
return m_viewFlags & kShowIgnored;
}
void MessageDBView::SetShowingIgnored(XP_Bool bShowIgnored)
{
if (bShowIgnored)
m_viewFlags |= kShowIgnored;
else
m_viewFlags &= ~kShowIgnored;
}
MsgERR MessageDBView::AddHdr(DBMessageHdr *msgHdr)
{
char flags = 0;
#ifdef DEBUG_bienvenu
XP_ASSERT((int) m_idArray.GetSize() == m_flags.GetSize() && (int) m_idArray.GetSize() == m_levels.GetSize());
#endif
if (msgHdr->GetFlags() & kIgnored && !GetShowingIgnored())
return eSUCCESS;
CopyDBFlagsToExtraFlags(msgHdr->GetFlags(), &flags);
if (msgHdr->GetArticleNum() == msgHdr->GetThreadId())
flags |= kIsThread;
MSG_ViewIndex insertIndex = GetInsertIndex(msgHdr);
if (insertIndex == MSG_VIEWINDEXNONE)
{
// if unreadonly, level is 0 because we must be the only msg in the thread.
char levelToAdd = (m_viewFlags & kUnreadOnly) ? 0 : msgHdr->GetLevel();
if (m_sortOrder == SortTypeAscending)
{
m_idArray.Add(msgHdr->GetMessageKey());
m_flags.Add(flags);
m_levels.Add(levelToAdd);
NoteChange(m_idArray.GetSize() - 1, 1, MSG_NotifyInsertOrDelete);
}
else
{
m_idArray.InsertAt(0, msgHdr->GetMessageKey());
m_flags.InsertAt(0, flags);
m_levels.InsertAt(0, levelToAdd);
NoteChange(0, 1, MSG_NotifyInsertOrDelete);
}
m_sortValid = FALSE;
}
else
{
m_idArray.InsertAt(insertIndex, msgHdr->GetMessageKey());
m_flags.InsertAt(insertIndex, flags);
m_levels.InsertAt(insertIndex, (m_sortType == SortByThread) ? 0 : msgHdr->GetLevel());
NoteChange(insertIndex, 1, MSG_NotifyInsertOrDelete);
}
OnHeaderAddedOrDeleted();
return eSUCCESS;
}
MsgERR MessageDBView::InsertHdrAt(DBMessageHdr *msgHdr, MSG_ViewIndex insertIndex)
{
char flags = 0;
CopyDBFlagsToExtraFlags(msgHdr->GetFlags(), &flags);
NoteStartChange(insertIndex, 1, MSG_NotifyChanged);
m_idArray.SetAt(insertIndex, msgHdr->GetMessageKey());
m_flags.SetAt(insertIndex, flags);
m_levels.SetAt(insertIndex, (m_sortType == SortByThread) ? 0 : msgHdr->GetLevel());
NoteEndChange(insertIndex, 1, MSG_NotifyChanged);
OnHeaderAddedOrDeleted();
return eSUCCESS;
}
MsgERR MessageDBView::OnNewHeader(MessageKey newKey, XP_Bool /*ensureListed*/)
{
MsgERR err = eID_NOT_FOUND;;
// views can override this behaviour, which is to append to view.
// This is the mail behaviour, but threaded views might want
// to insert in order...
DBMessageHdr *msgHdr = m_messageDB->GetDBHdrForKey(newKey);
if (msgHdr != NULL)
{
err = AddHdr(msgHdr);
delete msgHdr;
}
return err;
}
XP_Bool MessageDBView::WantsThisThread(DBThreadMessageHdr * /*threadHdr*/)
{
return TRUE;
}
MsgERR MessageDBView::FinishedAddingHeaders()
{
return eSUCCESS;
}
// make sure the passed key is "in" the view (e.g., for a threaded sort, this
// may just mean the parent thread is in the view).
void MessageDBView::EnsureListed(MessageKey key)
{
if (key != MSG_MESSAGEKEYNONE)
{
// find the key, expanding if neccessary.
MSG_ViewIndex index = FindKey(key, TRUE);
if (index == MSG_VIEWINDEXNONE) // tell the view about it.
OnNewHeader(key, TRUE);
}
}
MessageKey MessageDBView::GetAt(MSG_ViewIndex index)
{
if (index >= m_idArray.GetSize() || index == MSG_VIEWINDEXNONE)
return kIdNone;
else
return(m_idArray.GetAt(index));
}
MSG_ViewIndex MessageDBView::FindKey(MessageKey key, XP_Bool expand)
{
MSG_ViewIndex retIndex = MSG_VIEWINDEXNONE;
retIndex = (MSG_ViewIndex) (m_idArray.FindIndex(key));
if (key != MSG_MESSAGEKEYNONE && retIndex == MSG_VIEWINDEXNONE && expand && m_messageDB)
{
MessageKey threadKey = m_messageDB->GetKeyOfFirstMsgInThread(key);
if (threadKey != kIdNone)
{
MSG_ViewIndex threadIndex = FindKey(threadKey, FALSE);
if (threadIndex != MSG_VIEWINDEXNONE)
{
char flags = m_flags[threadIndex];
if ((flags & kElided) && ExpandByIndex(threadIndex, NULL) == eSUCCESS)
retIndex = FindKey(key, FALSE);
}
}
}
return retIndex;
}
typedef struct entryInfo
{
MessageKey id;
char bits;
} EntryInfo;
typedef struct tagIdStr{
EntryInfo info;
char str[1];
} IdStr;
typedef struct tagIdStrPtr{
EntryInfo info;
const char *strPtr;
} IdStrPtr;
static int /* __cdecl */ FnSortIdStr(const void* pItem1, const void* pItem2)
{
IdStr** p1 = (IdStr**)pItem1;
IdStr** p2 = (IdStr**)pItem2;
int retVal = XP_STRCMP((*p1)->str, (*p2)->str); // used to be strcasecmp, but INTL sorting routine lower cases it.
if (retVal != 0)
return(retVal);
if ((*p1)->info.id >= (*p2)->info.id)
return(1);
else
return(-1);
}
static int /* __cdecl */ FnSortIdStrPtr(const void* pItem1, const void* pItem2)
{
IdStrPtr** p1 = (IdStrPtr**)pItem1;
IdStrPtr** p2 = (IdStrPtr**)pItem2;
int retVal = XP_STRCMP((*p1)->strPtr, (*p2)->strPtr); // used to be strcasecmp, but INTL sorting routine lower cases it.
if (retVal != 0)
return(retVal);
if ((*p1)->info.id >= (*p2)->info.id)
return(1);
else
return(-1);
}
typedef struct tagIdWord{
EntryInfo info;
uint16 word;
} IdWord;
static int /* __cdecl */ FnSortIdWord(const void* pItem1, const void* pItem2)
{
IdWord** p1 = (IdWord**)pItem1;
IdWord** p2 = (IdWord**)pItem2;
long retVal = (*p1)->word - (*p2)->word;
if (retVal > 0)
return(1);
else if (retVal < 0)
return(-1);
else if ((*p1)->info.id >= (*p2)->info.id)
return(1);
else
return(-1);
}
typedef struct tagIdDWord{
EntryInfo info;
uint32 dword;
} IdDWord;
static int /* __cdecl */ FnSortIdDWord(const void* pItem1, const void* pItem2)
{
IdDWord** p1 = (IdDWord**)pItem1;
IdDWord** p2 = (IdDWord**)pItem2;
if ((*p1)->dword > (*p2)->dword)
return(1);
else if ((*p1)->dword < (*p2)->dword)
return(-1);
else if ((*p1)->info.id >= (*p2)->info.id)
return(1);
else
return(-1);
}
MSG_ViewIndex MessageDBView::GetInsertIndex(DBMessageHdr *msgHdr)
{
XP_Bool done = FALSE;
XP_Bool withinOne = FALSE;
MSG_ViewIndex retIndex = MSG_VIEWINDEXNONE;
MSG_ViewIndex tryIndex = GetSize() / 2;
MSG_ViewIndex newTryIndex;
MSG_ViewIndex lowIndex = 0;
MSG_ViewIndex highIndex = GetSize() - 1;
IdDWord dWordEntryInfo1, dWordEntryInfo2;
IdStrPtr strPtrInfo1, strPtrInfo2;
if (GetSize() == 0)
return 0;
uint16 maxLen;
int16 csid = (GetDB()->GetDBFolderInfo()->GetCSID() & ~CS_AUTO);
XPStringObj field1Str;
XPStringObj field2Str;
eFieldType fieldType = GetFieldTypeAndLenForSort(m_sortType, &maxLen);
const void *pValue1, *pValue2;
char *intlString1 = NULL;
if (m_sortType == SortByThread) // punt on threaded view for now.
return retIndex;
int (*comparisonFun) (const void *pItem1, const void *pItem2)=NULL;
int retStatus = 0;
switch (fieldType)
{
case kString:
comparisonFun = FnSortIdStrPtr;
strPtrInfo1.strPtr = intlString1 = GetStringField(msgHdr, m_sortType, csid, field1Str);
strPtrInfo1.info.id = msgHdr->GetMessageKey();
pValue1 = &strPtrInfo1;
break;
case kU16:
case kU32:
pValue1 = &dWordEntryInfo1;
dWordEntryInfo1.dword = GetLongField(msgHdr, m_sortType);
dWordEntryInfo1.info.id = msgHdr->GetMessageKey();
comparisonFun = FnSortIdDWord;
break;
default:
done = TRUE;
}
while (!done)
{
if (highIndex == lowIndex)
break;
MessageKey messageKey = GetAt(tryIndex);
DBMessageHdr *tryHdr = m_messageDB->GetDBHdrForKey(messageKey);
char *intlString2 = NULL;
if (!tryHdr)
break;
if (fieldType == kString)
{
strPtrInfo2.strPtr = intlString2 = GetStringField(tryHdr, m_sortType, csid, field2Str);
strPtrInfo2.info.id = messageKey;
pValue2 = &strPtrInfo2;
}
else
{
dWordEntryInfo2.dword = GetLongField(tryHdr, m_sortType);
dWordEntryInfo2.info.id = messageKey;
pValue2 = &dWordEntryInfo2;
}
delete tryHdr;
retStatus = (*comparisonFun)(&pValue1, &pValue2);
FREEIF(intlString2);
if (retStatus == 0)
break;
if (m_sortOrder == SortTypeDescending) //switch retStatus based on sort order
retStatus = (retStatus > 0) ? -1 : 1;
if (retStatus < 0)
{
newTryIndex = tryIndex - (tryIndex - lowIndex) / 2;
if (newTryIndex == tryIndex)
{
if (!withinOne && newTryIndex > lowIndex)
{
newTryIndex--;
withinOne = TRUE;
}
}
highIndex = tryIndex;
}
else
{
newTryIndex = tryIndex + (highIndex - tryIndex) / 2;
if (newTryIndex == tryIndex)
{
if (!withinOne && newTryIndex < highIndex)
{
withinOne = TRUE;
newTryIndex++;
}
lowIndex = tryIndex;
}
}
if (tryIndex == newTryIndex)
break;
else
tryIndex = newTryIndex;
}
if (retStatus >= 0)
retIndex = tryIndex + 1;
else if (retStatus < 0)
retIndex = tryIndex;
FREEIF(intlString1);
return retIndex;
}
MsgERR MessageDBView::ExternalSort(SortType sortType,
XP_Bool sort_forward_p)
{
SortOrder sortOrder = (sort_forward_p)
? SortTypeAscending : SortTypeDescending;
return Sort(sortType, sortOrder);
}
MsgERR MessageDBView::Sort(SortType sortType, SortOrder sortOrder)
{
return SortInternal(sortType, sortOrder);
}
MsgERR MessageDBView::SortInternal(SortType sortType, SortOrder sortOrder)
{
int arraySize;
MsgERR err = eSUCCESS;
XPByteArray *pBits = GetFlagsArray();
XPPtrArray ptrs;
XPStringObj fieldStr;
int16 csid = (GetDB()->GetDBFolderInfo()->GetCSID() & ~CS_AUTO);
arraySize = GetSize();
if (sortType == m_sortType && m_sortValid)
{
if (sortOrder == m_sortOrder)
{
return eSUCCESS;
}
else
{
if (sortType != SortByThread)
{
// reverse the order
ReverseSort();
err = eSUCCESS;
}
else
{
err = ReverseThreads();
}
m_sortOrder = sortOrder;
m_messageDB->SetSortInfo(sortType, sortOrder);
return err;
}
}
if (sortType == SortByThread)
return eSUCCESS;
uint16 maxLen;
eFieldType fieldType = GetFieldTypeAndLenForSort(sortType, &maxLen);
int i;
// This function uses GlobalAlloc because I don't want to fragment up out heap with these potentially large memory blocks
// Also, freeing a heap block does not return the block to the system, but freeing a globalAlloc block does.
IdStr** pPtrBase = (IdStr**)GlobalAllocPtr(GMEM_MOVEABLE, arraySize * sizeof(IdStr*));
if (pPtrBase)
{
int numSoFar = 0;
// calc max possible size needed for all the rest
uint32 maxSize = (uint32)(maxLen + sizeof(EntryInfo) + 1) * (uint32)(arraySize - numSoFar);
uint32 maxBlockSize = (uint32) 0xf000L;
uint32 allocSize = MIN(maxBlockSize, maxSize);
char * pTemp = (char *)GlobalAllocPtr(GMEM_MOVEABLE, allocSize);
char * pBase = pTemp;
if (pTemp)
{
ptrs.Add(pTemp); // keep track of this so we can free them all
XP_Bool more = TRUE;
DBMessageHdr *msgHdr = NULL;
uint32 longValue;
while (more && numSoFar < arraySize)
{
MessageKey thisKey = m_idArray.GetAt(numSoFar);
if (sortType != SortById)
{
msgHdr = m_messageDB->GetDBHdrForKey(thisKey);
if (msgHdr == NULL)
{
err = eID_NOT_FOUND;
break;
}
}
else
msgHdr = NULL;
// could be a problem here if the ones that appear here are different than the ones already in the array
const char* pField;
char *intlString = NULL;
int paddedFieldLen;
int actualFieldLen;
if (fieldType == kString)
{
pField = intlString = GetStringField(msgHdr, sortType, csid, fieldStr);
actualFieldLen = (pField) ? strlen(pField) + 1 : 1;
paddedFieldLen = actualFieldLen;
int mod4 = actualFieldLen % 4;
if (mod4 > 0)
paddedFieldLen += 4 - mod4;
}
else
{
longValue = (sortType == SortById) ? thisKey : GetLongField(msgHdr, sortType);
pField = (const char *) &longValue;
actualFieldLen = paddedFieldLen = maxLen;
}
// check to see if this entry fits into the block we have allocated so far
// pTemp - pBase = the space we have used so far
// sizeof(EntryInfo) + fieldLen = space we need for this entry
// allocSize = size of the current block
if ((uint32)(pTemp - pBase) + (uint32)sizeof(EntryInfo) + (uint32)paddedFieldLen >= allocSize)
{
maxSize = (uint32)(maxLen + sizeof(EntryInfo) + 1) * (uint32)(arraySize - numSoFar);
maxBlockSize = (uint32) 0xf000L;
allocSize = MIN(maxBlockSize, maxSize);
pTemp = (char*)GlobalAllocPtr(GMEM_MOVEABLE, allocSize);
if (!pTemp)
{
err = eOUT_OF_MEMORY;
break;
}
pBase = pTemp;
ptrs.Add(pTemp); // remember this pointer so we can free it later
}
// make sure there aren't more IDs than we allocated space for
if (numSoFar >= arraySize)
{
err = eOUT_OF_MEMORY;
break;
}
// now store this entry away in the allocated memory
pPtrBase[numSoFar] = (IdStr*)pTemp;
EntryInfo *info = (EntryInfo *) pTemp;
info->id = thisKey;
char bits = 0;
bits = m_flags[numSoFar];
info->bits = bits;
pTemp += sizeof(EntryInfo);
int32 bytesLeft = allocSize - (int32)(pTemp - pBase);
int32 bytesToCopy = MIN(bytesLeft, actualFieldLen);
if (pField)
{
memcpy((char *)pTemp, pField, bytesToCopy);
if (bytesToCopy < actualFieldLen)
{
#ifdef DEBUG_bienvenu
XP_ASSERT(FALSE); // wow, big block
#endif
*(pTemp + bytesToCopy) = '\0';
}
FREEIF(intlString); // free intl'ized string
}
else
*pTemp = 0;
pTemp += paddedFieldLen;
if (msgHdr)
delete msgHdr;
++numSoFar;
}
if (err == eSUCCESS)
{
// now sort the array based on the appropriate type of comparison
switch(fieldType)
{
case kString:
XP_QSORT(pPtrBase, numSoFar, sizeof(IdStr*), FnSortIdStr);
break;
case kU16:
XP_QSORT(pPtrBase, numSoFar, sizeof(IdWord*), FnSortIdWord);
break;
case kU32:
XP_QSORT(pPtrBase, numSoFar, sizeof(IdDWord*), FnSortIdDWord);
break;
default:
XP_ASSERT(FALSE); // not supposed to get here
break;
}
// now puts the IDs into the array in proper order
for (i = 0; i < numSoFar; i++)
{
m_idArray.SetAt(i, pPtrBase[i]->info.id);
if (pBits != NULL)
pBits->SetAt(i, pPtrBase[i]->info.bits);
}
m_sortType = sortType;
m_sortOrder = sortOrder;
if (sortOrder == SortTypeDescending)
{
ReverseSort();
}
}
}
}
// free all the memory we allocated
for (i = 0; i < ptrs.GetSize(); i++)
{
GlobalFreePtr(ptrs[i]);
}
if (pPtrBase)
GlobalFreePtr(pPtrBase);
if (err == eSUCCESS)
{
m_sortValid = TRUE;
m_messageDB->SetSortInfo(sortType, sortOrder);
}
return err;
}
MessageDBView::eFieldType MessageDBView::GetFieldTypeAndLenForSort(SortType sortType, uint16 *pMaxLen)
{
eFieldType fieldType;
uint16 maxLen;
switch (sortType)
{
case SortBySubject:
fieldType = kString;
maxLen = kMaxSubject;
break;
case SortByRecipient:
fieldType = kString;
maxLen = kMaxRecipient;
break;
case SortByAuthor:
fieldType = kString;
maxLen = kMaxAuthor;
break;
case SortByDate:
fieldType = kU32;
maxLen = sizeof(time_t);
break;
case SortByPriority:
fieldType = kU32;
maxLen = sizeof(uint32);
break;
case SortByThread:
case SortById:
case SortBySize:
case SortByFlagged:
case SortByUnread:
case SortByStatus:
fieldType = kU32;
maxLen = sizeof(uint32);
break;
default:
XP_ASSERT(FALSE);
return kString;
}
*pMaxLen = maxLen;
return fieldType;
}
// helper routines for internal sort. XPStringObj is only currently used by
// recipients but we should change the rest so we aren't returning pointers
// to hash strings. This routine allocates a string, so the caller has to free it.
char *MessageDBView::GetStringField(DBMessageHdr *msgHdr, SortType sortType, int16 csid, XPStringObj &string)
{
const char *pField;
switch (sortType)
{
case SortBySubject:
if (msgHdr->GetSubject(string, FALSE, m_messageDB->GetDB()))
pField = string;
else
pField = "";
break;
case SortByRecipient:
msgHdr->GetNameOfRecipient(string, 0, m_messageDB->GetDB());
pField = string ;
if (!pField)
pField = "";
break;
case SortByAuthor:
msgHdr->GetRFC822Author(string, m_messageDB->GetDB());
pField = string ;
if (!pField)
pField = "";
break;
default:
// XP_ASSERT(FALSE);
return(0);
}
return INTL_DecodeMimePartIIAndCreateCollationKey(pField, csid, 0);
}
uint32 MessageDBView::GetStatusSortValue(DBMessageHdr *msgHdr)
{
uint32 sortValue = 5;
uint32 messageFlags = m_messageDB->GetStatusFlags(msgHdr);
if (messageFlags & MSG_FLAG_NEW) // happily, new by definition stands alone
return 0;
#define MSG_STATUS_MASK (MSG_FLAG_REPLIED | MSG_FLAG_FORWARDED)
switch (messageFlags & MSG_STATUS_MASK)
{
case MSG_FLAG_REPLIED:
sortValue = 2;
break;
case MSG_FLAG_FORWARDED|MSG_FLAG_REPLIED:
sortValue = 1;
break;
case MSG_FLAG_FORWARDED:
sortValue = 3;
break;
}
if (sortValue == 5) // none of the above flags set
{
if (messageFlags & MSG_FLAG_READ) // make read a visible status in winfe.
sortValue = 4;
}
return sortValue;
}
uint32 MessageDBView::GetLongField(DBMessageHdr *msgHdr, SortType sortType)
{
switch (sortType)
{
case SortByDate:
return msgHdr->GetDate();
case SortBySize:
return msgHdr->GetMessageSize();
case SortById:
return msgHdr->GetMessageKey();
case SortByPriority: // want highest priority to have lowest value
// so ascending sort will have highest priority first.
return MSG_HighestPriority - msgHdr->GetPriority();
case SortByStatus:
return GetStatusSortValue(msgHdr);
case SortByFlagged:
return !(msgHdr->GetFlags() & kMsgMarked); //make flagged come out on top.
case SortByUnread:
{
XP_Bool isRead = FALSE;
GetDB()->IsRead(msgHdr->GetMessageKey(), &isRead);
return !isRead; // make unread show up at top
}
default:
XP_ASSERT(FALSE);
return 0;
}
}
void MessageDBView::ReverseSort(void)
{
XPByteArray *pBits = GetFlagsArray();
int num = GetSize();
for (int j = 0; j < (num / 2); j++)
{
// go up half the array swapping values
int end = num - j - 1;
char bits;
if (pBits != NULL)
{
bits = pBits->GetAt(j);
pBits->SetAt(j, pBits->GetAt(end));
pBits->SetAt(end, bits);
}
MessageKey tempID = m_idArray.GetAt(j);
m_idArray.SetAt(j, m_idArray.GetAt(end));
m_idArray.SetAt(end, tempID);
}
}
// reversing threads involves reversing the threads but leaving the
// expanded messages ordered relative to the thread, so we
// make a copy of each array and copy them over.
MsgERR MessageDBView::ReverseThreads()
{
MsgERR err = eSUCCESS;
XPByteArray *newFlagArray = new XPByteArray;
IDArray *newIdArray = new IDArray;
XPByteArray *newLevelArray = new XPByteArray;
int sourceIndex, destIndex;
int viewSize = GetSize();
if (newIdArray == NULL || newFlagArray == NULL)
{
err = eOUT_OF_MEMORY;
goto CLEANUP;
}
newIdArray->SetSize(m_idArray.GetSize());
newFlagArray->SetSize(m_flags.GetSize());
newLevelArray->SetSize(m_levels.GetSize());
for (sourceIndex = 0, destIndex = viewSize - 1; sourceIndex < viewSize;)
{
int endThread; // find end of current thread.
XP_Bool inExpandedThread = FALSE;
for (endThread = sourceIndex; endThread < viewSize; endThread++)
{
char flags = m_flags[endThread];
if (!inExpandedThread && (flags & (kIsThread|kHasChildren)) && !(flags & kElided))
inExpandedThread = TRUE;
else if (flags & kIsThread)
{
if (inExpandedThread)
endThread--;
break;
}
}
if (endThread == viewSize)
endThread--;
int saveEndThread = endThread;
while (endThread >= sourceIndex)
{
newIdArray->SetAt(destIndex, m_idArray.GetAt(endThread));
newFlagArray->SetAt(destIndex, m_flags.GetAt(endThread));
newLevelArray->SetAt(destIndex, m_levels.GetAt(endThread));
endThread--;
destIndex--;
}
sourceIndex = saveEndThread + 1;
}
// this copies the contents of both arrays - it would be cheaper to
// just assign the new data ptrs to the old arrays and "forget" the new
// arrays' data ptrs, so they won't be freed when the arrays are deleted.
m_idArray.RemoveAll();
m_flags.RemoveAll();
m_levels.RemoveAll();
m_idArray.InsertAt(0, newIdArray);
m_flags.InsertAt(0, newFlagArray);
m_levels.InsertAt(0, newLevelArray);
CLEANUP:
// if we swizzle data pointers for these arrays, this won't be right.
if (newFlagArray != NULL)
delete newFlagArray;
if (newIdArray != NULL)
delete newIdArray;
if (newLevelArray != NULL)
delete newLevelArray;
return err;
}
MsgERR MessageDBView::ListThreads(MessageKey * /*pMessageNums*/,
int /*numToList*/,
MessageHdrStruct * /*pOutput*/,
int * /*pNumListed*/)
{
return eNYI;
}
MsgERR MessageDBView::ListThreadsShort(MessageKey * pMessageNums,
int numToList,
MSG_MessageLine * pOutput,
int * pNumListed)
{
MsgERR err = eSUCCESS;
XP_BZERO(pOutput, sizeof(*pOutput) * numToList);
int i;
for (i = 0; i < numToList && err == eSUCCESS; i++)
{
{
err = m_messageDB->GetShortMessageHdr(pMessageNums[i], pOutput + i);
if (err == eSUCCESS)
{
// force non-threaded view to be flat.
if (m_sortType != SortByThread)
{
(pOutput + i)->level = 0;
// (pOutput + i)->flags &= ~(kHasChildren); // Not used by FE.
(pOutput + i)->numChildren = 0;
(pOutput + i)->numNewChildren = 0;
}
}
}
}
if (pNumListed != NULL)
*pNumListed = i;
return err;
}
// list the headers of the top-level thread ids
MsgERR MessageDBView::ListThreadIds(MessageKey * /*startMsg*/,
MessageKey * /*pOutput*/,
int /*numToList*/,
int * /*numListed*/)
{
return eNYI;
}
MsgERR MessageDBView::ListThreadIds(ListContext * /*context*/,
MessageKey * /*pOutput*/,
int /*numToList*/,
int * /*numListed*/)
{
return eNYI;
}
// return the list header information for the documents in a thread.
MsgERR MessageDBView::ListThread(MessageKey /*threadId*/,
MessageKey /*startMsg*/,
int /*numToList*/,
MessageHdrStruct * /*pOutput*/,
int * /*pNumListed*/)
{
return eNYI;
}
MsgERR MessageDBView::ListThreadShort(MessageKey /*threadId*/,
MessageKey /*startMsg*/,
int /*numToList*/,
MSG_MessageLine * /*pOutput*/,
int * /*pNumListed*/)
{
return eNYI;
}
MsgERR MessageDBView::ListShortMsgHdrByIndex(MSG_ViewIndex startIndex, int numToList, MSG_MessageLine *pOutput, int *pNumListed)
{
MsgERR err = eSUCCESS;
XP_BZERO(pOutput, sizeof(*pOutput) * numToList);
int i;
for (i = 0; i < numToList && err == eSUCCESS; i++)
{
if (i + startIndex < m_idArray.GetSize())
{
err = m_messageDB->GetShortMessageHdr(m_idArray[i + startIndex], pOutput + i);
if (err == eSUCCESS)
{
char extraFlag = m_flags[i + startIndex];
CopyExtraFlagsToPublicFlags(extraFlag, &((pOutput + i)->flags));
// force non-threaded view to be flat. Wish FE's would do this
if (m_sortType != SortByThread)
{
(pOutput + i)->level = 0;
}
else
{
(pOutput + i)->level = m_levels[i + startIndex];
}
// m_levels is only valid in the thread sort - otherwise, use kIsThread flag,
// Ideally, we'd always use kIsThread, but this is a safer fix for now.
// It's probably not worth keeping level array valid for sorted views.
if (m_levels[i + startIndex] == 0 && m_sortType == SortByThread || (m_sortType != SortByThread && extraFlag & kIsThread))
{
DBThreadMessageHdr *thread = m_messageDB->GetDBThreadHdrForThreadID((pOutput + i)->threadId);
if (thread != NULL)
{
if (m_sortType == SortByThread) // don't set child counts if not threaded
{
if (m_viewFlags & kUnreadOnly)
{
if (extraFlag & kElided)
{
(pOutput + i)->numChildren = thread->GetNumNewChildren() - 1;
if (extraFlag & kIsRead) // count top message if it's read.
(pOutput + i)->numChildren++;
}
else
(pOutput + i)->numChildren = CountExpandedThread(i + startIndex) -1;
}
else
(pOutput + i)->numChildren = thread->GetNumChildren() - 1;
if ((int16) ((pOutput + i)->numChildren) < 0)
(pOutput + i)->numChildren = 0;
(pOutput + i)->numNewChildren = thread->GetNumNewChildren();
}
if (thread->GetFlags() & kIgnored)
(pOutput + i)->flags |= MSG_FLAG_IGNORED;
else
(pOutput + i)->flags &= ~MSG_FLAG_IGNORED;
if (thread->GetFlags() & kWatched)
(pOutput + i)->flags |= MSG_FLAG_WATCHED;
else
(pOutput + i)->flags &= ~MSG_FLAG_WATCHED;
delete thread;
}
}
}
}
else
{
err = eID_NOT_FOUND;
}
}
if (pNumListed != NULL)
*pNumListed = i;
return err;
}
MsgERR MessageDBView::ListMsgHdrByIndex(MSG_ViewIndex startIndex, int numToList, MessageHdrStruct *pOutput, int *pNumListed)
{
MsgERR err = eSUCCESS;
XP_BZERO(pOutput, sizeof(*pOutput) * numToList);
int i;
for (i = 0; i < numToList && err == eSUCCESS; i++)
{
if (i + startIndex < m_idArray.GetSize())
{
err = m_messageDB->GetMessageHdr(m_idArray[i + startIndex],
pOutput + i);
if (err == eSUCCESS)
{
CopyExtraFlagsToPublicFlags(m_flags[i + startIndex],
&((pOutput + i)->m_flags));
// force non-threaded view to be flat.
if (m_sortType != SortByThread)
{
(pOutput + i)->m_level = 0;
(pOutput + i)->m_flags &= ~(kHasChildren);
}
else
{
(pOutput + i)->m_level = m_levels[i + startIndex];
if ((pOutput + i)->m_level == 0)
{
DBThreadMessageHdr *thread = m_messageDB->GetDBThreadHdrForThreadID((pOutput + i)->m_threadId);
if (thread != NULL)
{
(pOutput + i)->m_numChildren = thread->GetNumChildren() - 1;
(pOutput + i)->m_numNewChildren = thread->GetNumNewChildren();
delete thread;
}
}
}
}
}
else
{
err = eID_NOT_FOUND;
}
}
if (pNumListed != NULL)
*pNumListed = i;
return err;
}
MsgERR MessageDBView::GetMsgLevelByIndex(MSG_ViewIndex index, int &level)
{
MsgERR err = eSUCCESS;
level = 0;
if ((int) index < m_levels.GetSize() ) {
level = m_sortType == SortByThread ? m_levels[ index ] : 0;
} else {
err = eID_NOT_FOUND;
}
return err;
}
// This counts the number of messages in an expanded thread, given the
// index of the first message in the thread.
int32 MessageDBView::CountExpandedThread(MSG_ViewIndex index)
{
int32 numInThread = 0;
MSG_ViewIndex startOfThread = index;
while ((int32) startOfThread >= 0 && m_levels[startOfThread] != 0)
startOfThread--;
MSG_ViewIndex threadIndex = startOfThread;
do
{
threadIndex++;
numInThread++;
}
while ((int32) threadIndex < m_levels.GetSize() && m_levels[threadIndex] != 0);
return numInThread;
}
// returns the number of lines that would be added (> 0) or removed (< 0)
// if we were to try to expand/collapse the passed index.
MsgERR MessageDBView::ExpansionDelta(MSG_ViewIndex index, int32 *expansionDelta)
{
int32 numChildren;
MsgERR err;
*expansionDelta = 0;
if ((int) index > m_idArray.GetSize())
return eID_NOT_FOUND;
char flags = m_flags[index];
if (m_sortType != SortByThread)
return eSUCCESS;
// The client can pass in the key of any message
// in a thread and get the expansion delta for the thread.
if (!(m_viewFlags & kUnreadOnly))
{
err = m_messageDB->GetThreadCount(m_idArray[index], &numChildren);
if (err != eSUCCESS)
return err;
}
else
{
numChildren = CountExpandedThread(index);
}
if (flags & kElided)
*expansionDelta = numChildren - 1;
else
*expansionDelta = - (numChildren - 1);
return eSUCCESS;
}
MsgERR MessageDBView::ToggleExpansion(MSG_ViewIndex index, uint32 *numChanged)
{
MSG_ViewIndex threadIndex = ThreadIndexOfMsg(GetAt(index), index);
if (threadIndex == MSG_VIEWINDEXNONE)
{
XP_ASSERT(FALSE);
return eNotThread;
}
char flags = m_flags[threadIndex];
// if not a thread, or doesn't have children, no expand/collapse
// If we add sub-thread expand collapse, this will need to be relaxed
if (!(flags & kIsThread) || !(flags && kHasChildren))
return eNotThread;
if (flags & kElided)
return ExpandByIndex(threadIndex, numChanged);
else
return CollapseByIndex(threadIndex, numChanged);
}
MsgERR MessageDBView::ExpandAll()
{
for (int i = GetSize() - 1; i >= 0; i--)
{
uint32 numExpanded;
char flags = m_flags[i];
if (flags & kElided)
ExpandByIndex(i, &numExpanded);
}
return eSUCCESS;
}
MsgERR MessageDBView::CollapseAll()
{
for (int i = 0; i < GetSize(); i++)
{
uint32 numCollapsed;
char flags = m_flags[i];
if (!(flags & kElided))
CollapseByIndex(i, &numCollapsed);
}
return eSUCCESS;
}
MsgERR MessageDBView::ExpandByIndex(MSG_ViewIndex index, uint32 *pNumExpanded)
{
int numListed;
char flags = m_flags[index];
MessageKey firstIdInThread, startMsg = kIdNone;
MsgERR err;
MSG_ViewIndex firstInsertIndex = index + 1;
MSG_ViewIndex insertIndex = firstInsertIndex;
uint32 numExpanded = 0;
IDArray tempIDArray;
XPByteArray tempFlagArray;
XPByteArray tempLevelArray;
XPByteArray unreadLevelArray;
XP_ASSERT(flags & kElided);
flags &= ~kElided;
if ((int) index > m_idArray.GetSize())
return eID_NOT_FOUND;
firstIdInThread = m_idArray[index];
DBMessageHdr *msgHdr = m_messageDB->GetDBHdrForKey(firstIdInThread);
if (msgHdr == NULL)
{
XP_ASSERT(FALSE);
return eID_NOT_FOUND;
}
m_flags[index] = flags;
NoteChange(index, 1, MSG_NotifyChanged);
do
{
const int listChunk = 200;
MessageKey listIDs[listChunk];
char listFlags[listChunk];
char listLevels[listChunk];
if (m_viewFlags & kUnreadOnly)
{
if (flags & kIsRead)
unreadLevelArray.Add(0); // keep top level hdr in thread, even though read.
err = m_messageDB->ListUnreadIdsInThread(msgHdr->GetThreadId(), &startMsg, unreadLevelArray,
listChunk, listIDs, listFlags, listLevels, &numListed);
}
else
err = m_messageDB->ListIdsInThread(msgHdr, &startMsg, listChunk,
listIDs, listFlags, listLevels, &numListed);
// Don't add thread to view, it's already in.
for (int i = 0; i < numListed; i++)
{
if (listIDs[i] != firstIdInThread)
{
tempIDArray.Add(listIDs[i]);
tempFlagArray.Add(listFlags[i]);
tempLevelArray.Add(listLevels[i]);
insertIndex++;
}
}
if (numListed < listChunk || startMsg == kIdNone)
break;
}
while (err == eSUCCESS);
numExpanded = (insertIndex - firstInsertIndex);
NoteStartChange(firstInsertIndex, numExpanded, MSG_NotifyInsertOrDelete);
m_idArray.InsertAt(firstInsertIndex, &tempIDArray);
m_flags.InsertAt(firstInsertIndex, &tempFlagArray);
m_levels.InsertAt(firstInsertIndex, &tempLevelArray);
NoteEndChange(firstInsertIndex, numExpanded, MSG_NotifyInsertOrDelete);
delete msgHdr;
if (pNumExpanded != NULL)
*pNumExpanded = numExpanded;
return err;
}
MsgERR MessageDBView::CollapseByIndex(MSG_ViewIndex index, uint32 *pNumCollapsed)
{
MessageKey firstIdInThread;
MsgERR err;
char flags = m_flags[index];
int32 threadCount = 0;
if (flags & kElided || m_sortType != SortByThread)
return eSUCCESS;
flags |= kElided;
if (index > m_idArray.GetSize())
return eID_NOT_FOUND;
firstIdInThread = m_idArray[index];
DBMessageHdr *msgHdr = m_messageDB->GetDBHdrForKey(firstIdInThread);
if (msgHdr == NULL)
{
XP_ASSERT(FALSE);
return eID_NOT_FOUND;
}
m_flags[index] = flags;
NoteChange(index, 1, MSG_NotifyChanged);
err = ExpansionDelta(index, &threadCount);
if (err == eSUCCESS)
{
int32 numRemoved = threadCount; // don't count first header in thread
NoteStartChange(index + 1, -numRemoved, MSG_NotifyInsertOrDelete);
// start at first id after thread.
for (int i = 1; i <= threadCount && index + 1 < m_idArray.GetSize(); i++)
{
m_idArray.RemoveAt(index + 1);
m_flags.RemoveAt(index + 1);
m_levels.RemoveAt(index + 1);
}
if (pNumCollapsed != NULL)
*pNumCollapsed = numRemoved;
NoteEndChange(index + 1, -numRemoved, MSG_NotifyInsertOrDelete);
}
delete msgHdr;
return err;
}
MsgERR MessageDBView::FindPrevUnread(MessageKey startKey, MessageKey *pResultKey,
MessageKey *resultThreadId)
{
MSG_ViewIndex startIndex = FindViewIndex(startKey);
MSG_ViewIndex curIndex = startIndex;
MSG_ViewIndex lastIndex = (uint32) GetSize() - 1;
MsgERR err = eID_NOT_FOUND;
if (startIndex == kViewIndexNone)
return eID_NOT_FOUND;
*pResultKey = kIdNone;
if (resultThreadId)
*resultThreadId = kIdNone;
for (; (int) curIndex >= 0 && (*pResultKey == kIdNone); curIndex--)
{
char flags = m_flags[curIndex];
if (curIndex != startIndex && flags & kIsThread && flags & kElided)
{
MessageKey threadId = m_idArray[curIndex];
err = m_messageDB->GetUnreadKeyInThread(threadId, pResultKey,
resultThreadId);
if (err == eSUCCESS && (*pResultKey != kIdNone))
break;
}
if (!(flags & kIsRead) && (curIndex != startIndex))
{
*pResultKey = m_idArray[curIndex];
err = eSUCCESS;
break;
}
}
// found unread message but we don't know the thread
if (*pResultKey != kIdNone && resultThreadId && *resultThreadId == kIdNone)
{
*resultThreadId = m_messageDB->GetThreadIdForMsgId(*pResultKey);
}
return err;
}
// Note that these routines do NOT expand collapsed threads! This mimics the old behaviour,
// but it's also because we don't remember whether a thread contains a flagged message the
// same way we remember if a thread contains new messages. It would be painful to dive down
// into each collapsed thread to update navigate status.
// We could cache this info, but it would still be expensive the first time this status needs
// to get updated.
MsgERR MessageDBView::FindFirstFlagged(MSG_ViewIndex * pResultIndex)
{
return FindNextFlagged(0, pResultIndex);
}
MsgERR MessageDBView::FindPrevFlagged(MSG_ViewIndex startIndex, MSG_ViewIndex *pResultIndex)
{
MSG_ViewIndex lastIndex = (uint32) GetSize() - 1;
MSG_ViewIndex curIndex;
*pResultIndex = MSG_VIEWINDEXNONE;
if (GetSize() > 0 && IsValidIndex(startIndex))
{
curIndex = startIndex;
do
{
if (curIndex != 0)
curIndex--;
char flags = m_flags[curIndex];
if (flags & kMsgMarked)
{
*pResultIndex = curIndex;
break;
}
}
while (curIndex != 0);
}
return eSUCCESS;
}
MsgERR MessageDBView::FindNextFlagged(MSG_ViewIndex startIndex, MSG_ViewIndex *pResultIndex)
{
MSG_ViewIndex lastIndex = (uint32) GetSize() - 1;
MSG_ViewIndex curIndex;
*pResultIndex = MSG_VIEWINDEXNONE;
if (GetSize() > 0)
{
for (curIndex = startIndex; curIndex <= lastIndex; curIndex++)
{
char flags = m_flags[curIndex];
if (flags & kMsgMarked)
{
*pResultIndex = curIndex;
break;
}
}
}
return eSUCCESS;
}
MsgERR MessageDBView::FindFirstNew(MSG_ViewIndex * pResultIndex)
{
MessageKey firstNewKey = m_messageDB->GetFirstNew();
if (pResultIndex)
*pResultIndex = FindKey(firstNewKey, TRUE);
return eSUCCESS;
}
// Generic routine to find next unread id. It doesn't do an expand of a
// thread with new messages, so it can't return a view index.
MsgERR MessageDBView::FindNextUnread(MessageKey startId, MessageKey *pResultKey,
MessageKey *resultThreadId)
{
MSG_ViewIndex startIndex = FindViewIndex(startId);
MSG_ViewIndex curIndex = startIndex;
MSG_ViewIndex lastIndex = (uint32) GetSize() - 1;
MsgERR err = eSUCCESS;
if (startIndex == kViewIndexNone)
return eID_NOT_FOUND;
*pResultKey = kIdNone;
if (resultThreadId)
*resultThreadId = kIdNone;
for (; curIndex <= lastIndex && (*pResultKey == kIdNone); curIndex++)
{
char flags = m_flags[curIndex];
if (!(flags & kIsRead) && (curIndex != startIndex))
{
*pResultKey = m_idArray[curIndex];
break;
}
// check for collapsed thread with new children
if (m_sortType == SortByThread && flags & kIsThread && flags & kElided)
{
MessageKey threadId = m_idArray[curIndex];
err = m_messageDB->GetUnreadKeyInThread(threadId, pResultKey,
resultThreadId);
if (err == eSUCCESS && (*pResultKey != kIdNone))
break;
}
}
// found unread message but we don't know the thread
if (*pResultKey != kIdNone && resultThreadId && *resultThreadId == kIdNone)
{
*resultThreadId = m_messageDB->GetThreadIdForMsgId(*pResultKey);
}
return err;
}
MsgERR MessageDBView::DataNavigate( MessageKey startKey, MSG_MotionType motion,
MessageKey *pResultKey, MessageKey *pThreadKey)
{
MsgERR err = eSUCCESS;
MSG_ViewIndex resultIndex;
MSG_ViewIndex lastIndex = (uint32) GetSize() - 1;
MSG_ViewIndex startIndex = FindViewIndex(startKey);
if (startIndex == kViewIndexNone)
return eID_NOT_FOUND;
XP_ASSERT(pResultKey != NULL );
if (pResultKey == NULL)
return eBAD_PARAMETER;
switch (motion)
{
case MSG_FirstMessage:
*pResultKey = m_idArray[0];
break;
case MSG_NextMessage:
// return same index and id on next on last message
resultIndex = MIN(startIndex + 1, lastIndex);
*pResultKey = m_idArray[resultIndex];
break;
case MSG_PreviousMessage:
*pResultKey = m_idArray[(startIndex > 0) ? startIndex : 0];
break;
case MSG_LastMessage:
*pResultKey = m_idArray[lastIndex];
break;
case MSG_FirstUnreadMessage:
// note fall thru - is this motion ever used?
startKey = m_idArray[0];
case MSG_NextUnreadMessage:
// It might be worthwhile to not actually find the next unread,
// but just determine if there is one. Or, it might be worth
// remembering the next unread.
FindNextUnread(startKey, pResultKey, pThreadKey);
break;
case MSG_PreviousUnreadMessage:
// will do an expand
err = FindPrevUnread(startKey, pResultKey, pThreadKey);
break;
case MSG_LastUnreadMessage:
break;
default:
XP_ASSERT(FALSE); // unsupported motion.
break;
}
return err;
}
typedef struct CommandStrLookup
{
int command;
int mkStringNum;
} CommandStrLookup;
// Because some compilers can't initialize static data with ints, we have the following pain
CommandStrLookup navigateCommands[] =
{
{ MSG_FirstMessage, 0, /*MK_MSG_FIRST_MSG */},
{ MSG_NextMessage, 0, /*MK_MSG_NEXT_MSG */},
{ MSG_PreviousMessage, 0, /*MK_MSG_PREV_MSG */},
{ MSG_LastMessage, 0, /*MK_MSG_LAST_MSG */},
{ MSG_FirstUnreadMessage, 0, /*MK_MSG_FIRST_UNREAD */},
{ MSG_NextUnreadMessage, 0, /*MK_MSG_NEXT_UNREAD */},
{ MSG_PreviousUnreadMessage, 0, /*MK_MSG_PREV_UNREAD */},
{ MSG_LastUnreadMessage, 0, /*MK_MSG_LAST_UNREAD */},
{ MSG_ReadMore, 0, /*MK_MSG_READ_MORE */},
{ MSG_NextUnreadThread, 0, /*MK_MSG_NEXTUNREAD_THREAD */},
{ MSG_NextUnreadGroup, 0, /*MK_MSG_NEXTUNREAD_GROUP */},
{ MSG_FirstFlagged, 0, /*MK_MSG_FIRST_FLAGGED */},
{ MSG_NextFlagged, 0, /*MK_MSG_NEXT_FLAGGED */},
{ MSG_PreviousFlagged, 0, /*MK_MSG_PREVIOUS_FLAGGED */},
};
/*static*/ void MessageDBView::InitNavigateCommands()
{
if (navigateCommands[0].mkStringNum == 0)
{
navigateCommands[0].mkStringNum = MK_MSG_FIRST_MSG;
navigateCommands[1].mkStringNum = MK_MSG_NEXT_MSG;
navigateCommands[2].mkStringNum = MK_MSG_PREV_MSG;
navigateCommands[3].mkStringNum = MK_MSG_LAST_MSG;
navigateCommands[4].mkStringNum = MK_MSG_FIRST_UNREAD;
navigateCommands[5].mkStringNum = MK_MSG_NEXT_UNREAD;
navigateCommands[6].mkStringNum = MK_MSG_PREV_UNREAD;
navigateCommands[7].mkStringNum = MK_MSG_LAST_UNREAD;
navigateCommands[8].mkStringNum = MK_MSG_READ_MORE;
navigateCommands[9].mkStringNum = MK_MSG_NEXTUNREAD_THREAD;
navigateCommands[10].mkStringNum = MK_MSG_NEXTUNREAD_GROUP;
navigateCommands[11].mkStringNum = MK_MSG_FIRST_FLAGGED;
navigateCommands[12].mkStringNum = MK_MSG_NEXT_FLAGGED;
navigateCommands[13].mkStringNum = MK_MSG_PREV_FLAGGED;
}
}
MsgERR MessageDBView::GetNavigateStatus(MSG_MotionType motion, MSG_ViewIndex index,
XP_Bool *selectable_p,
const char **display_string)
{
XP_Bool enable = FALSE;
MsgERR err = eFAILURE;
MessageKey resultKey;
MSG_ViewIndex resultIndex = MSG_VIEWINDEXNONE;
InitNavigateCommands();
// warning - we no longer validate index up front because fe passes in -1 for no
// selection, so if you use index, be sure to validate it before using it
// as an array index.
switch (motion)
{
case MSG_FirstMessage:
case MSG_LastMessage:
if (GetSize() > 0)
enable = TRUE;
break;
case MSG_NextMessage:
if (IsValidIndex(index) && index < (uint32) GetSize() - 1)
enable = TRUE;
break;
case MSG_PreviousMessage:
if (IsValidIndex(index) && index != 0 && GetSize() > 1)
enable = TRUE;
break;
case MSG_FirstFlagged:
err = FindFirstFlagged(&resultIndex);
enable = (err == eSUCCESS && resultIndex != MSG_VIEWINDEXNONE);
break;
case MSG_NextFlagged:
err = FindNextFlagged(index + 1, &resultIndex);
enable = (err == eSUCCESS && resultIndex != MSG_VIEWINDEXNONE);
break;
case MSG_PreviousFlagged:
if (IsValidIndex(index) && index != 0)
err = FindPrevFlagged(index, &resultIndex);
enable = (err == eSUCCESS && resultIndex != MSG_VIEWINDEXNONE);
break;
case MSG_FirstNew:
err = FindFirstNew(&resultIndex);
enable = (err == eSUCCESS && resultIndex != MSG_VIEWINDEXNONE);
break;
case MSG_LaterMessage:
enable = GetSize() > 0;
break;
case MSG_ReadMore:
enable = TRUE; // for now, always true.
break;
case MSG_NextFolder:
case MSG_NextUnreadGroup:
case MSG_NextUnreadThread:
case MSG_NextUnreadMessage:
case (MSG_MotionType) MSG_ToggleThreadKilled:
enable = TRUE; // always enabled in nwo
break;
case MSG_PreviousUnreadMessage:
if (IsValidIndex(index))
{
err = FindPrevUnread(m_idArray[index], &resultKey);
enable = (resultKey != kIdNone);
}
break;
default:
XP_ASSERT(FALSE);
}
if (selectable_p)
*selectable_p = enable;
// look up motion code in CommandStrLookup.
for (int i = 0; display_string && i < (sizeof(navigateCommands) / sizeof(navigateCommands[0])); i++)
{
if (navigateCommands[i].command == motion)
{
*display_string = XP_GetString(navigateCommands[i].mkStringNum);
break;
}
}
return eSUCCESS;
}
// Starting from startId, performs the passed in navigation, including
// any marking read needed, and returns the resultKey and index of the
// destination of the navigation. If there are no more unread in the view,
// it returns a resultId of kIdNone and an index of kViewIndexNone.
MsgERR MessageDBView::Navigate(MSG_ViewIndex startIndex, MSG_MotionType motion,
MessageKey * pResultKey, MSG_ViewIndex * pResultIndex,
MSG_ViewIndex *pThreadIndex, XP_Bool wrap /* = TRUE */)
{
MsgERR err = eSUCCESS;
MessageKey resultThreadKey;
MSG_ViewIndex curIndex;
MSG_ViewIndex lastIndex = (GetSize() > 0) ? (uint32) GetSize() - 1 : kViewIndexNone;
MSG_ViewIndex threadIndex = kViewIndexNone;
XP_ASSERT(pResultKey != NULL && pResultIndex != NULL );
if (pResultKey == NULL || pResultIndex == NULL)
return eBAD_PARAMETER;
switch (motion)
{
case MSG_FirstMessage:
if (GetSize() > 0)
{
*pResultIndex = 0;
*pResultKey = m_idArray[0];
}
else
{
*pResultIndex = kViewIndexNone;
*pResultKey = MSG_MESSAGEKEYNONE;
}
break;
case MSG_NextMessage:
// return same index and id on next on last message
*pResultIndex = MIN(startIndex + 1, lastIndex);
*pResultKey = m_idArray[*pResultIndex];
break;
case MSG_PreviousMessage:
*pResultIndex = (startIndex > 0) ? startIndex - 1 : 0;
*pResultKey = m_idArray[*pResultIndex];
break;
case MSG_LastMessage:
*pResultIndex = lastIndex;
*pResultKey = m_idArray[*pResultIndex];
break;
case MSG_FirstFlagged:
err = FindFirstFlagged(pResultIndex);
if (IsValidIndex(*pResultIndex))
*pResultKey = m_idArray[*pResultIndex];
break;
case MSG_NextFlagged:
err = FindNextFlagged(startIndex + 1, pResultIndex);
if (IsValidIndex(*pResultIndex))
*pResultKey = m_idArray[*pResultIndex];
break;
case MSG_PreviousFlagged:
err = FindPrevFlagged(startIndex, pResultIndex);
if (IsValidIndex(*pResultIndex))
*pResultKey = m_idArray[*pResultIndex];
break;
case MSG_FirstNew:
err = FindFirstNew(pResultIndex);
if (IsValidIndex(*pResultIndex))
*pResultKey = m_idArray[*pResultIndex];
break;
case MSG_FirstUnreadMessage:
startIndex = kViewIndexNone; // note fall thru - is this motion ever used?
case MSG_NextUnreadMessage:
for (curIndex = (startIndex == kViewIndexNone) ? 0 : startIndex; curIndex <= lastIndex && lastIndex != kViewIndexNone; curIndex++)
{
char flags = m_flags[curIndex];
// don't return start index since navigate should move
if (!(flags & kIsRead) && (curIndex != startIndex))
{
*pResultIndex = curIndex;
*pResultKey = m_idArray[*pResultIndex];
break;
}
// check for collapsed thread with new children
if (m_sortType == SortByThread && flags & kIsThread && flags & kElided)
{
DBThreadMessageHdr *threadHdr = m_messageDB->GetDBThreadHdrForMsgID(m_idArray[curIndex]);
if (threadHdr == NULL)
{
XP_ASSERT(FALSE);
continue;
}
if (threadHdr->GetNumNewChildren() > 0)
{
uint32 numExpanded;
ExpandByIndex(curIndex, &numExpanded);
lastIndex += numExpanded;
if (pThreadIndex != NULL)
*pThreadIndex = curIndex;
}
delete threadHdr;
}
}
if (curIndex > lastIndex)
{
// wrap around by starting at index 0.
if (wrap)
{
MessageKey startKey = GetAt(startIndex);
err = Navigate(kViewIndexNone, MSG_NextUnreadMessage, pResultKey,
pResultIndex, pThreadIndex, FALSE);
if (*pResultKey == startKey) // wrapped around and found start message!
{
*pResultIndex = kViewIndexNone;
*pResultKey = kIdNone;
}
}
else
{
*pResultIndex = kViewIndexNone;
*pResultKey = kIdNone;
}
}
break;
case MSG_PreviousUnreadMessage:
err = FindPrevUnread(m_idArray[startIndex], pResultKey,
&resultThreadKey);
if (err == eSUCCESS)
{
*pResultIndex = FindViewIndex(*pResultKey);
if (*pResultKey != resultThreadKey && m_sortType == SortByThread)
{
threadIndex = ThreadIndexOfMsg(*pResultKey, kViewIndexNone);
if (*pResultIndex == kViewIndexNone)
{
DBThreadMessageHdr *threadHdr = m_messageDB->GetDBThreadHdrForMsgID(*pResultKey);
if (threadHdr == NULL)
{
XP_ASSERT(FALSE);
break;
}
if (threadHdr->GetNumNewChildren() > 0)
{
uint32 numExpanded;
ExpandByIndex(threadIndex, &numExpanded);
}
delete threadHdr;
*pResultIndex = FindViewIndex(*pResultKey);
}
}
if (pThreadIndex != NULL)
*pThreadIndex = threadIndex;
}
break;
case MSG_LastUnreadMessage:
break;
case MSG_NextUnreadThread:
if (startIndex == kViewIndexNone)
{
XP_ASSERT(FALSE);
break;
}
err = MarkThreadOfMsgRead(m_idArray[startIndex], startIndex, TRUE);
if (err == eSUCCESS)
return Navigate(startIndex, MSG_NextUnreadMessage, pResultKey,
pResultIndex, pThreadIndex, TRUE);
break;
case MSG_ToggleThreadKilled:
{
XP_Bool resultKilled;
if (startIndex == kViewIndexNone)
{
XP_ASSERT(FALSE);
break;
}
threadIndex = ThreadIndexOfMsg(GetAt(startIndex), startIndex);
ToggleIgnored( &startIndex, 1, &resultKilled);
if (resultKilled)
{
if (threadIndex != MSG_VIEWINDEXNONE)
CollapseByIndex(threadIndex, NULL);
return Navigate(threadIndex, MSG_NextUnreadThread, pResultKey,
pResultIndex, pThreadIndex);
}
else
{
*pResultIndex = startIndex;
*pResultKey = m_idArray[*pResultIndex];
return eSUCCESS;
}
}
case MSG_LaterMessage:
if (startIndex == kViewIndexNone)
{
XP_ASSERT(FALSE);
break;
}
m_messageDB->MarkLater(m_idArray[startIndex], 0);
return Navigate(startIndex, MSG_NextUnreadMessage, pResultKey,
pResultIndex, pThreadIndex);
default:
XP_ASSERT(FALSE); // unsupported motion.
break;
}
return err;
}
MSG_ViewIndex MessageDBView::GetIndexOfFirstDisplayedKeyInThread(DBThreadMessageHdr *threadHdr)
{
MSG_ViewIndex retIndex = MSG_VIEWINDEXNONE;
int childIndex = 0;
// We could speed up the unreadOnly view by starting our search with the first
// unread message in the thread. Sometimes, that will be wrong, however, so
// let's skip it until we're sure it's neccessary.
// (m_viewFlags & kUnreadOnly)
// ? threadHdr->GetFirstUnreadKey(m_messageDB) : threadHdr->GetChildAt(0);
while (retIndex == MSG_VIEWINDEXNONE && childIndex < threadHdr->GetNumChildren())
{
MessageKey childKey = threadHdr->GetChildAt(childIndex++);
retIndex = FindViewIndex(childKey);
}
return retIndex;
}
DBMessageHdr *MessageDBView::GetFirstMessageHdrToDisplayInThread(DBThreadMessageHdr *threadHdr)
{
DBMessageHdr *msgHdr;
if (m_viewFlags & kUnreadOnly)
msgHdr = threadHdr->GetFirstUnreadChild(GetDB());
else
msgHdr = threadHdr->GetChildHdrAt(0);
return msgHdr;
}
// caller must referTo hdr if they want to hold it or change it!
DBMessageHdr *MessageDBView::GetFirstDisplayedHdrInThread(DBThreadMessageHdr *threadHdr)
{
MSG_ViewIndex viewIndex = GetIndexOfFirstDisplayedKeyInThread(threadHdr);
MessageKey msgKey = GetAt(viewIndex);
return (msgKey == MSG_MESSAGEKEYNONE) ? 0 : m_messageDB->GetDBHdrForKey(msgKey);
}
// Find the view index of the thread containing the passed msgKey, if
// the thread is in the view. MsgIndex is passed in as a shortcut if
// it turns out the msgKey is the first message in the thread,
// then we can avoid looking for the msgKey.
MSG_ViewIndex MessageDBView::ThreadIndexOfMsg(MessageKey msgKey,
MSG_ViewIndex msgIndex /* = kViewIndexNone */,
int32 *pThreadCount /* = NULL */,
uint32 *pFlags /* = NULL */)
{
if (m_sortType != SortByThread)
return kViewIndexNone;
DBThreadMessageHdr *threadHdr = m_messageDB->GetDBThreadHdrForMsgID(msgKey);
MSG_ViewIndex retIndex = kViewIndexNone;
if (threadHdr != NULL)
{
if (msgIndex == kViewIndexNone)
msgIndex = FindViewIndex(msgKey);
if (msgIndex == kViewIndexNone) // key is not in view, need to find by thread
{
msgIndex = GetIndexOfFirstDisplayedKeyInThread(threadHdr);
MessageKey threadKey = (msgIndex == kViewIndexNone) ? kIdNone : GetAt(msgIndex);
if (pFlags)
*pFlags = threadHdr->GetFlags();
}
MSG_ViewIndex startOfThread = msgIndex;
while ((int32) startOfThread >= 0 && m_levels[startOfThread] != 0)
startOfThread--;
retIndex = startOfThread;
if (pThreadCount)
{
int32 numChildren = 0;
MSG_ViewIndex threadIndex = startOfThread;
do
{
threadIndex++;
numChildren++;
}
while ((int32) threadIndex < m_levels.GetSize() && m_levels[threadIndex] != 0);
*pThreadCount = numChildren;
}
delete threadHdr;
}
return retIndex;
}
MsgERR MessageDBView::MarkThreadOfMsgRead(MessageKey msgId, MSG_ViewIndex msgIndex, XP_Bool bRead)
{
DBThreadMessageHdr *threadHdr = m_messageDB->GetDBThreadHdrForMsgID(msgId);
MSG_ViewIndex threadIndex;
MsgERR err;
if (threadHdr == NULL)
{
XP_ASSERT(FALSE);
return eID_NOT_FOUND;
}
if (msgId != threadHdr->GetChildAt(0))
threadIndex = GetIndexOfFirstDisplayedKeyInThread(threadHdr);
else
threadIndex = msgIndex;
err = MarkThreadRead(threadHdr, threadIndex, bRead);
delete threadHdr;
return err;
}
MsgERR MessageDBView::MarkThreadRead(DBThreadMessageHdr *threadHdr,
MSG_ViewIndex threadIndex, XP_Bool bRead)
{
XP_Bool threadElided = TRUE;
if (threadIndex != kViewIndexNone)
threadElided = (m_flags[threadIndex] & kElided);
for (int childIndex = 0; childIndex < threadHdr->GetNumChildren();
childIndex++)
{
DBMessageHdr *msgHdr = threadHdr->GetChildHdrAt(childIndex);
if (msgHdr == NULL)
{
#ifdef DEBUG_bienvenu
XP_ASSERT(FALSE);
#endif
continue;
}
// don't pass in listener so we can get change notification!
// We used to mark read through the view, but we weren't checking
// if the key actually was in the view.
m_messageDB->MarkHdrRead(msgHdr, bRead, NULL /* &m_changeListener */);
delete msgHdr;
}
if (bRead)
threadHdr->SetNumNewChildren(0);
else
threadHdr->SetNumNewChildren(threadHdr->GetNumChildren());
return eSUCCESS;
}
// view modifications methods by index
// read/unread handling.
MsgERR MessageDBView::ToggleReadByIndex(MSG_ViewIndex index)
{
if (!IsValidIndex(index))
return eInvalidIndex;
return SetReadByIndex(index, !(m_flags[index] & kIsRead));
}
MsgERR MessageDBView::SetReadByIndex(MSG_ViewIndex index, XP_Bool read)
{
MsgERR err;
if (!IsValidIndex(index))
return eInvalidIndex;
if (read)
OrExtraFlag(index, kIsRead);
else
AndExtraFlag(index, ~kIsRead);
err = m_messageDB->MarkRead(m_idArray[index], read, &m_changeListener);
NoteChange(index, 1, MSG_NotifyChanged);
if (m_sortType == SortByThread)
{
MSG_ViewIndex threadIndex = ThreadIndexOfMsg(m_idArray[index], index, NULL, NULL);
if (threadIndex != index)
NoteChange(threadIndex, 1, MSG_NotifyChanged);
}
return err;
}
MsgERR MessageDBView::SetThreadOfMsgReadByIndex(MSG_ViewIndex index, XP_Bool /*read*/)
{
MsgERR err;
if (!IsValidIndex(index))
return eInvalidIndex;
err = MarkThreadOfMsgRead(m_idArray[index], index, TRUE);
return err;
}
static MsgERR
msg_AddNameAndAddressToAB (MWContext* context, const char *name, const char *address, XP_Bool lastOneToAdd)
{
MsgERR err = eSUCCESS;
PersonEntry person;
char * tempname = NULL;
DIR_Server* pab = NULL;
INTL_CharSetInfo c = LO_GetDocumentCharacterSetInfo(context);
person.Initialize();
if (XP_STRLEN (name))
tempname = XP_STRDUP (name);
else
{
int len = 0;
char * at = NULL;
if (address)
{
// if the mail address doesn't contain @
// then the name is the whole email address
if ((at = XP_STRCHR(address, '@')) == NULL)
tempname = MSG_ExtractRFC822AddressNames (address);
else {
// otherwise extract everything up to the @
// for the name
len = XP_STRLEN (address) - XP_STRLEN (at);
tempname = (char *) XP_ALLOC (len + 1);
XP_STRNCPY_SAFE (tempname, address, len + 1);
}
}
}
person.pGivenName = tempname;
person.pEmailAddress = XP_STRDUP (address);
person.WinCSID = INTL_GetCSIWinCSID(c);
AB_BreakApartFirstName (FE_GetAddressBook(NULL), &person);
DIR_GetPersonalAddressBook (FE_GetDirServers(), &pab);
err = AB_AddUserWithUI (context, &person, pab, lastOneToAdd);
person.CleanUp();
return err;
}
/* new address book APIs require a destination container */
MsgERR MessageDBView::AddSenderToABByIndex(MSG_Pane * pane, MWContext* context, MSG_ViewIndex index, XP_Bool lastOneToAdd, XP_Bool displayRecip, AB_ContainerInfo * destAB)
{
/* taken verbatim from the old address book version except we call the new API AB_AddNameAndAddress */
MsgERR err = eSUCCESS;
char author[512];
char authorname [256];
int num;
char * name = NULL;
char * address = NULL;
if (!IsValidIndex(index))
return eInvalidIndex;
if (!context)
return eUNKNOWN;
DBMessageHdr *dbHdr = m_messageDB->GetDBHdrForKey(m_idArray[index]);
if (displayRecip)
{
int32 numRecips = dbHdr->GetNumRecipients();
for (int32 i = 0; i < numRecips && err == eSUCCESS; i++)
{
XPStringObj recipName;
dbHdr->GetNameOfRecipient (recipName, (int) i, m_messageDB->GetDB());
XPStringObj recipAddress;
dbHdr->GetMailboxOfRecipient (recipAddress, (int) i, m_messageDB->GetDB());
err = AB_AddNameAndAddress(pane, destAB, recipName, recipAddress, lastOneToAdd);
}
}
else
{
dbHdr->GetRFC822Author(authorname, sizeof (authorname), m_messageDB->GetDB());
dbHdr->GetAuthor(author, sizeof (author), m_messageDB->GetDB());
num = MSG_ParseRFC822Addresses(author, &name, &address);
if (num < 0)
return eOUT_OF_MEMORY;
err = AB_AddNameAndAddress (pane, destAB, authorname, address, lastOneToAdd);
}
delete dbHdr;
XP_FREEIF (name);
XP_FREEIF (address);
return err;
}
MsgERR MessageDBView::AddAllToABByIndex(MSG_Pane * pane, MWContext* context, MSG_ViewIndex index, XP_Bool lastOneToAdd, AB_ContainerInfo * destAB)
{
/* copied pretty much verbatim from the old address book version except we call the new APIs. */
MsgERR err = eSUCCESS;
XPStringObj prettyname;
XPStringObj mailbox;
int32 numRecipients = 0;
int32 numCCList = 0;
char name [kMaxFullNameLength];
char address [kMaxEmailAddressLength];
if (!IsValidIndex(index))
return eInvalidIndex;
DBMessageHdr *dbHdr = m_messageDB->GetDBHdrForKey(m_idArray[index]);
numRecipients = dbHdr->GetNumRecipients();
numCCList = dbHdr->GetNumCCRecipients();
err = AddSenderToABByIndex (pane, context, index, (lastOneToAdd && numRecipients == 0 && numCCList == 0), FALSE, destAB);
if (err != eSUCCESS) {
delete dbHdr;
return eUNKNOWN;
}
for (int32 i = 0; i < numRecipients && err == eSUCCESS; i++)
{
dbHdr->GetNameOfRecipient(prettyname, i, m_messageDB->GetDB());
XP_STRNCPY_SAFE(name, prettyname, kMaxFullNameLength);
dbHdr->GetMailboxOfRecipient(mailbox, i, m_messageDB->GetDB());
XP_STRNCPY_SAFE(address, mailbox, kMaxEmailAddressLength);
err = AB_AddNameAndAddress (pane, destAB,name, address, (lastOneToAdd &&
( i == numRecipients - 1) && (numCCList == 0)));
}
for (int32 j = 0; j < numCCList && err == eSUCCESS; j++)
{
dbHdr->GetNameOfCCRecipient(prettyname, j, m_messageDB->GetDB());
XP_STRNCPY_SAFE(name, prettyname, kMaxFullNameLength);
dbHdr->GetMailboxOfCCRecipient(mailbox, j, m_messageDB->GetDB());
XP_STRNCPY_SAFE(address, mailbox, kMaxEmailAddressLength);
err = AB_AddNameAndAddress (pane, destAB, name, address, (lastOneToAdd && (j == numCCList - 1)));
}
delete dbHdr;
return err;
}
/* mscott: DELETE THESE AS SOON AS THE NEW ADDRESS BOOK IS TURNED ON FOR EVERYONE */
MsgERR MessageDBView::AddSenderToABByIndex(MWContext * context, MSG_ViewIndex index, XP_Bool lastOneToAdd, XP_Bool displayRecip)
{
MsgERR err = eSUCCESS;
char author[512];
char authorname [256];
int num;
char * name = NULL;
char * address = NULL;
if (!IsValidIndex(index))
return eInvalidIndex;
if (!context)
return eUNKNOWN;
DBMessageHdr *dbHdr = m_messageDB->GetDBHdrForKey(m_idArray[index]);
if (displayRecip)
{
int32 numRecips = dbHdr->GetNumRecipients();
for (int32 i = 0; i < numRecips && err == eSUCCESS; i++)
{
XPStringObj recipName;
dbHdr->GetNameOfRecipient (recipName, (int) i, m_messageDB->GetDB());
XPStringObj recipAddress;
dbHdr->GetMailboxOfRecipient (recipAddress, (int) i, m_messageDB->GetDB());
err = msg_AddNameAndAddressToAB (context, recipName, recipAddress, lastOneToAdd);
}
}
else
{
dbHdr->GetRFC822Author(authorname, sizeof (authorname), m_messageDB->GetDB());
dbHdr->GetAuthor(author, sizeof (author), m_messageDB->GetDB());
num = MSG_ParseRFC822Addresses(author, &name, &address);
if (num < 0)
return eOUT_OF_MEMORY;
err = msg_AddNameAndAddressToAB (context, authorname, address, lastOneToAdd);
}
delete dbHdr;
XP_FREEIF (name);
XP_FREEIF (address);
return err;
}
MsgERR MessageDBView::AddAllToABByIndex(MWContext* context, MSG_ViewIndex index, XP_Bool lastOneToAdd)
{
MsgERR err = eSUCCESS;
XPStringObj prettyname;
XPStringObj mailbox;
int32 numRecipients = 0;
int32 numCCList = 0;
char name [kMaxFullNameLength];
char address [kMaxEmailAddressLength];
if (!IsValidIndex(index))
return eInvalidIndex;
DBMessageHdr *dbHdr = m_messageDB->GetDBHdrForKey(m_idArray[index]);
numRecipients = dbHdr->GetNumRecipients();
numCCList = dbHdr->GetNumCCRecipients();
err = AddSenderToABByIndex (context, index, (lastOneToAdd && numRecipients == 0 && numCCList == 0), FALSE);
if (err != eSUCCESS) {
delete dbHdr;
return eUNKNOWN;
}
for (int32 i = 0; i < numRecipients && err == eSUCCESS; i++)
{
dbHdr->GetNameOfRecipient(prettyname, i, m_messageDB->GetDB());
XP_STRNCPY_SAFE(name, prettyname, kMaxFullNameLength);
dbHdr->GetMailboxOfRecipient(mailbox, i, m_messageDB->GetDB());
XP_STRNCPY_SAFE(address, mailbox, kMaxEmailAddressLength);
err = msg_AddNameAndAddressToAB (context, name, address, (lastOneToAdd &&
( i == numRecipients - 1) && (numCCList == 0)));
}
for (int32 j = 0; j < numCCList && err == eSUCCESS; j++)
{
dbHdr->GetNameOfCCRecipient(prettyname, j, m_messageDB->GetDB());
XP_STRNCPY_SAFE(name, prettyname, kMaxFullNameLength);
dbHdr->GetMailboxOfCCRecipient(mailbox, j, m_messageDB->GetDB());
XP_STRNCPY_SAFE(address, mailbox, kMaxEmailAddressLength);
err = msg_AddNameAndAddressToAB (context, name, address, (lastOneToAdd && (j == numCCList - 1)));
}
delete dbHdr;
return err;
}
MsgERR MessageDBView::MarkMarkedByIndex(MSG_ViewIndex index, XP_Bool mark)
{
MsgERR err;
if (!IsValidIndex(index))
return eInvalidIndex;
if (mark)
OrExtraFlag(index, kMsgMarked);
else
AndExtraFlag(index, ~kMsgMarked);
err = m_messageDB->MarkMarked(m_idArray[index], mark, &m_changeListener);
NoteChange(index, 1, MSG_NotifyChanged);
return err;
}
// caller must RemoveReference thread!
MSG_ViewIndex MessageDBView::GetThreadFromMsgIndex(MSG_ViewIndex index,
DBThreadMessageHdr **threadHdr)
{
MessageKey msgKey = GetAt(index);
MsgViewIndex threadIndex;
XP_ASSERT(threadHdr);
*threadHdr = m_messageDB->GetDBThreadHdrForMsgID(msgKey);
if (*threadHdr == NULL)
{
// XP_ASSERT(FALSE);
return MSG_VIEWINDEXNONE;
}
if (msgKey != (*threadHdr)->m_threadKey)
threadIndex = GetIndexOfFirstDisplayedKeyInThread(*threadHdr);
else
threadIndex = index;
return threadIndex;
}
// ignore handling.
MsgERR MessageDBView::ToggleThreadIgnored(DBThreadMessageHdr *thread, MSG_ViewIndex threadIndex)
{
MsgERR err;
if (!IsValidIndex(threadIndex))
return eInvalidIndex;
err = SetThreadIgnored(thread, threadIndex, !((thread->GetFlags() & kIgnored) != 0));
return err;
}
MsgERR MessageDBView::ToggleThreadWatched(DBThreadMessageHdr *thread, MSG_ViewIndex index)
{
MsgERR err;
if (!IsValidIndex(index))
return eInvalidIndex;
err = SetThreadWatched(thread, index, !((thread->GetFlags() & kWatched) != 0));
return err;
}
MsgERR MessageDBView::ToggleIgnored( MsgViewIndex* indices, int32 numIndices, XP_Bool *resultToggleState)
{
MsgERR err;
DBThreadMessageHdr *thread = NULL;
if (numIndices == 1)
{
MsgViewIndex threadIndex = GetThreadFromMsgIndex(*indices, &thread);
if (thread)
{
err = ToggleThreadIgnored(thread, threadIndex);
if (resultToggleState)
*resultToggleState = (thread->GetFlags() & kIgnored) ? TRUE : FALSE;
delete thread;
}
}
else
{
if (numIndices > 1)
XP_QSORT (indices, numIndices, sizeof(MSG_ViewIndex), MSG_Pane::CompareViewIndices);
for (int curIndex = numIndices - 1; curIndex >= 0; curIndex--)
{
MsgViewIndex threadIndex = GetThreadFromMsgIndex(*indices, &thread);
}
}
return eSUCCESS;
}
MsgERR MessageDBView::ToggleWatched( MsgViewIndex* indices, int32 numIndices)
{
MsgERR err;
DBThreadMessageHdr *thread = NULL;
if (numIndices == 1)
{
MsgViewIndex threadIndex = GetThreadFromMsgIndex(*indices, &thread);
if (threadIndex != MSG_VIEWINDEXNONE)
{
err = ToggleThreadWatched(thread, threadIndex);
delete thread;
}
}
else
{
if (numIndices > 1)
XP_QSORT (indices, numIndices, sizeof(MSG_ViewIndex), MSG_Pane::CompareViewIndices);
for (int curIndex = numIndices - 1; curIndex >= 0; curIndex--)
{
MsgViewIndex threadIndex = GetThreadFromMsgIndex(*indices, &thread);
}
}
return eSUCCESS;
}
MsgERR MessageDBView::SetThreadIgnored(DBThreadMessageHdr *thread, MSG_ViewIndex threadIndex, XP_Bool ignored)
{
MsgERR err;
if (!IsValidIndex(threadIndex))
return eInvalidIndex;
err = m_messageDB->MarkThreadIgnored(thread, m_idArray[threadIndex], ignored, &m_changeListener);
NoteChange(threadIndex, 1, MSG_NotifyChanged);
if (ignored)
{
MarkThreadRead(thread, threadIndex, TRUE);
}
return err;
}
MsgERR MessageDBView::SetThreadWatched(DBThreadMessageHdr *thread, MSG_ViewIndex index, XP_Bool watched)
{
MsgERR err;
if (!IsValidIndex(index))
return eInvalidIndex;
err = m_messageDB->MarkThreadWatched(thread, m_idArray[index], watched, &m_changeListener);
NoteChange(index, 1, MSG_NotifyChanged);
return err;
}
MsgERR MessageDBView::SetKeyByIndex(MSG_ViewIndex index, MessageKey id)
{
m_idArray.SetAt(index, id);
return eSUCCESS;
}
// This method just removes the specified line from the view. It does
// NOT delete it from the database.
MsgERR MessageDBView::RemoveByIndex(MSG_ViewIndex index)
{
if (!IsValidIndex(index))
return eInvalidIndex;
m_idArray.RemoveAt(index);
m_flags.RemoveAt(index);
m_levels.RemoveAt(index);
NoteChange(index, -1, MSG_NotifyInsertOrDelete);
return eSUCCESS;
}
MsgERR MessageDBView::DeleteMessagesByIndex(MSG_ViewIndex *indices, int32 numIndices, XP_Bool removeFromDB)
{
MsgERR err = eSUCCESS;
IDArray messageKeys;
MSG_ViewIndex *tmpIndices = new MSG_ViewIndex [numIndices];
if (!tmpIndices)
return eOUT_OF_MEMORY;
memcpy (tmpIndices, indices, numIndices * sizeof(MSG_ViewIndex));
XP_QSORT (tmpIndices, numIndices, sizeof(MSG_ViewIndex), MSG_Pane::CompareViewIndices);
if (removeFromDB)
messageKeys.SetSize(numIndices);
for (int32 i = numIndices - 1; i >= 0 && err == eSUCCESS; i--)
{
MSG_ViewIndex viewIndex = tmpIndices[i];
if (IsValidIndex(viewIndex))
{
if (removeFromDB)
messageKeys.SetAt(i, m_idArray[viewIndex]);
err = RemoveByIndex(viewIndex);
OnHeaderAddedOrDeleted();
}
}
if (removeFromDB)
{
if (err == eSUCCESS)
err = m_messageDB->DeleteMessages(messageKeys, &m_changeListener);
}
delete [] tmpIndices;
return err;
}
// Delete the message from the database, and remove it from the view.
// If there's an error deleting the message from the db, it will
// not be removed from the view. We could return an error and still
// have deleted the message from the db, if there's an error
// deleting it from the view (this better not happen...)
MsgERR MessageDBView::DeleteMsgByIndex(MSG_ViewIndex index, XP_Bool removeFromDB)
{
MsgERR err = eSUCCESS;
if (!IsValidIndex(index))
return eInvalidIndex;
// cache the key before it is removed from the m_idArray
MessageKey keyOfDeletedMessage = m_idArray[index];
if (err == eSUCCESS)
{
err = RemoveByIndex(index);
OnHeaderAddedOrDeleted();
}
if (removeFromDB)
err = m_messageDB->DeleteMessage(keyOfDeletedMessage, &m_changeListener);
return err;
}
MsgERR MessageDBView::InsertByIndex(MSG_ViewIndex index,
MessageKey id)
{
if (!IsValidIndex(index))
return eInvalidIndex;
m_idArray.InsertAt(index, id, 1);
m_flags.InsertAt(index, 0, 1);
m_levels.InsertAt(index, 0, 1);
return eSUCCESS;
}
// view modifications methods by ID
MsgERR MessageDBView::SetReadByID(MessageKey id, XP_Bool read, MSG_ViewIndex* pIndex)
{
MSG_ViewIndex viewIndex = (MSG_ViewIndex) FindViewIndex(id);
if (pIndex != NULL)
*pIndex = viewIndex;
return SetReadByIndex(viewIndex, read);
}
// This should insert a new id after the passed in id, and returns the index
// at which it inserted it. Only write if needed.
MsgERR MessageDBView::InsertByID(MessageKey /*id*/,
MessageKey /*newId*/,
MSG_ViewIndex* /*pIndex*/)
{
return eNYI;
}
void MessageDBView::NoteChange(MSG_ViewIndex firstlineChanged, int numChanged,
MSG_NOTIFY_CODE changeType)
{
NotifyViewChangeAll(firstlineChanged, numChanged, changeType, &m_changeListener);
}
void MessageDBView::NoteStartChange(MSG_ViewIndex firstlineChanged, int numChanged,
MSG_NOTIFY_CODE changeType)
{
NotifyViewStartChangeAll(firstlineChanged, numChanged, changeType, &m_changeListener);
}
void MessageDBView::NoteEndChange(MSG_ViewIndex firstlineChanged, int numChanged,
MSG_NOTIFY_CODE changeType)
{
NotifyViewEndChangeAll(firstlineChanged, numChanged, changeType, &m_changeListener);
}
XP_Bool MessageDBView::IsValidIndex(MSG_ViewIndex index)
{
return (index < (MSG_ViewIndex) m_idArray.GetSize());
}
MsgERR MessageDBView::OrExtraFlag(MSG_ViewIndex index, char orflag)
{
char flag;
if (!IsValidIndex(index))
return eInvalidIndex;
flag = m_flags[index];
flag |= orflag;
m_flags[index] = flag;
OnExtraFlagChanged(index, flag);
return eSUCCESS;
}
MsgERR MessageDBView::AndExtraFlag(MSG_ViewIndex index, char andflag)
{
char flag;
if (!IsValidIndex(index))
return eInvalidIndex;
flag = m_flags[index];
flag &= andflag;
m_flags[index] = flag;
OnExtraFlagChanged(index, flag);
return eSUCCESS;
}
MsgERR MessageDBView::SetExtraFlag(MSG_ViewIndex index, char extraflag)
{
if (!IsValidIndex(index))
return eInvalidIndex;
m_flags[index] = extraflag;
OnExtraFlagChanged(index, extraflag);
return eSUCCESS;
}
MsgERR MessageDBView::GetExtraFlag(MSG_ViewIndex index,
char *extraFlag)
{
if (!IsValidIndex(index))
return eInvalidIndex;
*extraFlag = m_flags[index];
return eSUCCESS;
}
void MessageDBView::SetExtraFlagsFromDBFlags(uint32 messageFlags, MSG_ViewIndex index)
{
XP_ASSERT(IsValidIndex(index));
char flags = m_flags[index];
char origFlags = flags;
char saveFlags;
// save extra flags not stored in db, and restore them below.
// make a mask of the state of the extra flags
saveFlags = flags & (kHasChildren | kIsThread | kElided);
CopyDBFlagsToExtraFlags(messageFlags, &flags);
// no matter what CopyDBFlagsToExtraFlags did
// clear the three extra flags
flags &= ~(kHasChildren | kIsThread | kElided);
// use the mask to restore the state of the three flags
flags |= saveFlags;
m_flags.SetAt(index, flags);
if (m_sortType == SortByThread && (flags & kIsRead != origFlags & kIsRead)) // to update unread counts on thread headers.
{
MSG_ViewIndex threadIndex = ThreadIndexOfMsg(m_idArray[index], index, NULL, NULL);
if (threadIndex != index)
NoteChange(threadIndex, 1, MSG_NotifyChanged);
}
}
// Copy flags from extra array byte into DBMessageHdr flags. These flags may not have
// the same bit positions, although they do now. The message flags are currently 32 bits, and
// the extra flags just 8. Also, this routine takes a pointer to messageFlags so that it
// can just change the bits it knows about.
// These are the DB flags, not the MSG_FLAG flags.
void MessageDBView::CopyExtraFlagsToDBFlags(char flags, uint32 *messageFlags)
{
if (flags & kElided)
*messageFlags |= kElided;
else
*messageFlags &= ~kElided;
if (flags & kExpired)
*messageFlags |= kExpired;
else
*messageFlags &= ~kExpired;
if (flags & kIsRead)
*messageFlags |= kIsRead;
else
*messageFlags &= ~kIsRead;
if (flags & kHasChildren)
*messageFlags |= kHasChildren;
else
*messageFlags &= ~kHasChildren;
if (flags & kIsThread)
*messageFlags |= kIsThread;
else
*messageFlags &= ~kIsThread;
if (flags & kMsgMarked)
*messageFlags |= kMsgMarked;
else
*messageFlags &= ~kMsgMarked;
}
void MessageDBView::CopyExtraFlagsToPublicFlags(char flags, uint32 *messageFlags)
{
uint32 extraFlags = 0;
// Then turn off the possible bits in the result.
*messageFlags &= ~m_publicEquivOfExtraFlags;
// Now, convert the flags that are on, and turn the 32 bit public
// equivalent on in the result.
CopyExtraFlagsToDBFlags(flags, &extraFlags);
MessageDB::ConvertDBFlagsToPublicFlags(&extraFlags);
*messageFlags |= extraFlags;
}
void MessageDBView::CopyDBFlagsToExtraFlags(uint32 messageFlags, char *extraFlags)
{
if (messageFlags & kIsRead)
*extraFlags |= kIsRead;
else
*extraFlags &= ~kIsRead;
if (messageFlags & kExpired)
*extraFlags |= kExpired;
else
*extraFlags &= ~kExpired;
if (messageFlags & kHasChildren)
*extraFlags |= kHasChildren;
else
*extraFlags &= ~kHasChildren;
if (messageFlags & kElided)
*extraFlags |= kElided;
else
*extraFlags &= ~kElided;
if (messageFlags & kIsThread)
*extraFlags |= kIsThread;
else
*extraFlags &= ~kIsThread;
if (messageFlags & kMsgMarked)
*extraFlags |= kMsgMarked;
else
*extraFlags &= ~kMsgMarked;
if (messageFlags & kOffline)
*extraFlags |= kOffline;
else
*extraFlags &= ~kOffline;
}
/* Cache of open view objects allows us to enforce one open view per DB */
XP_List *MessageDBView::m_viewCache = NULL;
MessageDBView *MessageDBView::CacheLookup (MessageDB *pDB, ViewType type)
{
if (m_viewCache)
{
XP_List *walkCache = m_viewCache;
MessageDBView *walkView = 0;
do
{
walkView = (MessageDBView*) XP_ListNextObject(walkCache);
if (walkView && walkView->GetDB() == pDB)
{
// dbShowingIgnored doesn't matter if pDB is NULL, so FALSE is OK.
XP_Bool dbShowingIgnored = (pDB)
? (pDB->GetDBFolderInfo()->GetFlags() & MSG_FOLDER_PREF_SHOWIGNORED)
: FALSE;
if (( walkView->m_viewType == type && !!walkView->GetShowingIgnored() == !!dbShowingIgnored) || type == ViewAny || !pDB)
return walkView;
}
} while (walkView);
}
return NULL;
}
void MessageDBView::CacheAdd ()
{
// allocate list when needed
if (!m_viewCache)
m_viewCache = XP_ListNew();
// can't already exist in cache
XP_ASSERT (!CacheLookup(m_messageDB, m_viewType));
XP_ListAddObject (m_viewCache, this);
}
void MessageDBView::CacheRemove ()
{
// must already exist in cache
XP_ASSERT (CacheLookup (m_messageDB, m_viewType));
XP_ListRemoveObject (m_viewCache, this);
// delete list when empty
if (XP_ListCount (m_viewCache) == 0)
{
XP_ListDestroy (m_viewCache);
m_viewCache = NULL; // isn't this required? dmb
}
}
int32 MessageDBView::AddReference ()
{
m_messageDB->AddUseCount ();
return ++m_refCount;
}
Reference in New Issue View Git Blame Copy Permalink