gecko-dev/lib/libmsg/msgmpane.cpp

/* -*- 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 "rosetta.h"
#include "msg.h"
#include "errcode.h"
#include "xp_str.h"
#include "xpgetstr.h"

#include "msgmpane.h"
#include "msgtpane.h"
#include "msgfinfo.h"
#include "msgdb.h"
#include "msgdbvw.h"
#include "msgmast.h"
#include "msgprefs.h"
#include "msgsec.h"
#include "mailhdr.h"

#include "msgundmg.h"
#include "msgundac.h"
#include "mime.h"

#include "addrbook.h"

#include "libi18n.h"
#include "newshost.h"
#include "prefapi.h"
#include "maildb.h"
#include "prsembst.h"
#include "listngst.h"
#include "newsdb.h"
#include "intl_csi.h"
#include "msgimap.h"
#include "msgurlq.h"
#include "msgmdn.h"
#include "msgstrob.h"

extern "C" 
{
	extern int MK_MSG_DELETE_MESSAGE;
	extern int MK_OUT_OF_MEMORY;
	extern int MK_MSG_MARK_AS_READ;
	extern int MK_MSG_MARK_AS_UNREAD;
	extern int MK_MSG_NEW_NEWS_MESSAGE;
	extern int MK_MSG_POST_REPLY;
	extern int MK_MSG_POST_MAIL_REPLY;
	extern int MK_MSG_NEW_MAIL_MESSAGE;
	extern int MK_MSG_REPLY;
	extern int MK_MSG_REPLY_TO_SENDER;
	extern int MK_MSG_REPLY_TO_ALL;
	extern int MK_MSG_FORWARD_QUOTED;
	extern int MK_MSG_FORWARD;
	extern int MK_MSG_PARTIAL_MSG_FMT_1;
	extern int MK_MSG_PARTIAL_MSG_FMT_2;
	extern int MK_MSG_PARTIAL_MSG_FMT_3;
	extern int MK_MSG_ID_NOT_IN_FOLDER;
	extern int MK_MSG_FOLDER_UNREADABLE;
	extern int MK_MSG_OPEN_DRAFT;
	extern int MK_MSG_ADD_SENDER_TO_ADDRESS_BOOK;
	extern int MK_MSG_ADD_ALL_TO_ADDRESS_BOOK;
	extern int MK_MSG_CANT_OPEN;
}


#ifdef DEBUG_terry
static void
StupidAttachmentCount(MSG_Pane* pane, void*, int32 num, XP_Bool finished)
{
	XP_Trace("@@@ %d attachments (%s)\n", num, finished ? "Done" : "Not done");
	if (finished && num > 0) {
		MSG_AttachmentData* data;
		finished = FALSE;
		MSG_GetViewedAttachments(pane, &data, &finished);
		XP_ASSERT(finished);
		MSG_AttachmentData* tmp;
		for (tmp = data ; tmp->url ; tmp++) {
			XP_Trace("@@@     %s\n", tmp->url);
			XP_Trace("@@@         %s\n", tmp->real_type);
			XP_Trace("@@@         %s\n", tmp->real_name);
			XP_Trace("@@@         %s\n", tmp->description);
		}
		MSG_FreeAttachmentList(pane, data);
	}
}
#endif


MSG_MessagePane::MSG_MessagePane(MWContext* context, MSG_Master* master)
: m_PaneListener(this), MSG_Pane(context, master) 
{
	m_key = MSG_MESSAGEKEYNONE;
	m_postDeleteLoadKey = MSG_MESSAGEKEYNONE;

#ifdef DEBUG_terry

	static MSG_MessagePaneCallbacks call;
	call.AttachmentCount = StupidAttachmentCount;
	SetMessagePaneCallbacks(&call, NULL);

#endif

}


MSG_MessagePane::~MSG_MessagePane () 
{
	ClearDerivedStrings();
	InterruptContext(FALSE);	
	if (m_view) {
		m_view->Remove(&m_PaneListener);
		m_view->Close(); // drop reference count
		m_view = NULL;
	}
}


MSG_PaneType MSG_MessagePane::GetPaneType() 
{
	return MSG_MESSAGEPANE;
}


int MSG_MessagePane::SetMessagePaneCallbacks(MSG_MessagePaneCallbacks* c,
											 void* closure)
{
	m_callbacks = c;
	m_callbackclosure = closure;
	return 0;
}


MSG_MessagePaneCallbacks*
MSG_MessagePane::GetMessagePaneCallbacks(void** closure)
{
	if (closure) *closure = m_callbackclosure;
	return m_callbacks;
}



void MSG_MessagePane::NotifyPrefsChange(NotifyCode code) 
{
	if (m_folder)
	{
		if (((code == MailServerType)||(code == PopHost)) && 
            (GetFolder()->GetType() == FOLDER_IMAPMAIL))
        {
			FE_PaneChanged(this, TRUE, MSG_PaneNotifyFolderDeleted,
                           (uint32)GetFolder());
        }
		else if (code != Directory)
		{
			// We don't want to reload the message on a directory change 
			// because a directory notification can result from a prefs 
			// reload, which can in turn result from loading a message. 
			// (Holy recursion, Batman!)
			LoadMessage(m_folder, m_key, NULL, TRUE);
		}
		else // code == Directory
		{
			// If the main mail directory changes, do we not close ourselves?
		}
	}
}

MSG_FolderInfo *MSG_MessagePane::GetFolder() 
{
	return m_folder;
}

void MSG_MessagePane::SetFolder(MSG_FolderInfo *info)
{
	m_folder = info;
}

PaneListener *MSG_MessagePane::GetListener() 
{
	return &m_PaneListener;
}

MsgERR MSG_MessagePane::InitializeFolderAndView (const char *folderName)
{
	MsgERR status = 0;
	MSG_FolderInfo	*folder = GetMaster()->FindMailFolder (folderName, FALSE);

	if (m_folder != folder)	// don't reinitialize folder and view unless it has changed
	{
		if (folder)			// sometimes, folderName is NULL, so folder will be NULL, so re-use m_folder
			m_folder = folder;
		CloseView();
		char* url = m_folder->BuildUrl(NULL, MSG_MESSAGEKEYNONE);
		status = MessageDBView::OpenURL(url, GetMaster(),
											   ViewAny,
											   &m_view, TRUE /* open in foreground */);

		if (status == eSUCCESS && m_view != NULL)
			m_view->Add(&m_PaneListener); // add listener back to view
		XP_FREE(url);
	}
	
	return status;
}

void MSG_MessagePane::StartingUpdate(MSG_NOTIFY_CODE code, MSG_ViewIndex where,
							  int32 num)
{
	if (m_numstack == 0)
		m_PaneListener.StartKeysChanging();

	MSG_Pane::StartingUpdate(code, where, num);
}

void MSG_MessagePane::EndingUpdate(MSG_NOTIFY_CODE code, MSG_ViewIndex where,
							  int32 num)
{
	MSG_Pane::EndingUpdate(code, where, num);
	if (m_numstack == 0)
		m_PaneListener.EndKeysChanging();
}


void MSG_MessagePane::SwitchView(MessageDBView *newView)
{
	m_view->Remove(&m_PaneListener);
	m_view->Close();
	m_view = newView;
	m_view->AddReference();
	m_view->Add(&m_PaneListener); // add listener back to view
	newView->EnsureListed(m_key);
}

// allow_content_change indicates whether we should maintain the
// integrity of the original message from the server.  If set to TRUE,
// that means it is safe for us to fiddle with the content.  For instance,
// we are allowed to download it by IMAP MIME parts and assemble a somewhat
// empty shell.
MsgERR
MSG_MessagePane::LoadMessage(MSG_FolderInfo* folder, 
							MessageKey key,
							Net_GetUrlExitFunc *loadUrlExitFunction,
							XP_Bool allow_content_change) 
{
	XP_Bool clearMessageArea = (m_key != key);

	if (m_key != key)
		MSG_SetBiffStateAndUpdateFE(MSG_BIFF_NoMail);

#ifdef XP_MAC
	{
	// Ask FE if it's OK to load another message (the window may be closing).
	enum { MSG_PaneNotifyOKToLoadNewMessage = 999 }; // Can we make this official?
	XP_Bool ok = TRUE;
	FE_PaneChanged(this, FALSE, (MSG_PANE_CHANGED_NOTIFY_CODE)MSG_PaneNotifyOKToLoadNewMessage, (int32)&ok);
	if (!ok)
		return eSUCCESS;
	}
#endif

	if (clearMessageArea && folder && folder->GetType() == FOLDER_IMAPMAIL) 
	{
		MSG_IMAPFolderInfoMail *imapFolder =  folder->GetIMAPFolderInfoMail();
		MSG_UrlQueue *queue = MSG_UrlQueue::FindQueueWithSameContext (this);
		if (queue != NULL)
			clearMessageArea = FALSE;	
		// pseudo interrupt any message load, if we're fetching by chunks
		XP_Bool	fetchByChunks = TRUE;
		PREF_GetBoolPref("mail.imap.fetch_by_chunks", &fetchByChunks);
		if (fetchByChunks && imapFolder &&  imapFolder->GetRunningIMAPUrl())
		{
			IMAP_PseudoInterruptFetch(GetContext());
			clearMessageArea = FALSE;	
		}
	}

	// Clear message area, but only if we're loading
	// a new message. This is all very unfortunate. Clearing message
	// area causes libparse to interrupt the mail context, which happens
	// to be reparsing a folder in some cases. This is because WinFE
	// clears the message area if the view is empty (even if it was
	// empty to start with) as a side effect of trying to select something.
	if (clearMessageArea)
	{
#ifndef XP_MAC
		// macfe has its own clearing routine (CMessageView::ClearMessageArea)
		msg_ClearMessageArea(GetContext());
#endif
		m_key = key;
	}
	if (key == MSG_MESSAGEKEYNONE)
		return eSUCCESS;

	// don't reinitialize folder and view unless it has changed, or the view or DB seem invalid
	if (m_folder != folder || !m_view || !m_view->GetDB())	
	{
		m_folder = folder;
		MsgERR status = InitializeFolderAndView (NULL);
		if (status != eSUCCESS) 
			return status;
	}

	FE_PaneChanged(this, FALSE, MSG_PaneNotifyMessageLoaded, key);

	if (m_callbacks && m_callbacks->AttachmentCount) {
		m_callbacks->AttachmentCount(this, m_callbackclosure, 0, FALSE);
	}

	XP_ASSERT(m_view);
	char *url = m_folder->BuildUrl(m_view->GetDB(), key);
	if (NULL != url)
	{
		Net_GetUrlExitFunc *preExitFunc;

		m_doneLoadingFunc = NULL;
		m_doneLoading = FALSE;
		if (m_justmakecompose) 
		{
			preExitFunc = MSG_MessagePane::FinishComposeFor;
		}
		else
		{
			preExitFunc = MSG_MessagePane::FinishedLoading;
			m_doneLoadingFunc = loadUrlExitFunction;
		}

		
		if (folder->GetType() == FOLDER_IMAPMAIL)
		{
			MSG_IMAPFolderInfoMail *imapFolder = (MSG_IMAPFolderInfoMail *) folder;
			imapFolder->SetDownloadState(MSG_IMAPFolderInfoMail::kNoDownloadInProgress);
			GetContext()->currentIMAPfolder = imapFolder;
		}

		if (m_callbacks && m_callbacks->AttachmentCount) {
			m_callbacks->AttachmentCount(this, m_callbackclosure, 0, FALSE);
		}
		
		// if an imap folder is being loaded in this context, then this
		// is the result of the user clicking on a message.  We interrupt
		// and load
		XP_Bool shouldNotInterrupt = TRUE;
		if (folder->GetType() == FOLDER_IMAPMAIL) 
		{
			XP_Bool	urlIsInMemoryCache = FALSE;
			MSG_IMAPFolderInfoMail *imapFolder = folder->GetIMAPFolderInfoMail();
			if (imapFolder->GetFolderLoadingContext() == GetContext())
				shouldNotInterrupt = FALSE;

			URL_Struct *url_s = NET_CreateURLStruct (url, NET_IsOffline() ? NET_SUPER_RELOAD : NET_DONT_RELOAD);
			char extraFlag = 0;	// figure out extra flag before we start loading offline messages, because that marks it read.

			MSG_UrlQueue *q = NULL;
			if (url_s)
			{
				if (!NET_IsOffline())
				{
					MSG_ViewIndex viewIndex = m_view->FindKey(key, FALSE);
					if (viewIndex != MSG_VIEWINDEXNONE)
					{
						m_view->GetExtraFlag(viewIndex, &extraFlag);
					}
				}
				url_s->allow_content_change = allow_content_change;
				m_key = key;
				q = MSG_UrlQueue::AddUrlToPane(url_s, preExitFunc, this, FALSE, NET_IsOffline() ? NET_SUPER_RELOAD : NET_DONT_RELOAD);
				urlIsInMemoryCache = NET_IsURLInMemCache(url_s);
			}
			else
				return eUNKNOWN;

			XP_FREE(url);

			// if this message was previously unread, and the message is offline or 
			// in memory cache, make sure the server knows it's read

			if (!NET_IsOffline())
			{
				if (!(extraFlag & kIsRead))
				{
					if (urlIsInMemoryCache || (extraFlag & kOffline))
					{
						IDArray	keysToFlag;

						keysToFlag.Add(m_key);
						imapFolder->StoreImapFlags(this, kImapMsgSeenFlag, TRUE, keysToFlag, q);
					}
				}
			}
			
			return eSUCCESS;
		}
		URL_Struct* ustruct = NET_CreateURLStruct(url, NET_IsOffline() ? NET_SUPER_RELOAD : NET_DONT_RELOAD);
		ustruct->pre_exit_fn = preExitFunc;
		GetURL(ustruct, TRUE);	// TRUE will quietly work if any existing 
												// url is 'almost done'.

		// clear any imap copy info so download will work

		XP_FREE (url);

		return eSUCCESS;
	}
	else
		return eUNKNOWN; //PHP need better error code
}


void MSG_MessagePane::FinishedLoading(URL_Struct* ustruct, int status,
									  MWContext* context)
{
	MSG_MessagePane* pane = (MSG_MessagePane*) ustruct->msg_pane;
	XP_ASSERT(pane && pane->GetPaneType() == MSG_MESSAGEPANE);
	if (!pane || pane->GetPaneType() != MSG_MESSAGEPANE) return;
	if (pane->m_doneLoadingFunc) {
		(*pane->m_doneLoadingFunc)(ustruct, status, context);
		pane->m_doneLoadingFunc = NULL;
	}
	pane->m_doneLoading = TRUE;
	if (pane->m_callbacks && pane->m_callbacks->AttachmentCount) {
		pane->m_callbacks->AttachmentCount(pane, pane->m_callbackclosure,
										   MimeGetAttachmentCount(context),
										   TRUE);
		if (context && MIME_HasAttachments(context))
			(pane->m_view->GetDB())->MarkHasAttachments(pane->m_key, TRUE, (ChangeListener*) pane /* m_view ? */);
	}
}



void MSG_MessagePane::DestroyPane(URL_Struct* ustruct, int /*status*/,
								  MWContext* /*context*/)
{
	MSG_MessagePane* pane = (MSG_MessagePane*) ustruct->msg_pane;
	XP_ASSERT(pane->GetPaneType() == MSG_MESSAGEPANE);
	if (pane->GetPaneType() == MSG_MESSAGEPANE) {
		delete pane;
	}
}


void MSG_MessagePane::FinishComposeFor(URL_Struct* ustruct, int /*status*/,
									   MWContext* /*context*/)
{
	MSG_MessagePane* pane = (MSG_MessagePane*) ustruct->msg_pane;
	XP_ASSERT(pane->GetPaneType() == MSG_MESSAGEPANE);
	if (pane->GetPaneType() == MSG_MESSAGEPANE) {
		pane->UnregisterFromPaneList();	// Make sure that netlib won't decide
										// to attach this pane to a URL,
										// because this pane is about to go
										// away.
		if (pane->ComposeMessage(pane->m_composetype,
								 MSG_MessagePane::DestroyPane) != eSUCCESS) {
			delete pane;
		}
	}
}


MsgERR
MSG_MessagePane::MakeComposeFor(MSG_FolderInfo* folder, MessageKey key,
								MSG_CommandType type)
{
	m_justmakecompose = TRUE;
	m_composetype = type;
	XP_Bool allow_content_change = 
		((type == MSG_ReplyToSender) ||
		(type == MSG_ReplyToAll) ||
		(type == MSG_ForwardMessageQuoted));
	MsgERR status = LoadMessage(folder, key, NULL, allow_content_change);	// forwarding requires message integrity
	if (status != eSUCCESS) delete this;
	return status;
}



void
MSG_MessagePane::ClearDerivedStrings()
{
  FREEIF(m_mailToSenderUrl);
  FREEIF(m_mailToAllUrl);
  FREEIF(m_postReplyUrl);
  FREEIF(m_postAndMailUrl);
  FREEIF(m_displayedMessageSubject);
  FREEIF(m_displayedMessageId);
}


static char*
msg_get_1522_header(MWContext *context, MimeHeaders *headers,
                                        const char *name, XP_Bool all_p)
{
	char *contents = MimeHeaders_get(headers, name, FALSE, all_p);
	INTL_CharSetInfo c = LO_GetDocumentCharacterSetInfo(context);
	if (contents && *contents) {
		char *converted = IntlDecodeMimePartIIStr(contents, INTL_GetCSIWinCSID(c),
												  FALSE);
		if (converted) {
			XP_FREE(contents);
			contents = converted;
		}
	}
	return contents;
}




void 
MSG_MessagePane::ActivateReplyOptions(MimeHeaders* headers)
{
	XP_Bool mdnNeeded = FALSE, isRead = FALSE;
	
	// Since this gets called when the text appears in the pane, this is a
	// great time to mark the message as read.

	if (!m_justmakecompose) {
		XP_Bool bMarkMessageRead = TRUE;
		char *xref = MimeHeaders_get(headers, HEADER_XREF, FALSE, FALSE);
		char *messageID = MimeHeaders_get(headers, HEADER_MESSAGE_ID, FALSE, FALSE);
		if (messageID && m_view && m_view->GetDB())
		{
			MessageDB *db = m_view->GetDB();
			// check if this is the same message-id as we think we should have for the
			// current key.
			DBMessageHdr *curHdr = db->GetDBHdrForKey(m_key);
			db->IsMDNNeeded(m_key, &mdnNeeded);
			db->IsRead(m_key, &isRead);

			if (curHdr)
			{
				XPStringObj curKeyMessageID;
				curHdr->GetMessageId(curKeyMessageID, db->GetDB());
				char	*strippedMsgID = (char *) XP_ALLOC(XP_STRLEN(messageID));
				if (strippedMsgID)
				{
					MessageHdrStruct::StripMessageId(messageID, strippedMsgID, XP_STRLEN(messageID));
					if (XP_STRCMP(strippedMsgID, curKeyMessageID))
					{
						char *newsgroups = MimeHeaders_get(headers, HEADER_NEWSGROUPS, FALSE, FALSE);
						m_key = db->GetMessageKeyForID(messageID);
						FE_PaneChanged(this, FALSE, MSG_PaneNotifyMessageLoaded, m_key);
						// ### dmb should check if we've changed newsgroups!
						FREEIF(newsgroups);

					}
				}
				FREEIF(strippedMsgID);
				delete curHdr;
			}
			if (m_folder && m_key == m_folder->GetLastMessageLoaded())
			{
				m_folder->SetLastMessageLoaded(MSG_MESSAGEKEYNONE);
				bMarkMessageRead = FALSE;
			}
		}
		if (bMarkMessageRead)
			MarkMessageKeyRead(m_key, xref);
		FREEIF(xref);
		FREEIF(messageID);
	}


	char *host = 0;
	char *to_and_cc = 0;
	char *re_subject = 0;
	char *new_refs = 0;

	char *from = 0;
	char *repl = 0;
	char *subj = 0;
	char *id = 0;
	char *refs = 0;
	char *to = 0;
	char *cc = 0;
	char *grps = 0;
	char *foll = 0;

	HG02087

	ClearDerivedStrings();

	if (headers) {

		from = msg_get_1522_header(m_context, headers, HEADER_FROM,     FALSE);
		repl = msg_get_1522_header(m_context, headers, HEADER_REPLY_TO, FALSE);
		subj = msg_get_1522_header(m_context, headers, HEADER_SUBJECT,  FALSE);
		to   = msg_get_1522_header(m_context, headers, HEADER_TO,       TRUE);
		cc   = msg_get_1522_header(m_context, headers, HEADER_CC,       TRUE);

		/* These headers should not be RFC-1522-decoded. */
		grps = MimeHeaders_get(headers, HEADER_NEWSGROUPS,  FALSE, TRUE);
		foll = MimeHeaders_get(headers, HEADER_FOLLOWUP_TO, FALSE, TRUE);
		id   = MimeHeaders_get(headers, HEADER_MESSAGE_ID,  FALSE, FALSE);
		refs = MimeHeaders_get(headers, HEADER_REFERENCES,  FALSE, TRUE);

		if (repl) {
			FREEIF(from);
			from = repl;
			repl = 0;
		}

		if (foll) {
			FREEIF(grps);
			grps = foll;
			foll = 0;
		}


	  HG82126
	}

	if (m_folder && m_folder->IsNews()) {
		/* Decide whether cancelling this message should be allowed. */
		m_cancellationAllowed = FALSE;
		if (from) {
			char *us = MSG_MakeFullAddress (NULL, FE_UsersMailAddress ());
			char *them = MSG_ExtractRFC822AddressMailboxes(from);
			m_cancellationAllowed = (us && them && !strcasecomp (us, them));
			FREEIF(us);
			FREEIF(them);
		}
	}

	if (!headers) return;

	if (subj) {
		m_displayedMessageSubject = XP_STRDUP(subj);
	}
	if (id) {
		m_displayedMessageId = XP_STRDUP(id);
	}

	host = ComputeNewshostArg();

	if (to || cc) {
		to_and_cc = (char *)
			XP_ALLOC((to ? XP_STRLEN (to) : 0) +
					 (cc ? XP_STRLEN (cc) : 0) +
					 5);
		if (!to_and_cc) goto FAIL;
		*to_and_cc = 0;
		if (to) XP_STRCPY(to_and_cc, to);
		if (to && *to && cc && *cc) {
			XP_STRCAT(to_and_cc, ", ");
		}
		if (cc) XP_STRCAT(to_and_cc, cc);
	}

	if (id || refs) {
		int maxlen =
			(id ? XP_STRLEN(id) : 0) +
			(refs ? XP_STRLEN (refs) : 0) +
			5;
		new_refs = (char *) XP_ALLOC(maxlen);
		if (!new_refs) goto FAIL;
		*new_refs = 0;
		if (refs) XP_STRCPY (new_refs, refs);
		if (refs && id) {
			XP_STRCAT (new_refs, " ");
		}
		if (id) XP_STRCAT (new_refs, id);
	}

	if (from || grps || to_and_cc) {
		const char *s = subj;
		if (s) msg_StripRE(&s, NULL);

		re_subject = (char *) XP_ALLOC((s ? XP_STRLEN (s) : 0) + 10);
		if (!re_subject) goto FAIL;
		XP_STRCPY (re_subject, "Re: ");
		if (s) XP_STRCAT (re_subject, s);
	}

	if (from) {
		m_mailToSenderUrl = MakeMailto(from, 0, 0, re_subject, new_refs,
									   0, host, HG62212);
	}

	if (from || to_and_cc) {
		m_mailToAllUrl = MakeMailto(from, to_and_cc, 0, re_subject,
									new_refs, 0, host, HG91611);
	}

	if (grps) {
		if (!strcasecomp(grps, "poster")) {
			/* "Followup-to: poster" makes "post reply" act the same as
			   "reply to sender". */
			if (m_mailToSenderUrl) {
				m_postReplyUrl = XP_STRDUP(m_mailToSenderUrl);
			}
		} else {
			m_postReplyUrl =
				MakeMailto(0, 0, grps, re_subject, new_refs, 0, host, HG81762);
		}
	}

	if (from || grps) {
		if (grps && !strcasecomp(grps, "poster")) {
			/* "Followup-to: poster" makes "post and mail reply" act the
			   same as "reply to sender". */
			if (m_mailToSenderUrl) {
				m_postAndMailUrl = XP_STRDUP(m_mailToSenderUrl);
			}
		} else {
			m_postAndMailUrl = MakeMailto(from, 0, grps,
										  re_subject, new_refs, 0, host,
										  HG76255);
		}
	}

	if (m_folder && !m_folder->IsNews() && mdnNeeded && !isRead)
	{
		// Constructor of MSG_ProcessMdnNeededState will send out
		// an MDN report if needed.
		MSG_ProcessMdnNeededState
			processMdnNeeded(MSG_ProcessMdnNeededState::eDisplayed, 
							 this,
							 m_folder,
							 m_key,
							 headers,
							 FALSE);
		m_view->GetDB()->MarkMDNNeeded(m_key, FALSE);
		m_view->GetDB()->MarkMDNSent(m_key, TRUE);
	}

FAIL:
	FREEIF(host);
	FREEIF(to_and_cc);
	FREEIF(re_subject);
	FREEIF(new_refs);
	FREEIF(from);
	FREEIF(repl);
	FREEIF(subj);
	FREEIF(id);
	FREEIF(refs);
	FREEIF(to);
	FREEIF(cc);
	FREEIF(grps);
	FREEIF(foll);
}


void 
MSG_MessagePane::DoIncWithUIDL_s(URL_Struct *url, int status,
								 MWContext *context)
{
	XP_ASSERT(url && url->msg_pane);
	if (url && url->msg_pane) {
		XP_ASSERT(url->msg_pane->GetPaneType() == MSG_MESSAGEPANE);
		if (url->msg_pane->GetPaneType() == MSG_MESSAGEPANE) {
			((MSG_MessagePane*)url->msg_pane)->DoIncWithUIDL(url, status,
															 context);
		}
	}
}


void
MSG_MessagePane::DoIncWithUIDL(URL_Struct * /*url*/, int /*status*/,
							   MWContext * /*context*/)
{
	if (GetUIDL()) {
		DoCommand(MSG_GetNewMail, NULL, 0);
	}
}




void MSG_MessagePane::PrepareToIncUIDL(URL_Struct* url, const char* uidl)
{
	XP_ASSERT(url && uidl);
	if (!url || !uidl) return;
	FREEIF(m_incUidl);
	m_incUidl = XP_STRDUP(uidl);
	if (url->msg_pane == NULL) url->msg_pane = this;
	XP_ASSERT(url->msg_pane == this);
	if (url && url->msg_pane == this && m_incUidl) {
		url->pre_exit_fn = MSG_MessagePane::DoIncWithUIDL_s;
	}
}


void
MSG_MessagePane::IncorporateShufflePartial(URL_Struct * /* url */, int status,
										   MWContext * /* context */)
{
	FREEIF(m_incUidl);
	if (status < 0)
		return;
	XP_ASSERT(m_view);
	if (!m_view)
		return;
	MessageDB* db = m_view->GetDB();

	XP_ASSERT(db);
	if (!db)
		return;
	XP_ASSERT(m_folder);
	if (!m_folder)
		return;
	MSG_FolderInfoMail* mailfolder = m_folder->GetMailFolderInfo();

	XP_ASSERT(mailfolder);
	if (!mailfolder)
		return;

	MessageKey oldkey = m_key;
	MessageKey newkey = MSG_MESSAGEKEYNONE;
	ListContext* list = NULL;
	DBMessageHdr* hdr = NULL;

	if (db->ListLast(&list, &hdr) == eSUCCESS) {
		newkey = hdr->GetMessageKey();
		db->ListDone(list);
	}

	if (newkey == MSG_MESSAGEKEYNONE)
		return;

	MSG_ThreadPane* threadpane = GetMaster()->FindThreadPaneNamed(mailfolder->GetPathname());
	if (threadpane)
	{
		MessageDBView* threadview = threadpane->GetMsgView();
		if (threadview)
		{
			MSG_ViewIndex index = threadview->FindViewIndex(oldkey);
			if (index != MSG_VIEWINDEXNONE)
				threadview->RemoveByIndex(index);	// kill old msg line
				//threadview->SetKeyByIndex(index, newkey);
		}
	}

	hdr = db->GetDBHdrForKey(oldkey);
	if (hdr) {
		db->RemoveHeaderFromDB(hdr);
		delete hdr;
	}

	LoadMessage(m_folder, newkey, NULL, TRUE);

	// Ok, this is a little weird. The GetNewMail command rightly acquires 
	// the semaphore, and hopes that GetNewMailExit will be called to releaase
	// the semaphore. But when incorporating the rest of a truncated message,
	// the exit function is IncorporateShufflePartial, so release it here.
	m_folder->ReleaseSemaphore (this);
	mailfolder->SetGettingMail(FALSE);
}



char *
MSG_MessagePane::MakeForwardMessageUrl(XP_Bool quote_original)
{
	char *url = 0;
	char *host = ComputeNewshostArg();
	MessageHdrStruct header;
	char *fwd_subject = 0;
	const char *id = 0;
	char *attachment = 0;

	HG22987

	if (!m_view || m_key == MSG_MESSAGEKEYNONE || 
		!m_folder || !m_view->GetDB()) {
		return NULL;
	}
	if (m_view->GetDB()->GetMessageHdr(m_key, &header) != eSUCCESS) {
		return NULL;
	}

	fwd_subject = CreateForwardSubject(&header);
	id = header.m_messageId;

	if (*id) {
		attachment = m_folder->BuildUrl(m_view->GetDB(), m_key);
	}
	
	/* if we are quoting the original document, slip a cookie string in
	   at the beginning of the attachment field.  This will be removed
	   before processing. */
	
	if (quote_original && attachment) {
		char * new_attachment = PR_smprintf(MSG_FORWARD_COOKIE "%s",
											attachment);
		FREEIF(attachment);
		attachment = new_attachment;
	}
	
	url = MakeMailto(0, 0, 0, fwd_subject, 0, attachment, host, HG22296);
	FREEIF(attachment);

	FREEIF(host);
	FREEIF(fwd_subject);

	return url;
}



MsgERR
MSG_MessagePane::ComposeMessage(MSG_CommandType type, Net_GetUrlExitFunc* func)
{
	char *host = 0;
	char *url = 0;
	XP_Bool free_url_p = FALSE;
	URL_Struct *url_struct = 0;
	MSG_FolderInfoNews *newsFolder;
	MSG_PostDeliveryActionInfo *actionInfo = 0;
	XP_Bool checkForHTML = FALSE;

	HG22867

	switch (type) {
	case MSG_MailNew:
		host = ComputeNewshostArg ();
		HG32145
		url = MakeMailto (0, 0, 0, 0, 0, 0, host, HG09990);
		free_url_p = TRUE;
		break;
	case MSG_PostNew:
		// ### tw - fix me - cast hack below
		if (!m_folder->IsNews())
			break;
		newsFolder = (MSG_FolderInfoNews *) m_folder;

		HG89520
		host = ComputeNewshostArg ();
		url = MakeMailto (0, 0, newsFolder->GetNewsgroupName(), 0, 0, 0,
						  host, HG02192);
		free_url_p = TRUE;
		break;
	case MSG_ReplyToSender:
		url = m_mailToSenderUrl;
		checkForHTML = TRUE;
		break;
	case MSG_ReplyToAll:
		url = m_mailToAllUrl;
		checkForHTML = TRUE;
		break;
	case MSG_PostReply:
		url = m_postReplyUrl;
		checkForHTML = TRUE;
		break;
	case MSG_PostAndMailReply:
		url = m_postAndMailUrl;
		checkForHTML = TRUE;
		break;
	case MSG_ForwardMessageAttachment:
		url = MakeForwardMessageUrl(FALSE);
		free_url_p = TRUE;
		break;
	case MSG_ForwardMessageQuoted:
		/* last flag indicates to quote the original message. */
		url = MakeForwardMessageUrl(TRUE);
		free_url_p = TRUE;
		break;
	default:
		XP_ASSERT (0);
		break;
	}

	FREEIF(host);
	if (!url) {
		url = "mailto:";
		free_url_p = FALSE;
	}

	// This is the place to add a "&force-plain-text" to the URL, if we ever
	// again wanted the feature of forcing a plaintext composition when you
	// reply to a plaintext message.

	if (checkForHTML) {
		char* part = MimeGetHtmlPartURL(GetContext());
		if (part) {
			char* tmp = PR_smprintf("%s&html-part=%s", url, part);
			if (tmp) {
				if (free_url_p) XP_FREE(url);
				url = tmp;
				free_url_p = TRUE;
			}
		}
	}

	url_struct = NET_CreateURLStruct (url, NET_NORMAL_RELOAD);
	if (free_url_p && url) {
        XP_FREE(url);
	}
	if (!url_struct) return eOUT_OF_MEMORY;

	/* Get a ride from url_struct->fe_data to attach 
	 * post delivery action info */
	if ( type == MSG_ReplyToSender ||
		 type == MSG_ReplyToAll ||
		 type == MSG_ForwardMessageAttachment ||
		 type == MSG_ForwardMessageQuoted ) {
		actionInfo = new MSG_PostDeliveryActionInfo(m_folder);

		if (actionInfo) {
			actionInfo->m_msgKeyArray.Add(m_key);

			XP_ASSERT( url_struct->fe_data == NULL );

			switch (type) {
			case MSG_ReplyToSender:
			case MSG_ReplyToAll:
				actionInfo->m_flags |= MSG_FLAG_REPLIED;
				url_struct->fe_data = actionInfo;
				/* actionInfo will be freed by CompositionPane
				 * when we close down the Composition Window.
				 */
				break;
			case MSG_ForwardMessageAttachment:
			case MSG_ForwardMessageQuoted:
				actionInfo->m_flags |= MSG_FLAG_FORWARDED;
				url_struct->fe_data = actionInfo;
				/* actionInfo will be freed by CompositionPane
				 * when we close down the Composition Window.
				 */
				break;
			default:
				XP_FREE (actionInfo);
				break;
			}
		}
	}
	url_struct->internal_url = TRUE;
	url_struct->pre_exit_fn = func;

	GetURL (url_struct, TRUE);

	return 0;
}


MsgERR MSG_MessagePane::SetViewFromUrl (const char *url)
{
	XP_ASSERT(!m_view);
	XP_ASSERT(url);

	return MessageDBView::OpenURL(url, GetMaster(), 
		ViewAny, &m_view, TRUE);
}

MsgERR MSG_MessagePane::DeleteMessage ()
{
	MSG_ViewIndex index = m_view->FindViewIndex(m_key);
 
//	if (index != MSG_VIEWINDEXNONE)	// try using the base class method...see what happens.
//		return TrashMessages(&index, 1);

 	MessageKey	 nextKey = MSG_MESSAGEKEYNONE;
	IDArray		*headerIds = new IDArray;
	XP_Bool imapDeleteIsMoveToTrash = (m_folder) ? m_folder->DeleteIsMoveToTrash() : FALSE;

	// allocate an array for the async machine

 	if (!headerIds)
 	{
 		XP_ASSERT(FALSE);
 		return eOUT_OF_MEMORY;
	}
 
 	// fill in the header for the selected message
	headerIds->Add(m_key);
 
 	// copy the messages into the trash folder
 	if (m_folder && (!(m_folder->GetFlags() & MSG_FOLDER_FLAG_TRASH) || !imapDeleteIsMoveToTrash))
 	{
 		XP_ASSERT (m_folder->IsMail());
			
 		MSG_FolderInfoMail *trashFolder = NULL;
		const char *path = NULL;
		if (m_folder->GetType() == FOLDER_MAIL)
		{
			path = m_master->GetPrefs()->MagicFolderName (MSG_FOLDER_FLAG_TRASH);
			trashFolder = m_master->FindMailFolder (path, TRUE);
		}
		else
		{
			if (imapDeleteIsMoveToTrash)
			{
				MSG_IMAPFolderInfoMail *imapInfo = m_folder->GetIMAPFolderInfoMail();
				if (imapInfo)
				{
					MSG_FolderInfo *foundTrash = MSG_GetTrashFolderForHost(imapInfo->GetIMAPHost());
					trashFolder = foundTrash ? foundTrash->GetMailFolderInfo() : (MSG_FolderInfoMail *)NULL;
				}
			}
		}

 		// Figure out what messate to load after this one is deleted
 		// MSG_FolderInfoMail::FinishCopyingMessages does the actual load.
 		if (index != MSG_VIEWINDEXNONE)
 		{
 			nextKey = m_view->GetAt(index + 1);
 			if (nextKey == MSG_MESSAGEKEYNONE)	// if last msg, try getting previous
 				nextKey = m_view->GetAt(index - 1);
 		}
 
		if (trashFolder)
 			m_folder->StartAsyncCopyMessagesInto (trashFolder, 
												  this, 
												  m_view->GetDB(),
												  headerIds, 
												  1, 
												  m_context, 
												  NULL, // do not run in url queue
												  TRUE, 
												  nextKey);
		else if (!imapDeleteIsMoveToTrash && (m_folder->GetType() == FOLDER_IMAPMAIL) )
			((MSG_IMAPFolderInfoMail *)m_folder)->DeleteSpecifiedMessages(this, *headerIds,nextKey);
 		//PHP impedance mismatch on error codes
 	}
 	return 0;
}

// static
void MSG_MessagePane::PostDeleteLoadExitFunction(URL_Struct *URL_s, int status, MWContext *)
{
	if ((status == 0) && (URL_s->msg_pane->GetPaneType() == MSG_MESSAGEPANE))
	{
		MSG_MessagePane *msgPane = (MSG_MessagePane *) URL_s->msg_pane;
		MessageKey loadKey = msgPane->GetPostDeleteLoadKey();
		if (loadKey != MSG_MESSAGEKEYNONE)
		{
			msgPane->LoadMessage(msgPane->GetFolder(), loadKey, NULL, TRUE);
		}
	}
	
	if (URL_s->msg_pane->GetPaneType() == MSG_MESSAGEPANE)
		((MSG_MessagePane *) URL_s->msg_pane)->SetPostDeleteLoadKey(MSG_MESSAGEKEYNONE);
}

MsgERR MSG_MessagePane::DoCommand(MSG_CommandType command,
								  MSG_ViewIndex* indices, int32 numIndices)
{
	// Note that nothing in here pays the slightest attention to indices or
	// numIndices.  On messagepanes, commands effect the displayed message
	// and that's it.

	// We'd better not be trying to do any commands at all if we don't even
	// have a m_view.
	XP_ASSERT(m_view);
	if (!m_view) return eUNKNOWN;

	if (command == MSG_ForwardMessage)
	{
		int32 forwardMsgMode = 0;
		PREF_GetIntPref("mail.forward_message_mode", &forwardMsgMode);
		if (forwardMsgMode == 1)
			command = MSG_ForwardMessageQuoted;
		else if (forwardMsgMode == 2)
			command = MSG_ForwardMessageInline;
		else
			command = MSG_ForwardMessageAttachment;
	}

	MsgERR err = eSUCCESS;

	switch (command)
	{
	case MSG_DeleteMessage:
		{
			// put this bug back in (deleting message from the trash) so that
			// deleting a message from non-trash in stand-alone message will
			// work for alpha.
			// The real solution is to send a notification to the fe that
			// a delete has finished.
			err = DeleteMessage();	
//			MSG_ViewIndex idx = m_view->FindIndex(m_key);
//			err = TrashMessages (&idx, 1);
		}
		break;
	case MSG_PostNew:
	case MSG_PostReply:
	case MSG_PostAndMailReply:
	case MSG_MailNew:
	case MSG_ReplyToSender:
	case MSG_ReplyToAll:
	case MSG_ForwardMessageAttachment:
	case MSG_ForwardMessageQuoted:
        err = ComposeMessage(command, NULL);
		break;
	case MSG_AddSender:
		AddURLToAddressBook(m_mailToSenderUrl);
		break;
	case MSG_AddAll:
		AddURLToAddressBook(m_mailToAllUrl);
		break;
	case MSG_ShowAllHeaders:
	case MSG_ShowSomeHeaders:
	case MSG_ShowMicroHeaders:
		// ### mwelch Changed from m/n prefs object accessor 
		//            to prefs api (will tweak prefs object)
		PREF_SetIntPref("mail.show_headers", 
						(int) (command - MSG_ShowMicroHeaders));
		//GetMaster()->GetPrefs()->SetHeaderStyle (command);
		err = LoadMessage (m_folder, m_key, NULL, TRUE); // is there an easier way to do this?
		break;
	case MSG_SaveMessagesAs:
	case MSG_ForwardMessageInline:
	case MSG_OpenMessageAsDraft:
		{
			MSG_ViewIndex index = m_view->FindViewIndex(m_key);
			err = MSG_Pane::DoCommand(command, &index, 1);
		}
		break;
	case MSG_AttachmentsInline:
	case MSG_AttachmentsAsLinks:
		{
			MessageKey key = m_key;
			PREF_SetBoolPref("mail.inline_attachments", 
							 (command == MSG_AttachmentsInline));
			LoadMessage (m_folder, MSG_MESSAGEKEYNONE, NULL, TRUE);
			LoadMessage (m_folder, key, NULL, TRUE);
		}
		break;
	case MSG_WrapLongLines:
		{
			MessageKey key = m_key;
			XP_Bool newWrap = !GetPrefs()->GetWrapLongLines();
			PREF_SetBoolPref("mail.wrap_long_lines", newWrap);
			LoadMessage (m_folder, MSG_MESSAGEKEYNONE, NULL, TRUE);
			LoadMessage (m_folder, key, NULL, TRUE);
		}
		break;

	case MSG_Rot13Message:
		{
			m_rot13p = !m_rot13p;
			MessageKey key = m_key;
			LoadMessage (m_folder, MSG_MESSAGEKEYNONE, NULL, TRUE);
			LoadMessage (m_folder, key, NULL, TRUE);
		}
		break;
	case MSG_CompressFolder:
		{
			MSG_FolderInfoMail *mailFolder = GetFolder()->GetMailFolderInfo();
			if (mailFolder)
				err = CompressOneMailFolder(mailFolder);
			else
				XP_ASSERT(FALSE);	// MSG_CommandStatus should have failed!
			break;
		}
	default:
		if (!indices)
		{
			MSG_ViewIndex index = m_view->FindViewIndex(m_key);
			if (index != MSG_VIEWINDEXNONE )
			{
				indices = &index;
				numIndices = 1;
			}
		}
		err = MSG_Pane::DoCommand(command, indices, numIndices);
	}
	return err;
}

MsgERR MSG_MessagePane::AddToAddressBook(MSG_CommandType command, MSG_ViewIndex*indices, int32 numIndices, AB_ContainerInfo * destAB)
{
	MsgERR status = 0;
	MessageHdrStruct header;

	status = m_view->GetDB()->GetMessageHdr(m_key, &header);
	if (status != eSUCCESS)
		return status;

	switch(command)
	{
	case MSG_AddSender:
		AB_AddSenderAB2(this, destAB, header.m_author, m_mailToSenderUrl);
		break;
	case MSG_AddAll:
		AB_AddSenderAB2(this, destAB, header.m_author, m_mailToAllUrl);
		break;
	default:
		XP_ASSERT(0);
	}

	return status;
}

MsgERR MSG_MessagePane::AddURLToAddressBook(char * url)
{
	MessageHdrStruct header;

	if (!url) return 0;
	if (m_view->GetDB()->GetMessageHdr(m_key, &header) != eSUCCESS) {
		return 0;
	}
	// assume add to personal address book
	AB_AddSenderToAddBook(FE_GetAddressBook(this), GetContext(), header.m_author, url);
	return 0;
}


MsgERR MSG_MessagePane::GetCommandStatus(MSG_CommandType command,
										 const MSG_ViewIndex* indices,
										 int32 numindices,
										 XP_Bool *selectable_pP,
										 MSG_COMMAND_CHECK_STATE *selected_p,
										 const char **display_stringP,
										 XP_Bool * plural_p)
{
	MsgERR err = eSUCCESS;
	const char *display_string = NULL;
	XP_Bool	selectable_p = TRUE;
	XP_Bool showingMsg = (m_key != MSG_MESSAGEKEYNONE);
	MSG_ViewIndex	curIndex;

	XP_Bool		news_p = (m_folder && m_folder->IsNews() );

	switch (command)
	{
	case MSG_CompressFolder:
		{
			selectable_p = m_folder && m_folder->IsMail();
			break;
		}
	case MSG_DeleteMessageNoTrash:
	case MSG_DeleteMessage:
		{
			MessageDB *db = (m_view) ? m_view->GetDB() : 0;
		selectable_p = (db != NULL && NULL != db->GetMailDB() && showingMsg);
		if (selectable_p)
			selectable_p = (MSG_VIEWINDEXNONE != m_view->FindViewIndex(m_key));

								// can't delete news msg
		display_string = XP_GetString (MK_MSG_DELETE_MESSAGE);
		if (selected_p)
		  *selected_p = MSG_NotUsed;
		break;
		}
	case MSG_MarkMessagesRead:
		{
		  MessageDB *db = (m_view) ? m_view->GetDB() : 0;
		  if (m_view && db)
			{
			  XP_Bool isRead;
			  if (db->IsRead(m_view->GetAt(m_view->FindViewIndex(m_key)), &isRead) == eSUCCESS) 
				{
				  if (!isRead)
					{
					  selectable_p = TRUE;
					}
				}
			  display_string = XP_GetString (MK_MSG_MARK_AS_READ);
			  if (selected_p)
				*selected_p = MSG_NotUsed;
			}
		  break;
		}
	case MSG_MarkMessagesUnread:
		{
		  MessageDB *db = (m_view) ? m_view->GetDB() : 0;
		  if (m_view && db)
			{
			  XP_Bool isRead;
			  if (db->IsRead(m_view->GetAt(m_view->FindViewIndex(m_key)), &isRead) == eSUCCESS) 
				{
				  if (isRead)
					{
					  selectable_p = TRUE;
					}
				}
			  display_string = XP_GetString (MK_MSG_MARK_AS_UNREAD);
			  if (selected_p)
				*selected_p = MSG_NotUsed;
			}
		  break;
		}
	case MSG_AddSender:
		display_string = XP_GetString(MK_MSG_ADD_SENDER_TO_ADDRESS_BOOK);
		selectable_p = showingMsg;
		break;
	case MSG_AddAll:
		display_string = XP_GetString(MK_MSG_ADD_ALL_TO_ADDRESS_BOOK);
		selectable_p = showingMsg;
		break;
	case MSG_PostNew:
		display_string = XP_GetString(MK_MSG_NEW_NEWS_MESSAGE);
		selectable_p = news_p && m_folder->AllowsPosting();
		break;
	case MSG_PostReply:
		display_string = XP_GetString(MK_MSG_POST_REPLY);
		selectable_p = news_p && showingMsg && m_folder->AllowsPosting();
		break;
	case MSG_PostAndMailReply:
		display_string = XP_GetString(MK_MSG_POST_MAIL_REPLY);
		selectable_p = news_p && showingMsg && m_folder->AllowsPosting();
		break;
	case MSG_MailNew:
		display_string = XP_GetString(MK_MSG_NEW_MAIL_MESSAGE);
		break;
	case MSG_ReplyToSender:
		display_string = XP_GetString(MK_MSG_REPLY_TO_SENDER);
		selectable_p = showingMsg;
		break;
	case MSG_ReplyToAll:
		display_string = XP_GetString(MK_MSG_REPLY_TO_ALL);
		selectable_p = showingMsg;
		break;
	case MSG_ForwardMessageQuoted:
		display_string = XP_GetString(MK_MSG_FORWARD_QUOTED);
		selectable_p = showingMsg;
		break;
	case MSG_ForwardMessage:
	case MSG_ForwardMessageAttachment:
  	    if (plural_p)
		  *plural_p = FALSE;
		selectable_p = showingMsg;
		display_string =  XP_GetString(MK_MSG_FORWARD);
		break;
	case MSG_Rot13Message:
		selectable_p = showingMsg;
		if (selected_p)
			*selected_p = (m_rot13p) ? MSG_Checked : MSG_Unchecked;
		break;
	case MSG_ShowAllHeaders:
	case MSG_ShowSomeHeaders:
	case MSG_ShowMicroHeaders:
		if (selected_p)
			*selected_p = (command == GetPrefs()->GetHeaderStyle() ?
						   MSG_Checked : MSG_Unchecked);
		selectable_p = showingMsg;
		break;
	case MSG_AttachmentsInline:
		if (selected_p)
			*selected_p = (GetPrefs()->GetNoInlineAttachments() ?
						   MSG_Unchecked : MSG_Checked);
		selectable_p = showingMsg;
		break;
	case MSG_AttachmentsAsLinks:
		if (selected_p)
			*selected_p = (GetPrefs()->GetNoInlineAttachments() ?
						   MSG_Checked : MSG_Unchecked);
		selectable_p = showingMsg;
		break;
	case MSG_WrapLongLines:
		if (selected_p)
			*selected_p = (GetPrefs()->GetWrapLongLines() ?
						   MSG_Checked : MSG_Unchecked);
		selectable_p = showingMsg;
		break;
	default:
		if (indices == NULL && m_view)
		{
			curIndex = m_view->FindViewIndex(m_key);
			indices = &curIndex;
			numindices = 1;
		}
		return MSG_Pane::GetCommandStatus(command, indices, numindices,
										 selectable_pP, selected_p,
										 display_stringP, plural_p);
	}
	if (display_stringP)
	  *display_stringP = display_string;

	if (selectable_pP)
	  *selectable_pP = selectable_p;

	return err;
}


void 
MSG_MessagePane::GetCurMessage(MSG_FolderInfo** folder, MessageKey* key,
							   MSG_ViewIndex *index)
{
	MessageKey	curKey = (m_folder) ? m_key : MSG_MESSAGEKEYNONE;

	if (folder) *folder = m_folder;
	if (key) *key = curKey;
	if (index)
	{
		*index = (m_view && curKey != MSG_MESSAGEKEYNONE)
			? m_view->FindViewIndex(curKey) : MSG_VIEWINDEXNONE;
	}
}

int
MSG_MessagePane::GetViewedAttachments(MSG_AttachmentData** data,
									  XP_Bool* iscomplete)
{
	if (iscomplete) *iscomplete = m_doneLoading;
	return MimeGetAttachmentList(GetContext(), data);
}


void
MSG_MessagePane::FreeAttachmentList(MSG_AttachmentData* data)
{
	MimeFreeAttachmentList(data);
}


HG82821

XP_Bool MSG_MessagePane::GetThreadLineByKey(MessageKey key, MSG_MessageLine* data) 
{
	XP_ASSERT(m_view);
	if (!m_view) 
		return FALSE;

//	XP_ASSERT(key == m_key); //When we load new msg ,this isn't be true

	int numlisted = -1;
	MsgERR status = m_view->ListThreadsShort(&key, 1, data, &numlisted);
	return (status == 0 && numlisted == 1);
}


XP_Bool MSG_MessagePane::ShouldRot13Message()
{
	return m_rot13p;
}



/* This function opens a message and returns a handle to that message in the
 * msg_ptr pointer.
 *
 * The message handle will be passed to MSG_ReadMessage and MSG_CloseMessage
 * to read data and to close the message
 *
 * Return values: return a negative return value listed in merrors.h to
 * signify an error.  return zero (0) on success.
 *
 * !Set message_ptr to NULL on error!
 */

int
MSG_MessagePane::OpenMessageSock(const char *folder_name,
								 const char *msg_id, int32 msgnum,
								 void *folder_ptr, void **message_ptr,
								 int32 *content_length)
{
	if (!m_view)
		InitializeFolderAndView (folder_name);

	if (msgnum == MSG_MESSAGEKEYNONE && m_view)
	{
		MailMessageHdr *hdr = (MailMessageHdr*) m_view->GetDB()->GetDBMessageHdrForID(msg_id);
		if (hdr)
			msgnum = hdr->GetMessageKey();
	}

	if ( msgnum != MSG_MESSAGEKEYNONE ) {
	    m_key = msgnum;
		InitializeFolderAndView (folder_name);
		FE_PaneChanged(this, FALSE, MSG_PaneNotifyMessageLoaded, msgnum);
	}

	return MSG_Pane::OpenMessageSock ( folder_name, msg_id, msgnum,
									   folder_ptr, message_ptr, 
									   content_length );
}


/* Partial messages
 */


char *
MSG_MessagePane::GeneratePartialMessageBlurb(URL_Struct *url,
											 void * /*closure*/,
											 MimeHeaders *headers)

{
	char *stuff = 0;
	char *new_url = 0, *quoted = 0;
	unsigned long flags = 0;
	char dummy = 0;
	char *uidl = 0, *xmoz = 0;

	/* The message is partial if it has an X-UIDL header field, and it has
	   an X-Mozilla-Status header field which contains the `partial' bit.
	   */

	uidl = MimeHeaders_get(headers, HEADER_X_UIDL, FALSE, FALSE);
	if (!uidl) goto DONE;
	xmoz = MimeHeaders_get(headers, HEADER_X_MOZILLA_STATUS, FALSE, FALSE);
	if (!xmoz) goto DONE;

	if (1 != sscanf (xmoz, " %lx %c", &flags, &dummy)) goto DONE;
          
	if (! (flags & MSG_FLAG_PARTIAL)) goto DONE;

	quoted = NET_Escape (uidl, URL_XALPHAS);
	if (!quoted) goto DONE;
	FREEIF(uidl);

	new_url = (char *) XP_ALLOC (XP_STRLEN (url->address) +
								 XP_STRLEN (quoted) + 20);
	if (!new_url) goto DONE;

	XP_STRCPY (new_url, url->address);
	XP_ASSERT (XP_STRCHR (new_url, '?'));
	if (XP_STRCHR (new_url, '?')) {
        XP_STRCAT (new_url, "&uidl=");
	} else {
        XP_STRCAT (new_url, "?uidl=");
	}
	XP_STRCAT (new_url, quoted);
	FREEIF(quoted);

	stuff = PR_smprintf ("%s%s%s%s",
						 XP_GetString(MK_MSG_PARTIAL_MSG_FMT_1),
						 XP_GetString(MK_MSG_PARTIAL_MSG_FMT_2),
						 new_url,
						 XP_GetString(MK_MSG_PARTIAL_MSG_FMT_3));

DONE:
	FREEIF(new_url);
	FREEIF(quoted);
	FREEIF(uidl);
	FREEIF(xmoz);

	return stuff;
}

URL_Struct * MSG_MessagePane::ConstructUrlForMessage(MessageKey key)
{
	if (key == MSG_MESSAGEKEYNONE)
		key = m_key;
	return MSG_Pane::ConstructUrlForMessage(key);
}


MsgERR
MSG_MessagePane::LoadFolder(MSG_FolderInfo* f) 
{
	char	*url = NULL;
	XP_Bool	finishedLoadingFolder = FALSE;	// are we finished loading folder?
	XP_StatStruct folderst;

	if (f == m_folder) return 0;

	m_folder = f;

	if (!f)
		return CloseView();

	XP_ASSERT(f->GetType() == FOLDER_MAIL || 
			  f->GetType() == FOLDER_NEWSGROUP ||
			  f->GetType() == FOLDER_IMAPMAIL ||
			  f->GetType() == FOLDER_CATEGORYCONTAINER);

	// we need to abort any current background parsing.
	if (m_folder != NULL)
		msg_InterruptContext(GetContext(), TRUE); 

	if (m_folder && m_folder->UserNeedsToAuthenticateForFolder(FALSE) && m_master->PromptForHostPassword(GetContext(), m_folder) != 0)
		return 0;

	CloseView();

	url = f->BuildUrl(NULL, MSG_MESSAGEKEYNONE);

	ViewType typeOfView = ViewAny;

	
	MsgERR status = MessageDBView::OpenURL(url, GetMaster(),
						 				   typeOfView, &m_view, FALSE);

	
	// fire off the IMAP url to update this folder, if it is IMAP
	if ((f->GetType() == FOLDER_IMAPMAIL) && (status == eSUCCESS))
	{
		MSG_IMAPFolderInfoMail *imapFolder = f->GetIMAPFolderInfoMail();
		if (imapFolder)
		{
			imapFolder->StartUpdateOfNewlySelectedFolder(this,TRUE,NULL);
		}
		else
		{
			XP_ASSERT(FALSE);
		}
	}
	
	if (f->GetType() == FOLDER_MAIL && status != eSUCCESS /*== eOldSummaryFile*/)
	{
		MailDB	*mailDB;

		XP_Trace("blowing away old summary file\n");
		const char* pathname = ((MSG_FolderInfoMail*) f)->GetPathname();
		if (!XP_Stat(pathname, &folderst, xpMailFolderSummary) && XP_FileRemove(pathname, xpMailFolderSummary) != 0)
		{
			status = MK_MSG_CANT_OPEN;
		}
		else
		{
			MSG_Master *mailMaster = GetMaster();
			URL_Struct *url_struct;
			url_struct = NET_CreateURLStruct(url, NET_DONT_RELOAD);

			status = MailDB::Open(pathname, TRUE, &mailDB, TRUE);
			if (mailDB != NULL && (status == eSUCCESS || status == eNoSummaryFile))
			{
				status = MessageDBView::OpenViewOnDB(mailDB, 
					ViewAny, &m_view);
				mailDB->Close(); // decrement ref count.
			}
			if (m_view != NULL && m_view->GetDB() != NULL)
			{
				ParseMailboxState *parseMailboxState = new ParseMailboxState(pathname);
				parseMailboxState->SetView(m_view);  
				parseMailboxState->SetPane(this);
				parseMailboxState->SetIncrementalUpdate(FALSE);
				parseMailboxState->SetMaster(mailMaster);
				parseMailboxState->SetDB(m_view->GetDB()->GetMailDB());
				parseMailboxState->SetContext(GetContext());
				parseMailboxState->SetFolder(m_folder);
				((MSG_FolderInfoMail*)f)->SetParseMailboxState(parseMailboxState);
				// fire off url to create summary file from mailbox - will work in background
				GetURL(url_struct, FALSE);
			}
		}
	}
	else if (f->IsNews())
	{
		MSG_FolderInfoNews *newsFolder = f->GetNewsFolderInfo();
		XP_ASSERT(newsFolder);
		const char* groupname = newsFolder->GetNewsgroupName();
		if (status != eSUCCESS)
		{
			if (status == eErrorOpeningDB || status == eOldSummaryFile) // corrupt database or out of date
			{
				NewsGroupDB	*newsDB;
				const char *dbFileName = newsFolder->GetXPDBFileName();

				if (dbFileName != NULL)
					XP_FileRemove(dbFileName, xpXoverCache);
				status = NewsGroupDB::Open(url, GetMaster(), &newsDB);
				if (status == eSUCCESS)
				{
					status = MessageDBView::OpenViewOnDB(newsDB, 
						ViewAny, &m_view);
					newsDB->Close();
				}
			}
		}
		if (status == eSUCCESS)	// get new articles from server.
		{
			MSG_Master *master = GetMaster();
			URL_Struct *url_struct;
			url_struct = NET_CreateURLStruct(url, NET_DONT_RELOAD);
			ListNewsGroupState * listState = new ListNewsGroupState(url, groupname, this);
			listState->SetMaster(master);
			listState->SetView(m_view);
			newsFolder->SetListNewsGroupState(listState);
			int status = GetURL(url_struct, FALSE);
			if (status == MK_INTERRUPTED || status == MK_OFFLINE)	
			{
				if (newsFolder->GetListNewsGroupState())	// FinishXOver not called...
				{
					delete listState;
					newsFolder->SetListNewsGroupState(NULL);
				}
				StartingUpdate(MSG_NotifyAll, 0, 0);
				EndingUpdate(MSG_NotifyAll, 0, 0);
				finishedLoadingFolder = TRUE;
			}
		}
		else if (status == eBuildViewInBackground)
		{
			status = ListThreads();
		}
	}
	else if (f->GetType() == FOLDER_IMAPMAIL && status != eSUCCESS)
	{
		const char* pathname = ((MSG_FolderInfoMail*) f)->GetPathname();
		XP_FileRemove(pathname, xpMailFolderSummary);
	}
	else if (status == eSUCCESS)
	{
		finishedLoadingFolder = TRUE;
	}
	if (status == eSUCCESS)
	{
		m_view->Add(GetListener());
	}

									// imap folders loads are asynchronous
									// this notification will happen in
									// MSG_IMAPFolderInfoMail::AllFolderHeadersAreDownloaded
	if (finishedLoadingFolder && (f->GetType() != FOLDER_IMAPMAIL))
	{
		FE_PaneChanged(this, TRUE, MSG_PaneNotifyFolderLoaded, (uint32) f);
	}

	if (m_folder)
		m_folder->SummaryChanged();	// for Will - so thread pane can display counts.

	XP_FREE(url);
	return status;
}