Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-13 23:17:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
2fbefad3f4
gecko-dev/lib/libmsg/subpane.cpp

1851 lines
48 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 "errcode.h"
#include "subpane.h"
#include "hosttbl.h"
#include "msgmast.h"
#include "msgfinfo.h"
#include "xp_hash.h"
#include "newshost.h"
#include "imaphost.h"
#include "xpgetstr.h"
#include "grec.h"
#include "xp_qsort.h"
#include "msgurlq.h"
extern "C"
{
extern int MK_OUT_OF_MEMORY;
extern int MK_MSG_SEARCH_FAILED;
extern int MK_MSG_INCOMPLETE_NEWSGROUP_LIST;
extern int XP_ALERT_OFFLINE_MODE_SELECTED;
extern int MK_NNTP_SERVER_NOT_CONFIGURED;
}
// we are using the same ChangeSubscribe structure for both
// News and IMAP. We are also keeping these structs in the same hash
struct ChangeSubscribe {
MSG_Host* host;
char* groupname;
XP_Bool subscribe; // Whether we're trying to subscribe or
// unsubscribe to this group.
ChangeSubscribe* next;
};
static XP_Bool imap_freehashkeys(XP_HashTable table, const void* key,
void* value, void* closure);
MSG_SubscribePane* MSG_SubscribePane::CurPane = NULL;
MSG_SubscribePane*
MSG_SubscribePane::Create(MWContext* context, MSG_Master* master,
MSG_Host* host)
{
XP_ASSERT(!CurPane);
if (CurPane) return NULL;
MSG_Host* defhost = NULL;
// first try getting the default News (NNTP) host
defhost = MSG_GetDefaultNewsHost(master);
// if no NNTP host, try getting the default IMAP host
if (!defhost)
{
defhost = MSG_GetDefaultIMAPHost(master);
}
// no hosts configured
if (defhost == NULL)
{
FE_Alert(context, XP_GetString(MK_NNTP_SERVER_NOT_CONFIGURED));
#ifdef XP_MAC
/* AFTER the alert, not before! */
FE_EditPreference(PREF_NewsHost);
#endif
return NULL;
}
MSG_SubscribePane* result = new MSG_SubscribePane(context, master, host);
if (result && CurPane == NULL) {
// We ran out of memory or something. Abort.
delete result;
result = NULL;
}
return result;
}
static int
HashComp(const void *obj1, const void *obj2)
{
XP_ASSERT(obj1 && obj2);
ChangeSubscribe* c1 = (ChangeSubscribe*) obj1;
ChangeSubscribe* c2 = (ChangeSubscribe*) obj2;
int delta = XP_STRCMP(c1->groupname, c2->groupname);
if (delta) return delta;
if (c1->host < c2->host) return -1;
if (c1->host == c2->host) return 0;
return 1;
}
static int
msg_hash_strcmp (const void *a, const void *b)
{
return XP_STRCMP ((const char *) a, (const char *) b);
}
static uint32
HashFunc(const void* obj)
{
return XP_StringHash(((ChangeSubscribe*) obj)->groupname);
}
static int sortedptrarray_strcmp (const void* a, const void* b)
{
return XP_STRCMP (*(char **)a, *(char **)b);
}
XP_Bool imap_freehashkeys(XP_HashTable /*table*/, const void* key,
void* /*value*/, void* /*closure*/)
{
XP_FREE((char*) key);
return TRUE;
}
MSG_SubscribePane::MSG_SubscribePane(MWContext* context, MSG_Master* master,
MSG_Host* host)
: MSG_LinedPane(context, master)
{
m_host = NULL;
XP_ASSERT(master);
if (!master) return;
msg_HostTable *newsHosts = master->GetHostTable();
m_subscribeHash = XP_HashTableNew(20, (XP_HashingFunction) HashFunc, (XP_HashCompFunction) HashComp);
if (!m_subscribeHash) return;
m_imapGroupHash = XP_HashTableNew(20, XP_StringHash, msg_hash_strcmp);
if (!m_imapGroupHash) return;
m_imapSubscribedList = new XPSortedPtrArray(sortedptrarray_strcmp);
m_imapTree = msg_IMAPGroupRecord::Create(NULL, NULL, 0, FALSE);
XP_ASSERT(m_imapTree);
if (!m_imapTree) return;
m_subscribeCommitted = FALSE;
m_expandingIMAPGroup = NULL;
m_host = host;
if (!m_host) {
if (newsHosts) m_host = newsHosts->GetDefaultHost(TRUE);
}
if (!m_host)
{
m_host = MSG_GetDefaultIMAPHost(master);
}
int numNewsHosts = newsHosts ? newsHosts->getNumHosts() : 0;
if (!m_host && numNewsHosts > 0) {
m_host = newsHosts->getHost(0);
}
m_subscribeList = NULL;
m_endSubscribeList = NULL;
// Go through the news hosts and add each group to
// the hash table
for (int i=0 ; i<numNewsHosts ; i++) {
MSG_NewsHost* h = newsHosts->getHost(i);
XP_ASSERT(h);
if (!h) continue;
MSG_FolderInfo* hostinfo = h->GetHostInfo();
XP_ASSERT(hostinfo);
if (!hostinfo) continue;
int num = hostinfo->GetNumSubFolders();
for (int j=0 ; j<num ; j++) {
MSG_FolderInfoNews* newsinfo =
(MSG_FolderInfoNews*) hostinfo->GetSubFolder(j);
XP_ASSERT(newsinfo->IsNews());
if (!newsinfo->IsNews()) continue;
if (!newsinfo->IsSubscribed()) continue;
const char* groupname = newsinfo->GetNewsgroupName();
h->NoticeNewGroup(groupname);
ChangeSubscribe* tmp = new ChangeSubscribe;
if (!tmp) break;
if (m_endSubscribeList) {
m_endSubscribeList->next = tmp;
} else {
m_subscribeList = tmp;
}
m_endSubscribeList = tmp;
tmp->host = h;
tmp->groupname = new char [XP_STRLEN(groupname) + 1];
if (!tmp->groupname) {
m_host = NULL;
return;
}
XP_STRCPY(tmp->groupname, groupname);
tmp->next = NULL;
tmp->subscribe = TRUE;
XP_Puthash(m_subscribeHash, tmp, tmp);
}
}
// We probably don't have to go through the IMAP hosts
// and add each group to the hash table, since they will
// be added on the fly
if (m_host) {
MSG_NewsHost *newsHost = m_host->GetNewsHost();
if (newsHost)
newsHost->Inhale();
SetMode(MSG_SubscribeAll, TRUE);
}
CurPane = this;
}
MSG_SubscribePane::~MSG_SubscribePane()
{
int32 i;
//if (!m_subscribeCommitted)
// CommitSubscriptions();
// Clean up the list of changed subscriptions.
// We should do this here because we don't know
// if the IMAP commits will succeed or not,
// until now.
ChangeSubscribe* tmp = m_subscribeList;
while (tmp) {
ChangeSubscribe* next = tmp->next;
delete [] tmp->groupname;
tmp->groupname = NULL;
tmp->next = NULL;
delete tmp;
tmp = next;
}
// Force all the newsrc files to be updated now. After all,
// subscribing is a major operation we don't want to lose.
msg_HostTable* hosts = GetMaster()->GetHostTable();
for (i=0 ; i < (hosts ? hosts->getNumHosts() : 0) ; i++) {
MSG_NewsHost* h = hosts->getHost(i);
XP_ASSERT(h);
if (!h) continue;
h->WriteIfDirty();
}
if (m_host && m_host->IsNews())
{
MSG_NewsHost *newsHost = m_host->GetNewsHost();
if (newsHost)
newsHost->Exhale();
}
if (m_subscribeHash)
XP_HashTableDestroy(m_subscribeHash);
ClearAndFreeIMAPGroupList();
if (m_imapGroupHash)
XP_HashTableDestroy(m_imapGroupHash);
ClearAndFreeIMAPSubscribedList();
delete m_imapSubscribedList;
for (i=0 ; i<m_groupView.GetSize() ; i++) {
delete m_groupView[i];
m_groupView[i] = NULL;
}
XP_ASSERT(CurPane == this);
if (CurPane == this) CurPane = NULL;
delete m_imapTree;
MSG_RefreshFoldersForUpdatedIMAPHosts(GetContext());
}
MSG_PaneType
MSG_SubscribePane::GetPaneType() {
return MSG_SUBSCRIBEPANE;
}
void
MSG_SubscribePane::NotifyPrefsChange(NotifyCode)
{
// ###tw Write me!
}
void
MSG_SubscribePane::ToggleExpansion(MSG_ViewIndex line, int32* numchanged)
{
DoToggleExpansion(line, numchanged);
UpdateCounts();
}
void
MSG_SubscribePane::DoToggleExpansion(MSG_ViewIndex line, int32* numchanged)
{
if (numchanged) *numchanged = 0;
XP_ASSERT(line != MSG_VIEWINDEXNONE && line < m_groupView.GetSize());
if (line == MSG_VIEWINDEXNONE || line >= m_groupView.GetSize()) return;
XP_ASSERT(m_mode == MSG_SubscribeAll);
if (m_mode != MSG_SubscribeAll) return;
msg_SubscribeLine* info = m_groupView[line];
int depth = info->GetDepth();
msg_GroupRecord* group = info->GetGroup();
XP_ASSERT(group);
if (!group) return;
if (line < m_groupView.GetSize() - 1 &&
(m_groupView[line+1]->GetDepth() > depth)) {
// OK, we are already expanded. So, collapse things, which means
// nuke all lines after the given one that have a depth bigger than
// the given line.
XP_ASSERT(group->IsExpanded());
int32 start = line + 1;
int32 end;
for (end=start ; end<m_groupView.GetSize() ; end++) {
if (m_groupView[end]->GetDepth() <= depth) break;
}
StartingUpdate(MSG_NotifyInsertOrDelete, start, - (end - start));
for (int32 i=start ; i<end ; i++) {
delete m_groupView[i];
m_groupView[i] = NULL;
}
m_groupView.RemoveAt(start, end - start);
if (numchanged) *numchanged = - (end - start);
EndingUpdate(MSG_NotifyInsertOrDelete, start, - (end - start));
group->SetIsExpanded(FALSE);
}
else
{
// We are not expanded, so expand, if possible.
if (info->CanExpand()) {
XP_ASSERT(!group->IsExpanded());
msg_SubscribeLineArray kids;
GetKidsArray(group, &kids, info->GetDepth() + 1);
XP_ASSERT(kids.GetSize() > 0); // If not, why did we think we could
// expand?
StartingUpdate(MSG_NotifyInsertOrDelete, line + 1, kids.GetSize());
m_groupView.InsertAt(line + 1, &kids);
EndingUpdate(MSG_NotifyInsertOrDelete, line + 1, kids.GetSize());
if (numchanged) *numchanged = kids.GetSize();
group->SetIsExpanded(TRUE);
}
if (m_host && m_host->IsIMAP())
{
// expanding an imap folder, search for new children
msg_IMAPGroupRecord *imapGroup = group->GetIMAPGroupRecord();
if (imapGroup && !imapGroup->GetAllGrandChildrenDiscovered())
{
m_expandingIMAPGroup = imapGroup;
MSG_IMAPHost *imapHost = m_host->GetIMAPHost();
if (imapHost)
{
char *groupname = imapGroup->GetFullName();
if (groupname)
{
char * url = CreateImapLevelChildDiscoveryUrl(imapHost->GetHostName(), groupname, imapGroup->GetHierarchySeparator(), 2);
if (url)
{
MSG_UrlQueue::AddUrlToPane(url, NULL, this);
XP_FREE(url);
}
delete groupname;
}
}
}
}
}
// Tell the FE to redraw the expand/collapse widget of the parent group
StartingUpdate(MSG_NotifyChanged, line, 1);
EndingUpdate(MSG_NotifyChanged, line, 1);
}
void
MSG_SubscribePane::IMAPChildDiscoverySuccessful()
{
if (m_expandingIMAPGroup)
{
m_expandingIMAPGroup->SetAllGrandChildrenDiscovered(TRUE);
m_expandingIMAPGroup = NULL;
}
}
int32
MSG_SubscribePane::ExpansionDelta(MSG_ViewIndex line)
{
int32 result = 0;
XP_ASSERT(line != MSG_VIEWINDEXNONE && line < m_groupView.GetSize());
if (line == MSG_VIEWINDEXNONE || line >= m_groupView.GetSize()) return 0;
XP_ASSERT(m_mode == MSG_SubscribeAll);
if (m_mode != MSG_SubscribeAll) return 0;
msg_SubscribeLine* info = m_groupView[line];
int depth = info->GetDepth();
if (line < m_groupView.GetSize() - 1 &&
(m_groupView[line+1]->GetDepth() > depth)) {
// OK, we are already expanded. So, count how many lines after the
// given one that have a depth bigger than the given line; that's how
// many lines we would nuke.
int32 start = line + 1;
int32 end;
for (end=start ; end<m_groupView.GetSize() ; end++) {
if (m_groupView[end]->GetDepth() <= depth) break;
}
result = - (end - start);
} else {
// We are not expanded, so count how many to expand, if any.
if (info->CanExpand()) {
msg_GroupRecord* group = info->GetGroup();
XP_ASSERT(group);
if (group) {
result = GetKidsArray(group, NULL, info->GetDepth() + 1);
}
}
}
return result;
}
int32
MSG_SubscribePane::GetNumLines()
{
return m_groupView.GetSize();
}
msg_GroupRecord*
MSG_SubscribePane::FindRealDescendent(msg_GroupRecord* group)
{
while (group && group->GetChildren()) {
group = group->GetChildren();
}
return group;
}
int32
MSG_SubscribePane::GetKidsArray(msg_GroupRecord* group,
msg_SubscribeLineArray* kids,
int depth)
{
msg_GroupRecord* child;
int32 result = 0;
int32 initsize = 0;
if (kids) initsize = kids->GetSize();
for (child = group->GetChildren(); child; child = child->GetSibling()) {
msg_SubscribeLine* info = NULL;
int32 numkids = child->GetNumKids();
if (child->IsGroup() && (child->IsIMAPGroupRecord() ?
(numkids == 0) : TRUE))
{
if (kids) {
info = new msg_SubscribeLine(child, depth,
WasSubscribed(child), 0);
kids->Add(info);
}
result++;
}
if (numkids > 0 /*&& !child->IsCategoryContainer() */ ) {
if ((numkids == 1) && !group->IsIMAPGroupRecord()) {
// If there's only one real group inside, then just go grab
// that one group, rather than wasting space by making a
// container for it.
msg_GroupRecord* tmp = FindRealDescendent(child);
if (kids) {
info = new
msg_SubscribeLine(tmp, depth,
WasSubscribed(tmp), 0);
kids->Add(info);
}
result++;
} else {
if (kids) {
info =
new msg_SubscribeLine(child, depth,
WasSubscribed(child),
child->GetNumKids());
kids->Add(info);
}
result++;
if (child->IsExpanded()) {
result += GetKidsArray(child, kids, depth + 1);
}
}
}
#ifdef NOTDEF
// I wish the below worked, but right now it turns out we can have
// some empty container groups. Sigh. ###
XP_ASSERT(kids == NULL || info != NULL); // We had to have added
// something or another...
#endif
}
XP_ASSERT(depth == 0 || result > 0); // We should never try to get any
// subnewsgroups unless there actually
// are some.
XP_ASSERT(kids == NULL || result + initsize == kids->GetSize());
return result;
}
MsgERR
MSG_SubscribePane::ToggleSubscribed(MSG_ViewIndex* indices, int32 numIndices)
{
if (!m_host) return eUNKNOWN;
for (int32 i=0 ; i<numIndices ; i++) {
MSG_ViewIndex line = indices[i];
XP_ASSERT(line != MSG_VIEWINDEXNONE && line < m_groupView.GetSize());
if (line == MSG_VIEWINDEXNONE || line >= m_groupView.GetSize()) {
continue;
}
msg_SubscribeLine* info = m_groupView[line];
msg_GroupRecord* group = info->GetGroup();
char *fullname = group->GetFullName();
if (!fullname)
{
return eOUT_OF_MEMORY;
}
ChangeSubscribe key;
key.groupname = fullname;
key.host = m_host;
ChangeSubscribe* tmp = (ChangeSubscribe*)
XP_Gethash(m_subscribeHash, &key, NULL);
if (!tmp) {
tmp = new ChangeSubscribe;
if (!tmp) return eOUT_OF_MEMORY;
if (m_endSubscribeList) {
m_endSubscribeList->next = tmp;
} else {
m_subscribeList = tmp;
}
m_endSubscribeList = tmp;
tmp->host = m_host;
tmp->groupname = fullname;
tmp->next = NULL;
XP_Puthash(m_subscribeHash, tmp, tmp);
} else {
XP_ASSERT(XP_STRCMP(tmp->groupname, fullname) == 0);
delete [] fullname;
}
XP_ASSERT(tmp->host == m_host);
tmp->subscribe = !info->GetSubscribed();
StartingUpdate(MSG_NotifyChanged, line, 1);
info->SetSubscribed(tmp->subscribe);
EndingUpdate(MSG_NotifyChanged, line, 1);
}
return eSUCCESS;
}
MsgERR
MSG_SubscribePane::SetSubscribed(MSG_ViewIndex* indices, int32 numIndices, XP_Bool subscribed)
{
if (!m_host) return eUNKNOWN;
for (int32 i=0 ; i<numIndices ; i++) {
MSG_ViewIndex line = indices[i];
XP_ASSERT(line != MSG_VIEWINDEXNONE && line < m_groupView.GetSize());
if (line == MSG_VIEWINDEXNONE || line >= m_groupView.GetSize()) {
continue;
}
msg_SubscribeLine* info = m_groupView[line];
if (info->GetSubscribed() != subscribed)
{
msg_GroupRecord* group = info->GetGroup();
char *fullname = group->GetFullName();
if (!fullname)
{
return eOUT_OF_MEMORY;
}
ChangeSubscribe key;
key.groupname = fullname;
key.host = m_host;
ChangeSubscribe* tmp = (ChangeSubscribe*)
XP_Gethash(m_subscribeHash, &key, NULL);
if (!tmp) {
tmp = new ChangeSubscribe;
if (!tmp) return eOUT_OF_MEMORY;
if (m_endSubscribeList) {
m_endSubscribeList->next = tmp;
} else {
m_subscribeList = tmp;
}
m_endSubscribeList = tmp;
tmp->host = m_host;
tmp->groupname = fullname;
tmp->next = NULL;
XP_Puthash(m_subscribeHash, tmp, tmp);
} else {
XP_ASSERT(XP_STRCMP(tmp->groupname, fullname) == 0);
delete [] fullname;
}
XP_ASSERT(tmp->host == m_host);
tmp->subscribe = subscribed;
StartingUpdate(MSG_NotifyChanged, line, 1);
info->SetSubscribed(tmp->subscribe);
EndingUpdate(MSG_NotifyChanged, line, 1);
}
}
return eSUCCESS;
}
MsgERR
MSG_SubscribePane::ExpandAll(MSG_ViewIndex* indices, int32 numIndices)
{
XP_ASSERT(m_host->IsNews());
if (!m_host->IsNews())
return 0;
// since the FE might have given us a pointer to their real selection (the
// WinFE does this), make a copy of the array so the array doesn't change
// out from under us when we call EndingUpdate
MSG_ViewIndex *tmpIndices = new MSG_ViewIndex[numIndices];
if (NULL == tmpIndices) {
return eOUT_OF_MEMORY;
}
XP_MEMCPY(tmpIndices, indices, sizeof(MSG_ViewIndex) * numIndices);
// since the FE could have constructed the list of indices in any order
// (e.g. order of discontiguous selection), we have to sort the indices so
// that we can expand the last one first (so we won't screw up any of the
// other indices.
if (numIndices > 1) {
XP_QSORT(tmpIndices, numIndices, sizeof(MSG_ViewIndex),
MSG_LinedPane::CompareViewIndices);
}
for (int32 i=numIndices-1 ; i>=0 ; i--) {
int32 n = ExpansionDelta(tmpIndices[i]);
if (n > 0) {
int32 m;
DoToggleExpansion(tmpIndices[i], &m);
XP_ASSERT(m == n);
for (MSG_ViewIndex l = tmpIndices[i] + m ; l>tmpIndices[i] ; l--) {
ExpandAll(&l, 1);
}
}
}
delete [] tmpIndices;
return 0;
}
MsgERR
MSG_SubscribePane::CollapseAll()
{
for (int32 i=m_groupView.GetSize() - 2 ; i>=0 ; i--) {
if (m_groupView[i]->GetDepth() < m_groupView[i+1]->GetDepth()) {
DoToggleExpansion(MSG_ViewIndex(i), NULL);
}
}
return 0;
}
MsgERR
MSG_SubscribePane::ClearNew()
{
if (!m_host) return eUNKNOWN;
if (!m_host->IsNews()) return eUNKNOWN; // only works for news
XP_ASSERT(m_mode == MSG_SubscribeNew);
MSG_NewsHost *newsHost = m_host->GetNewsHost();
if (newsHost)
newsHost->ClearNew();
else
return eUNKNOWN;
SetMode(MSG_SubscribeNew, TRUE);
return eSUCCESS;
}
void
MSG_SubscribePane::CheckForNewDone(URL_Struct* url_struct, int status,
MWContext* context)
{
if (!m_host) return;
if (!m_host->IsNews()) return;
MSG_NewsHost *newsHost = (MSG_NewsHost *)m_host;
MSG_Pane::CheckForNewDone(url_struct, status, context);
if (m_mode == MSG_SubscribeAll) {
if (status >= 0) {
newsHost->ClearNew();
newsHost->SaveHostInfo();
} else {
newsHost->Inhale(TRUE);
}
}
SetMode(m_mode, TRUE, FALSE);
if (m_callbacks.FetchCompleted) {
(*m_callbacks.FetchCompleted)(this, m_callbackclosure);
}
}
void
MSG_SubscribePane::ReportIMAPFolderDiscoveryFinished()
{
if (m_callbacks.FetchCompleted) {
(*m_callbacks.FetchCompleted)(this, m_callbackclosure);
}
}
void MSG_SubscribePane::ClearAndFreeIMAPSubscribedList()
{
char *subscribedName = NULL;
for (int j = 0; j < m_imapSubscribedList->GetSize(); j++)
{
subscribedName = (char *)(m_imapSubscribedList->GetAt(j));
XP_ASSERT (subscribedName);
delete subscribedName;
m_imapSubscribedList->RemoveAt(j);
}
}
void MSG_SubscribePane::ClearAndFreeIMAPGroupList()
{
delete m_imapTree; // deleting the root will delete all its children
XP_MapRemhash(m_imapGroupHash, imap_freehashkeys, NULL); // free the keys in the hash table
XP_Clrhash(m_imapGroupHash); // clear all the entries from the hash table
m_imapTree = msg_IMAPGroupRecord::Create(NULL, NULL, 0, FALSE); // recreate a new root
}
msg_IMAPGroupRecord *MSG_SubscribePane::FindParentRecordOfIMAPGroup(const char *folderName, char delimiter)
{
// look for this group's parent
char *parentName = XP_STRDUP(folderName);
if (!parentName)
return 0;
char *lastSlash = XP_STRRCHR(parentName, delimiter);
msg_IMAPGroupRecord *parentRecord = NULL;
if (lastSlash)
{
*lastSlash = 0;
parentRecord = (msg_IMAPGroupRecord *)(XP_Gethash(m_imapGroupHash, parentName, NULL));
}
XP_FREEIF(parentName);
return parentRecord;
}
// returns TRUE if we explicitly need to list this folder's children
// -- used only for top-level folders
// (NthLevelDiscovery is used for all other folders - easier and faster)
//
// filledInGroup is TRUE if we (the client) made up this group to act as a placeholder
// as a parent of a child which we have discovered first
XP_Bool MSG_SubscribePane::AddIMAPGroupToList(const char *folderName, char delimiter, XP_Bool isSubscribed,
uint32 folder_flags, XP_Bool filledInGroup /* = FALSE */)
{
XP_Bool needChildrenListed = FALSE;
// storage for ourFolderName is owned by the hash table m_imapGroupHash, as the key
char *ourFolderName = XP_STRDUP(folderName);
if (!ourFolderName)
return 0;
msg_IMAPGroupRecord *parentRecord = FindParentRecordOfIMAPGroup(ourFolderName, delimiter);
if (!parentRecord)
{
char *maybeParentName = XP_STRDUP(ourFolderName);
if (maybeParentName)
{
char *where = XP_STRRCHR(maybeParentName, delimiter);
if (where)
*where = 0;
if (where && *maybeParentName)
{
AddIMAPGroupToList(maybeParentName, delimiter, FALSE, 0, TRUE);
parentRecord = FindParentRecordOfIMAPGroup(ourFolderName, delimiter);
}
if (!parentRecord)
{
parentRecord = m_imapTree;
needChildrenListed = TRUE;
}
XP_FREE(maybeParentName);
}
}
if (isSubscribed)
{
// add it to the subscribe hash list - it should disallow duplicates automatically
char *subscribeFolderName = new char[XP_STRLEN(ourFolderName) + 1];
if (subscribeFolderName)
XP_STRCPY(subscribeFolderName, ourFolderName);
if (subscribeFolderName)
m_imapSubscribedList->Add(subscribeFolderName);
}
// should return TRUE if we've ever put this into the list
isSubscribed = (m_imapSubscribedList->FindIndex(0, ourFolderName) != -1);
msg_IMAPGroupRecord *lookedUpRecord = NULL;
if (!(lookedUpRecord = (msg_IMAPGroupRecord *)(XP_Gethash(m_imapGroupHash, ourFolderName, NULL))))
{
msg_IMAPGroupRecord *record = msg_IMAPGroupRecord::Create(parentRecord, ourFolderName, delimiter, filledInGroup);
if (record)
{
// set flags for the record
record->SetFlags(folder_flags);
// add to the list of known IMAP groups
XP_Puthash(m_imapGroupHash, ourFolderName, record);
// there's a parent, so add as a child if it is visible
// (or if the parent is the root)
msg_SubscribeLine *parentLine = NULL;
MSG_ViewIndex parentLineIndex = FindGroupViewIndex(parentRecord);
if (parentLineIndex != MSG_VIEWINDEXNONE)
parentLine = m_groupView[parentLineIndex];
if (parentLine || (parentRecord == m_imapTree))
{
if (parentLine)
parentLine->AddNewSubGroup();
if ((parentRecord == m_imapTree) ||
parentRecord->IsExpanded())
{
msg_IMAPGroupRecord *nextRecord = (msg_IMAPGroupRecord *)(record->GetSiblingOrAncestorSibling());
MSG_ViewIndex whereToInsert = MSG_VIEWINDEXNONE;
if (!nextRecord)
{
whereToInsert = m_groupView.GetSize();
}
else
{
whereToInsert = FindGroupViewIndex(nextRecord);
}
int16 parentDepth = parentRecord->GetDepth();
if (parentRecord == m_imapTree)
parentDepth = -1;
XP_Bool latestSubscribed = isSubscribed;
// see if we had already updated the state
// but it is uncommitted
ChangeSubscribe key;
key.groupname = ourFolderName;
key.host = m_host;
ChangeSubscribe* tmp = (ChangeSubscribe*)
XP_Gethash(m_subscribeHash, &key, NULL);
if (tmp) {
// If it was in the ChangeSubscribe list,
// then set the subscribe bit to what we had previously
// set it to.
latestSubscribed = tmp->subscribe;
}
// create the line
msg_SubscribeLine *childLine = new msg_SubscribeLine(record,
parentDepth+1, latestSubscribed, 0);
StartingUpdate(MSG_NotifyInsertOrDelete, whereToInsert, 1);
m_groupView.InsertAt(whereToInsert, childLine);
EndingUpdate(MSG_NotifyInsertOrDelete, whereToInsert, 1);
}
else
{
// make sure that there's a twisty
if (parentLineIndex != MSG_VIEWINDEXNONE)
{
StartingUpdate(MSG_NotifyChanged, parentLineIndex, 1);
EndingUpdate(MSG_NotifyChanged, parentLineIndex, 1);
}
}
}
else
{
// don't need to do anything, right? The parent isn't visible in
// the pane, and it's not a top-level folder (parent is root),
// so therefore the child can't be visible
}
return needChildrenListed;
}
else
return FALSE;
}
else
{
if (lookedUpRecord->GetIsGroupFilledIn())
{
// the record already existed in the hash table.
// we should update its state:
lookedUpRecord->SetIsGroupFilledIn(FALSE);
lookedUpRecord->SetHierarchySeparator(delimiter);
lookedUpRecord->SetFlags(folder_flags);
// update the line
msg_SubscribeLine *thisLine = NULL;
MSG_ViewIndex thisLineIndex = FindGroupViewIndex(lookedUpRecord);
if (thisLineIndex != MSG_VIEWINDEXNONE)
thisLine = m_groupView[thisLineIndex];
if (thisLine)
{
if (!thisLine->GetSubscribed())
thisLine->SetSubscribed(isSubscribed);
if (thisLineIndex != MSG_VIEWINDEXNONE)
{
StartingUpdate(MSG_NotifyChanged, thisLineIndex, 1);
EndingUpdate(MSG_NotifyChanged, thisLineIndex, 1);
}
}
}
FREEIF(ourFolderName);
// We might need its children
return FALSE;
}
}
MsgERR
MSG_SubscribePane::FetchGroupList()
{
if (!m_host) return eUNKNOWN;
MSG_NewsHost *newsHost = m_host->GetNewsHost();
if (newsHost)
{
StartingUpdate(MSG_NotifyAll, 0, 0);
m_groupView.RemoveAll();
EndingUpdate(MSG_NotifyAll, 0, 0);
XP_ASSERT(newsHost);
newsHost->Exhale();
newsHost->EmptyInhale();
newsHost->setLastUpdate(0); // Causes us to reload everything.
return CheckForNew(newsHost);
}
else if (m_host->IsIMAP())
{
// For IMAP, this means to clear our list and perform a LIST of
// the top-level folders again.
StartingUpdate(MSG_NotifyAll, 0, 0);
// do we need to delete the storage?
m_groupView.RemoveAll();
EndingUpdate(MSG_NotifyAll, 0, 0);
ClearAndFreeIMAPGroupList();
ClearAndFreeIMAPSubscribedList();
MSG_IMAPHost *imapHost = m_host->GetIMAPHost();
if (!imapHost)
return eUNKNOWN;
char * url = CreateImapAllAndSubscribedMailboxDiscoveryUrl(imapHost->GetHostName());
if (url)
{
MSG_UrlQueue::AddUrlToPane(url, NULL, this);
XP_FREE(url);
}
return eSUCCESS;
}
else
{
// not a news or IMAP host
XP_ASSERT(0);
return eUNKNOWN;
}
}
XP_Bool
MSG_SubscribePane::AddGroupsAsNew()
{
return (m_mode != MSG_SubscribeAll);
}
MsgERR
MSG_SubscribePane::DoCommand(MSG_CommandType command, MSG_ViewIndex* indices,
int32 numIndices)
{
MsgERR status = 0;
switch (command) {
case MSG_ToggleSubscribed:
status = ToggleSubscribed(indices, numIndices);
break;
case MSG_SetSubscribed:
status = SetSubscribed(indices, numIndices, TRUE);
break;
case MSG_ClearSubscribed:
status = SetSubscribed(indices, numIndices, FALSE);
break;
case MSG_FetchGroupList:
status = FetchGroupList();
break;
case MSG_ExpandAll:
status = ExpandAll(indices, numIndices);
UpdateCounts();
break;
case MSG_CollapseAll:
status = CollapseAll();
UpdateCounts();
break;
case MSG_ClearNew:
status = ClearNew();
UpdateCounts();
break;
case MSG_CheckForNew:
if (m_host && m_host->IsNews())
{
MSG_NewsHost *newsHost = m_host->GetNewsHost();
status = newsHost ? CheckForNew(newsHost) : eUNKNOWN;
}
break;
case MSG_UpdateMessageCount:
UpdateCounts();
break;
default:
status = MSG_LinedPane::DoCommand(command, indices, numIndices);
break;
}
if (status == MK_OFFLINE)
{
FE_Alert(GetContext(), XP_GetString(XP_ALERT_OFFLINE_MODE_SELECTED));
status = 0;
}
return status;
}
MsgERR
MSG_SubscribePane::GetCommandStatus(MSG_CommandType command,
const MSG_ViewIndex* indices,
int32 numindices,
XP_Bool *selectable_pP,
MSG_COMMAND_CHECK_STATE *selected_pP,
const char **display_stringP,
XP_Bool *plural_pP)
{
// ###tw This never returns a display_string, right now. If someone
// actually needs it, I'll be glad to add it; but I suspect all the FE's
// are going to get these strings their own way, since these are all
// dialog box buttons and not menu items.
const char *display_string = 0;
XP_Bool plural_p = FALSE;
XP_Bool selectable_p = TRUE;
XP_Bool selected_p = FALSE;
XP_Bool selected_used_p = FALSE;
int32 i;
switch (command) {
case MSG_ToggleSubscribed:
case MSG_SetSubscribed:
case MSG_ClearSubscribed:
if (m_host && m_host->IsIMAP())
selectable_p = TRUE;
else
{
for (i=0 ; i<numindices ; i++)
{
if (!m_groupView[i]->CanExpand())
{
selectable_p = TRUE;
break;
}
}
}
break;
case MSG_FetchGroupList:
selectable_p = (m_mode == MSG_SubscribeAll);
break;
case MSG_ExpandAll:
if (m_host && m_host->IsIMAP())
{
selectable_p = FALSE;
break;
}
case MSG_CollapseAll:
if (m_host)
{
if (m_host->IsNews())
{
// only allow expand all for News
for (i=0 ; i<numindices ; i++) {
if (m_groupView[i]->CanExpand()) {
selectable_p = TRUE;
break;
}
}
}
else
selectable_p = TRUE;
}
break;
case MSG_ClearNew:
case MSG_CheckForNew:
selectable_p = (m_host && m_host->IsNews() && (m_mode == MSG_SubscribeNew));
break;
default:
return MSG_Pane::GetCommandStatus(command, indices, numindices,
selectable_pP, selected_pP,
display_stringP, plural_pP);
}
if (selectable_pP) *selectable_pP = selectable_p;
if (selected_pP) {
if (selected_used_p) {
if (selected_p) {
*selected_pP = MSG_Checked;
} else {
*selected_pP = MSG_Unchecked;
}
} else {
*selected_pP = MSG_NotUsed;
}
}
if (display_stringP) *display_stringP = display_string;
if (plural_pP) *plural_pP = plural_p;
return 0;
}
int
MSG_SubscribePane::SetCallbacks(MSG_SubscribeCallbacks* callbacks,
void* closure)
{
m_callbacks = *callbacks;
m_callbackclosure = closure;
return SetMode(m_mode, TRUE);
}
int
MSG_SubscribePane::Cancel()
{
if (m_master->GetUpgradingToIMAPSubscription())
{
m_master->SetUpgradingToIMAPSubscription(FALSE);
}
ChangeSubscribe* tmp = m_subscribeList;
while (tmp) {
ChangeSubscribe* next = tmp->next;
delete [] tmp->groupname;
tmp->groupname = NULL;
tmp->next = NULL;
delete tmp;
tmp = next;
}
m_subscribeList = NULL;
XP_Clrhash(m_subscribeHash);
return 0;
}
MSG_Host*
MSG_SubscribePane::GetHost()
{
return m_host;
}
int
MSG_SubscribePane::SetHost(MSG_Host* host)
{
int status = 0;
if (host != m_host) {
if (m_host) {
MSG_NewsHost *newsHost = m_host->GetNewsHost();
if (newsHost)
status = newsHost->Exhale();
if (status < 0) return status;
}
m_host = host;
if (m_host) {
MSG_NewsHost *newsHost = m_host->GetNewsHost();
if (newsHost)
status = newsHost->Inhale();
if (status < 0) return status;
}
if (m_host && m_host->IsNews())
{
return SetMode(m_mode, TRUE);
}
else
{
// IMAP only allows subscribe, not search or new
return SetMode(MSG_SubscribeAll, TRUE);
}
}
return 0;
}
MSG_SubscribeMode
MSG_SubscribePane::GetMode()
{
return m_mode;
}
static int
CompareAddTimes(const void* e1, const void* e2)
{
msg_GroupRecord* g1 = (*((msg_SubscribeLine**) e1))->GetGroup();
msg_GroupRecord* g2 = (*((msg_SubscribeLine**) e2))->GetGroup();
int delta = int(int32(g2->GetAddTime()) - int32(g1->GetAddTime()));
if (delta) return delta;
XP_ASSERT(e1 != e2);
if (e1 == e2) return 0;
// Oh, boy. These two newsgroups seemed to have been added at the same
// time. We should display them in alphabetical order. But we don't
// want to just grab their fullnames, because that's pretty expensive and
// qsort compare routines should be very fast. So, we painfully compare
// their names, step by step.
// First, we find a common ancestor.
int d1 = g1->GetDepth();
int d2 = g2->GetDepth();
msg_GroupRecord* origg1 = g1;
while (d1 > d2) {
g1 = g1->GetParent();
d1--;
}
while (d2 > d1) {
g2 = g2->GetParent();
d2--;
}
if (g1 == g2) {
// This can happen only if the initial depths weren't the same, and
// one group is in fact an ancestor of the other. In that case,
// the ancestor comes first.
if (g1 == origg1) return -1;
else return 1;
}
while (g1->GetParent() != g2->GetParent()) {
g1 = g1->GetParent();
g2 = g2->GetParent();
}
return XP_STRCMP(g1->GetPartName(), g2->GetPartName());
}
int
MSG_SubscribePane::SetMode(MSG_SubscribeMode mode, XP_Bool force,
XP_Bool autofetch)
{
time_t first;
if (!force && mode == m_mode) return 0;
InterruptContext(FALSE);
StartingUpdate(MSG_NotifyAll, 0, 0);
for (int32 i=0 ; i<m_groupView.GetSize() ; i++) {
delete m_groupView[i];
m_groupView[i] = NULL;
}
m_groupView.RemoveAll();
MSG_NewsHost *newsHost = m_host ? m_host->GetNewsHost() : 0;
int32 lasttime = newsHost ? newsHost->getLastUpdate() : 0;
if (m_host) {
m_mode = mode;
switch(m_mode) {
case MSG_SubscribeAll:
if ((lasttime > 0) && newsHost) {
GetKidsArray(newsHost->GetGroupTree(), &m_groupView, 0);
}
break;
case MSG_SubscribeSearch:
XP_ASSERT(newsHost);
if (newsHost)
FindAll(m_lastSearch);
break;
case MSG_SubscribeNew:
XP_ASSERT(newsHost);
if (newsHost)
{
first = newsHost->GetFirstNewDate();
msg_GroupRecord* child;
for (child = newsHost->GetGroupTree()->GetChildren();
child;
child = child->GetNextAlphabeticNoCategories()) {
if (child->IsGroup() && child->GetAddTime() >= first) {
msg_SubscribeLine* info =
new msg_SubscribeLine(child, 0, WasSubscribed(child),
0);
if (info) m_groupView.Add(info);
}
}
m_groupView.QuickSort(CompareAddTimes);
}
break;
default:
XP_ASSERT(0);
break;
}
}
EndingUpdate(MSG_NotifyAll, 0, 0);
UpdateCounts();
if (autofetch && m_host && lasttime == 0) {
if (m_mode == MSG_SubscribeAll) {
if (m_callbacks.DoFetchGroups) {
(*m_callbacks.DoFetchGroups)(this, m_callbackclosure);
}
} else {
FE_Alert(GetContext(),
XP_GetString(MK_MSG_INCOMPLETE_NEWSGROUP_LIST));
}
}
return 0;
}
MSG_ViewIndex MSG_SubscribePane::FindGroupViewIndex(msg_GroupRecord* group)
{
if (!m_host) return MSG_VIEWINDEXNONE;
XP_ASSERT(group);
if (!group) return MSG_VIEWINDEXNONE;
MSG_ViewIndex result;
for (result = 0 ; result < m_groupView.GetSize() ; result++) {
if (m_groupView[result]->GetGroup() == group) {
return result;
}
}
return MSG_VIEWINDEXNONE;
}
// only NNTP
MSG_ViewIndex
MSG_SubscribePane::FindGroupExpandIfNecessary(msg_GroupRecord* group)
{
if (!m_host) return MSG_VIEWINDEXNONE;
MSG_NewsHost *newsHost = m_host->GetNewsHost();
XP_ASSERT(newsHost);
if (!newsHost) return MSG_VIEWINDEXNONE;
XP_ASSERT(group && group != newsHost->GetGroupTree());
if (!group || group == newsHost->GetGroupTree()) return MSG_VIEWINDEXNONE;
msg_GroupRecord* parent = group->GetParent();
if (!group->IsGroup() && group->GetNumKids() == 1) {
// This group has exactly one group inside of it, and that will be
// represented by one line. So we need to be searching for that line.
// But if the search fails, then we need to expand the original parent.
group = FindRealDescendent(group);
}
MSG_ViewIndex result;
for (result = 0 ; result < m_groupView.GetSize() ; result++) {
if (m_groupView[result]->GetGroup() == group) {
return result;
}
}
// Hmm. The group must be missing because an ancestor is closed.
// Find that ancestor and expand it.
result = FindGroupExpandIfNecessary(parent);
XP_ASSERT(result != MSG_VIEWINDEXNONE);
if (result == MSG_VIEWINDEXNONE) return result;
if (ExpansionDelta(result) > 0) {
DoToggleExpansion(result, NULL);
} else if (result < m_groupView.GetSize() - 1 &&
m_groupView[result+1]->GetGroup() == parent) {
if (ExpansionDelta(result + 1) > 0) {
DoToggleExpansion(result + 1, NULL);
}
}
for (; result < m_groupView.GetSize() ; result++) {
if (m_groupView[result]->GetGroup() == group) {
return result;
}
}
return MSG_VIEWINDEXNONE;
}
// only NNTP
MSG_ViewIndex
MSG_SubscribePane::FindFirst(const char* str)
{
XP_ASSERT(str);
if (!str || !*str) return MSG_VIEWINDEXNONE;
XP_ASSERT(m_mode == MSG_SubscribeAll);
if (m_mode != MSG_SubscribeAll) return MSG_VIEWINDEXNONE;
if (!m_host) return MSG_VIEWINDEXNONE;
MSG_NewsHost *newsHost = m_host->GetNewsHost();
XP_ASSERT(newsHost);
if (!newsHost || newsHost->getLastUpdate() == 0) return MSG_VIEWINDEXNONE;
msg_GroupRecord* parent = newsHost->GetGroupTree();
MSG_ViewIndex result = MSG_VIEWINDEXNONE;
char* ptr = NULL;
while (*str) {
ptr = XP_STRCHR(str, '.');
if (ptr) *ptr = '\0';
msg_GroupRecord* child = NULL;
/*if (!parent->IsCategoryContainer()) */ {
for (child = parent->GetChildren();
child;
child = child->GetSibling()) {
if (XP_STRCMP(child->GetPartName(), str) >= 0) break;
}
}
if (!child) break;
parent = child;
if (XP_STRCMP(child->GetPartName(), str) != 0) {
// This is not an exact match. Ignore any other parts of the
// input string.
break;
}
if (ptr) {
*ptr = '.';
str = ptr + 1;
} else {
break;
}
}
if (ptr) *ptr = '.';
XP_ASSERT(parent);
if (!parent || parent == newsHost->GetGroupTree()) return MSG_VIEWINDEXNONE;
result = FindGroupExpandIfNecessary(parent);
UpdateCounts();
return result;
}
// only NNTP
int
MSG_SubscribePane::AddSearchResult(msg_GroupRecord* child)
{
if (!child->IsGroup()) return 0;
msg_SubscribeLine* line =
new msg_SubscribeLine(child, 0, WasSubscribed(child), 0);
if (!line) return MK_OUT_OF_MEMORY;
int size = m_groupView.GetSize();
StartingUpdate(MSG_NotifyInsertOrDelete, size, 1);
m_groupView.InsertAt(size, line);
EndingUpdate(MSG_NotifyInsertOrDelete, size, 1);
return 0;
}
// only NNTP
int
MSG_SubscribePane::FindAll(const char* str)
{
XP_ASSERT(m_mode == MSG_SubscribeSearch);
if (m_mode != MSG_SubscribeSearch) return -1;
if (!m_host) return 0;
XP_ASSERT(m_host->IsNews());
MSG_NewsHost *newsHost = m_host->GetNewsHost();
if (!newsHost || newsHost->getLastUpdate() == 0) return 0;
StartingUpdate(MSG_NotifyAll, 0, 0);
m_groupView.RemoveAll();
EndingUpdate(MSG_NotifyAll, 0, 0);
if (str == NULL || *str == '\0') return 0;
msg_GroupRecord* child;
if (XP_STRCHR(str, '.') == NULL) {
// There are no dots in the search string, so we can just search the
// part names of each children.
for (child = newsHost->GetGroupTree()->GetChildren();
child ;
child = child->GetNextAlphabeticNoCategories()) {
if (XP_STRCASESTR(child->GetPartName(), str)) {
msg_GroupRecord* done = child->GetSiblingOrAncestorSibling();
for (;;) {
AddSearchResult(child);
msg_GroupRecord* next =
child->GetNextAlphabeticNoCategories();
if (next == done) break;
child = next;
}
} else {
const char* pretty = child->GetPrettyName();
if (pretty && XP_STRCASESTR(pretty, str)) {
AddSearchResult(child);
}
}
}
} else {
// There are dots in the search string, so we have to painfully grab
// the full name of every group to see if it matches. This can
// still be optimized, but it's harder, so I don't right now. ###tw
for (child = newsHost->GetGroupTree()->GetChildren();
child ;
child = child->GetNextAlphabeticNoCategories()) {
if (child->IsGroup()) {
char* fullname = child->GetFullName();
if (!fullname) return MK_OUT_OF_MEMORY;
if (XP_STRCASESTR(fullname, str)) {
AddSearchResult(child);
} else {
const char* pretty = child->GetPrettyName();
if (pretty && XP_STRCASESTR(pretty, str)) {
AddSearchResult(child);
}
}
delete [] fullname;
}
}
}
if (m_groupView.GetSize() == 0) {
FE_Alert(GetContext(), XP_GetString(MK_MSG_SEARCH_FAILED));
}
return 0;
}
XP_Bool
MSG_SubscribePane::GetGroupNameLineByIndex(MSG_ViewIndex firstline,
int32 numlines,
MSG_GroupNameLine* data)
{
if (!m_host || firstline == MSG_VIEWINDEXNONE ||
firstline + numlines > m_groupView.GetSize() ||
numlines < 0) return FALSE;
int32 i;
MSG_GroupNameLine* line;
for (i=0, line=data ; i<numlines ; i++, line++) {
msg_SubscribeLine* info = m_groupView[firstline + i];
msg_GroupRecord *group = info->GetGroup();
XP_ASSERT(group);
if (!group) return FALSE;
const char *pretty = group->GetPrettyName();
if (m_host->IsNews())
{
char *tmp = group->GetFullName();
if (!tmp) return FALSE; // Out of memory.
XP_STRNCPY_SAFE(line->name, tmp, sizeof(line->name));
delete [] tmp;
}
else
{
// IMAP - don't display the whole path
const char *partname = group->GetPartName();
if (!partname) return FALSE;
XP_STRNCPY_SAFE(line->name, partname, sizeof(line->name));
}
line->level = info->GetDepth();
line->total = info->GetNumMessages();
line->flags = 0;
MSG_NewsHost *newsHost = m_host->GetNewsHost();
if (newsHost && group->GetAddTime() > newsHost->GetFirstNewDate()) {
line->flags |= MSG_GROUPNAME_FLAG_NEW_GROUP;
}
if (info->CanExpand()) {
int length = XP_STRLEN(line->name);
if (m_host->IsNews())
{
PR_snprintf(line->name + length, sizeof(line->name) - length - 1,
".* (%ld groups)", info->GetNumSubGroups());
// ###tw I18N the above string. (Of course, it wasn't i18n in
// 3.0, either.)
}
else
{
int32 numSubGroups = info->GetNumSubGroups();
char *subfolderString = numSubGroups == 1 ?
"subfolder" : "subfolders";
PR_snprintf(line->name + length, sizeof(line->name) - length - 1,
".* (%ld %s)", numSubGroups, subfolderString);
// ###tw I18N the above string. (Of course, it wasn't i18n in
// 3.0, either.)
}
line->flags |= MSG_GROUPNAME_FLAG_HASCHILDREN;
if (firstline + i >= m_groupView.GetSize() - 1 ||
m_groupView[firstline + i + 1]->GetDepth() <= line->level) {
line->flags |= MSG_GROUPNAME_FLAG_ELIDED;
}
} else if (newsHost && pretty) {
int length = XP_STRLEN(line->name);
PR_snprintf(line->name + length, sizeof(line->name) - length - 1,
" (%s)", pretty);
}
if (info->GetSubscribed()) {
line->flags |= MSG_GROUPNAME_FLAG_SUBSCRIBED;
}
// set the folder type flags (IMAP public, IMAP personal, etc.)
msg_IMAPGroupRecord *imapGroup = group->GetIMAPGroupRecord();
if (imapGroup)
line->flags |= imapGroup->GetFlags();
}
return TRUE;
}
XP_Bool
MSG_SubscribePane::WasSubscribed(msg_GroupRecord* group)
{
char* groupname = group->GetFullName();
if (!groupname || !m_host) return FALSE;
// first look through the updated (uncommitted) subscribe list
ChangeSubscribe key;
key.groupname = groupname;
key.host = m_host;
ChangeSubscribe* tmp = (ChangeSubscribe*)
XP_Gethash(m_subscribeHash, &key, NULL);
if (tmp) {
delete [] groupname;
return tmp->subscribe;
}
// next, if it's IMAP, look through the original subscribed list
// that we first got back from the server
if (group->IsIMAPGroupRecord())
{
XP_Bool wasSubscribed = (m_imapSubscribedList->FindIndex(0, groupname) != -1);
delete [] groupname;
return wasSubscribed;
}
// otherwise, we must not be subscribed
delete [] groupname;
return FALSE;
}
void
MSG_SubscribePane::UpdateCounts()
{
if (m_host && !NET_IsOffline())
{
MSG_NewsHost *newsHost = m_host->GetNewsHost();
if (newsHost)
{
for (int i=0 ; i<m_groupView.GetSize() ; i++) {
msg_SubscribeLine* info = m_groupView[i];
if (info->GetNumMessages() < 0 && info->GetNumSubGroups() == 0) {
// OK, found one, so kick off the URL.
InterruptContext(FALSE);
UpdateNewsCounts(newsHost);
return;
}
}
}
}
}
void
MSG_SubscribePane::UpdateNewsCountsDone(int status)
{
if (status >= 0) {
UpdateCounts();
}
}
int32
MSG_SubscribePane::GetNewsRCCount(MSG_NewsHost* host)
{
XP_ASSERT(host == m_host);
if (host != m_host) return 0;
int num = m_groupView.GetSize();
int32 result = 0;
for (int i=0 ; i<num ; i++) {
msg_SubscribeLine* info = m_groupView[i];
if (info->GetNumMessages() < 0 && info->GetNumSubGroups() == 0) {
result++;
}
}
m_curUpdate = 0;
return result;
}
char*
MSG_SubscribePane::GetNewsRCGroup(MSG_NewsHost* host)
{
XP_ASSERT(host == m_host);
if (host != m_host) return NULL;
int num = m_groupView.GetSize();
if (num <= 0) return NULL;
if (m_curUpdate >= num) m_curUpdate = 0;
int32 i = m_curUpdate;
do {
msg_SubscribeLine* info = m_groupView[i];
if (info->GetNumMessages() < 0 && info->GetNumSubGroups() == 0) {
info->SetNumMessages(0); // so we don't keep returning this one.
msg_GroupRecord* group = info->GetGroup();
XP_ASSERT(group);
if (!group) continue;
char* tmp = group->GetFullName();
char* result = NULL;
if (tmp) {
result = XP_STRDUP(tmp); // ### Ick. malloc vs. new.
delete [] tmp;
}
m_curUpdate = i;
return result;
}
i++;
if (i >= num) i = 0;
} while (i != m_curUpdate);
return NULL;
}
int
MSG_SubscribePane::DisplaySubscribedGroup(MSG_NewsHost* host,
const char *groupname,
int32 /*oldest_message*/,
int32 /*youngest_message*/,
int32 total_messages,
XP_Bool /*nowvisiting*/)
{
XP_ASSERT(host == m_host);
if (host != m_host) return 0;
XP_ASSERT(m_curUpdate >= 0 && m_curUpdate < m_groupView.GetSize());
if (m_curUpdate < 0 || m_curUpdate >= m_groupView.GetSize()) return -1;
msg_SubscribeLine* info = m_groupView[m_curUpdate];
msg_GroupRecord* group = info->GetGroup();
XP_ASSERT(group);
if (!group) return -1;
char* tmp = group->GetFullName();
XP_Bool matches = (XP_STRCMP(groupname, tmp) == 0);
delete [] tmp;
if (matches) {
StartingUpdate(MSG_NotifyChanged, m_curUpdate, 1);
info->SetNumMessages(total_messages);
EndingUpdate(MSG_NotifyChanged, m_curUpdate, 1);
}
return 0;
}
int MSG_SubscribePane::CommitSubscriptions()
{
DisableUpdate();
InterruptContext(FALSE);
ChangeSubscribe* tmp = m_subscribeList;
XP_Bool runningIMAP = FALSE;
while (tmp) {
XP_ASSERT(tmp->groupname);
if (tmp->groupname)
{
if (tmp->host->IsNews())
{
MSG_NewsHost *newsHost = tmp->host->GetNewsHost();
if (tmp->subscribe) {
newsHost->AddGroup(tmp->groupname);
} else {
newsHost->RemoveGroup(tmp->groupname);
}
//delete [] tmp->groupname;
//tmp->groupname = NULL;
}
else if (tmp->host->IsIMAP())
{
MSG_IMAPHost *imapHost = tmp->host->GetIMAPHost();
// here's where we have to issue a subscribe or unsubscribe to the server
if (imapHost)
{
char *imapSubscribeURL = 0;
// whether or not we were originally subscribed to this folder
XP_Bool originallySubscribed = (m_imapSubscribedList->FindIndex(0, tmp->groupname) != -1);
if (tmp->subscribe && !originallySubscribed)
{
imapSubscribeURL = CreateIMAPSubscribeMailboxURL(imapHost->GetHostName(), tmp->groupname);
if (imapHost->GetIsHostUsingSubscription() || m_master->GetUpgradingToIMAPSubscription())
imapHost->SetHostNeedsFolderUpdate(TRUE); // we only need to update the folder view if we're only
// showing subscribed folders
}
else if (!tmp->subscribe && originallySubscribed)
{
imapSubscribeURL = CreateIMAPUnsubscribeMailboxURL(imapHost->GetHostName(), tmp->groupname);
if (imapHost->GetIsHostUsingSubscription() || m_master->GetUpgradingToIMAPSubscription())
imapHost->SetHostNeedsFolderUpdate(TRUE); // we only need to update the folder view if we're only
// showing subscribed folders
}
if (imapSubscribeURL)
{
runningIMAP = TRUE;
MSG_UrlQueue::AddUrlToPane(imapSubscribeURL, NULL, this);
XP_FREE(imapSubscribeURL);
}
}
}
else
{
// not News or IMAP - what is it?
XP_ASSERT(0);
}
}
ChangeSubscribe* next = tmp->next;
//delete tmp;
tmp = next;
}
if (m_master->GetUpgradingToIMAPSubscription())
{
m_master->SetIMAPSubscriptionUpgradedPrefs();
m_master->SetUpgradingToIMAPSubscription(FALSE);
}
if (!runningIMAP)
{
// make sure the FE knows it's ok to shut down the pane
FE_AllConnectionsComplete(GetContext());
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink