mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-12 14:37:50 +00:00
536 lines
20 KiB
C++
536 lines
20 KiB
C++
/* -*- 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.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
|
|
#ifndef _MsgPane_H_
|
|
#define _MsgPane_H_
|
|
|
|
#include "msgprnot.h"
|
|
#include "chngntfy.h"
|
|
#include "idarray.h"
|
|
#include "errcode.h"
|
|
#include "msgundmg.h"
|
|
#include "msg.h"
|
|
#include "abcom.h" // required for adding sender or recipients to address books.
|
|
|
|
class MSG_Master;
|
|
class MessageDBView;
|
|
class MSG_FolderInfo;
|
|
class MSG_NewsHost;
|
|
class ParseMailboxState;
|
|
class msg_Background;
|
|
class OfflineImapGoOnlineState;
|
|
class MSG_FolderInfoMail;
|
|
class MSG_PostDeliveryActionInfo;
|
|
|
|
struct tImapFilterClosure;
|
|
|
|
struct msg_incorporate_state;
|
|
struct MessageHdrStruct;
|
|
|
|
|
|
|
|
class PaneListener : public ChangeListener
|
|
{
|
|
public:
|
|
PaneListener(MSG_Pane *pPane);
|
|
virtual ~PaneListener();
|
|
virtual void OnViewChange(MSG_ViewIndex startIndex, int32 numChanged,
|
|
MSG_NOTIFY_CODE changeType, ChangeListener *instigator);
|
|
virtual void OnViewStartChange(MSG_ViewIndex startIndex, int32 numChanged,
|
|
MSG_NOTIFY_CODE changeType, ChangeListener *instigator);
|
|
virtual void OnViewEndChange(MSG_ViewIndex startIndex, int32 numChanged,
|
|
MSG_NOTIFY_CODE changeType, ChangeListener *instigator);
|
|
virtual void OnKeyChange(MessageKey keyChanged, int32 flags,
|
|
ChangeListener * instigator);
|
|
virtual void OnAnnouncerGoingAway (ChangeAnnouncer *instigator);
|
|
virtual void OnAnnouncerChangingView(ChangeAnnouncer * /* instigator */, MessageDBView * /* view */) ;
|
|
virtual void StartKeysChanging();
|
|
virtual void EndKeysChanging();
|
|
|
|
protected:
|
|
MSG_Pane *m_pPane;
|
|
XP_Bool m_keysChanging; // are keys changing?
|
|
XP_Bool m_keyChanged; // has a key changed since StartKeysChanging called?
|
|
};
|
|
|
|
// If a MSG_Pane has its url chain ptr set to a non-null value,
|
|
// it calls the GetNextURL method whenever it finishes a url that is chainable.
|
|
// These include delivering queued mail, get new mail, and retrieving
|
|
// messages for offline use, oddly enough - the three kinds of urls I need to queue.
|
|
// Sadly, neither the msg_Background or MSG_UrlQueue do what I want,
|
|
// because I need to chain network urls that have their own exit functions
|
|
// and indeed chain urls themselves.
|
|
class MSG_PaneURLChain
|
|
{
|
|
public:
|
|
MSG_PaneURLChain(MSG_Pane *pane);
|
|
virtual ~MSG_PaneURLChain();
|
|
virtual int GetNextURL(); // return 0 to stop chaining.
|
|
protected:
|
|
MSG_Pane *m_pane;
|
|
};
|
|
|
|
class MSG_Pane : public MSG_PrefsNotify {
|
|
public:
|
|
|
|
// hack..
|
|
// Find a pane of the given type that matches the given context. If none,
|
|
// find some other pane of the given type (if !contextMustMatch).
|
|
static MSG_Pane* FindPane(MWContext* context,
|
|
MSG_PaneType type = MSG_ANYPANE,
|
|
XP_Bool contextMustMatch = FALSE);
|
|
|
|
static XP_Bool PaneInMasterList(MSG_Pane *pane);
|
|
|
|
|
|
static MSG_PaneType PaneTypeForURL(const char *url);
|
|
XP_Bool NavigationGoesToNextFolder(MSG_MotionType motionType);
|
|
MSG_Pane(MWContext* context, MSG_Master* master);
|
|
virtual ~MSG_Pane();
|
|
|
|
void SetFEData(void*);
|
|
void* GetFEData();
|
|
|
|
virtual XP_Bool IsLinePane();
|
|
virtual MSG_PaneType GetPaneType() ;
|
|
virtual void NotifyPrefsChange(NotifyCode /*code*/) ;
|
|
|
|
virtual MSG_Pane* GetParentPane();
|
|
|
|
MSG_Pane* GetNextPane() {return m_nextPane;}
|
|
|
|
MSG_Pane *GetFirstPaneForContext(MWContext *context);
|
|
|
|
MSG_Pane *GetNextPaneForContext(MSG_Pane *pane, MWContext *context);
|
|
|
|
virtual MWContext* GetContext();
|
|
MSG_Prefs* GetPrefs();
|
|
|
|
MSG_Master* GetMaster() {return m_master;}
|
|
|
|
// these are here mostly to allow thread panes and message panes
|
|
// to handle the same commands - if we had a common base class
|
|
// for these (other than MSG_Pane), we could put these there.
|
|
virtual MessageDBView *GetMsgView();
|
|
virtual void SetMsgView(MessageDBView *);
|
|
virtual void SwitchView(MessageDBView *) ;
|
|
virtual MSG_FolderInfo *GetFolder() ;
|
|
virtual void SetFolder(MSG_FolderInfo *info);
|
|
virtual void StartingUpdate(MSG_NOTIFY_CODE /*code*/, MSG_ViewIndex /*where*/,
|
|
int32 /*num*/);
|
|
virtual void EndingUpdate(MSG_NOTIFY_CODE /*code*/, MSG_ViewIndex /*where*/,
|
|
int32 /*num*/);
|
|
|
|
// do not use this function unless you really know what you are doing.
|
|
// Currently, it is used when a url queue for loading an imap folder
|
|
// is interrupted
|
|
virtual void CrushUpdateLevelToZero();
|
|
|
|
virtual void OnFolderChanged(MSG_FolderInfo *folder);
|
|
virtual void OnFolderDeleted (MSG_FolderInfo *folder);
|
|
virtual void OnFolderAdded (MSG_FolderInfo *folder, MSG_Pane *instigator);
|
|
virtual void OnFolderKeysAreInvalid (MSG_FolderInfo *folder);
|
|
|
|
/* New address book requires a destination address book because it supports multiple ABs */
|
|
virtual MsgERR AddToAddressBook(MSG_CommandType command, MSG_ViewIndex*indices, int32 numIndices, AB_ContainerInfo * destAB);
|
|
|
|
virtual MsgERR DoCommand(MSG_CommandType command,
|
|
MSG_ViewIndex* indices, int32 numindices);
|
|
virtual MsgERR GetMailForAFolder(MSG_FolderInfo *folder);
|
|
|
|
virtual MsgERR GetCommandStatus(MSG_CommandType command,
|
|
const MSG_ViewIndex* indices, int32 numindices,
|
|
XP_Bool *selectable_p,
|
|
MSG_COMMAND_CHECK_STATE *selected_p,
|
|
const char **display_string,
|
|
XP_Bool *plural_p);
|
|
|
|
virtual MsgERR SetToggleStatus(MSG_CommandType command,
|
|
MSG_ViewIndex* indices, int32 numindices,
|
|
MSG_COMMAND_CHECK_STATE value);
|
|
|
|
virtual MSG_COMMAND_CHECK_STATE GetToggleStatus(MSG_CommandType command,
|
|
MSG_ViewIndex* indices,
|
|
int32 numindices);
|
|
|
|
virtual MsgERR GetNavigateStatus(MSG_MotionType motion, MSG_ViewIndex index,
|
|
XP_Bool *selectable_p,
|
|
const char **display_string);
|
|
|
|
MSG_FolderInfo* FindFolderOfType(int type);
|
|
|
|
|
|
MSG_FolderInfo* FindMailFolder(const char* pathname,
|
|
XP_Bool createIfMissing);
|
|
|
|
virtual MsgERR MarkReadByDate (time_t startDate, time_t endDate);
|
|
|
|
virtual XP_Bool SetMessagePriority(MessageKey key, MSG_PRIORITY priority);
|
|
|
|
MsgERR ComposeNewMessage();
|
|
//ComposeMessageToMany calls ComposeNewMessage if nothing was selected
|
|
//otherwise it builds a string containing selected groups to post to.
|
|
MsgERR ComposeMessageToMany(MSG_ViewIndex* indices, int32 numIndices);
|
|
|
|
virtual MsgERR ComposeNewsMessage(MSG_FolderInfo *folder);
|
|
char* CreateForwardSubject(MessageHdrStruct* header);
|
|
|
|
virtual void InterruptContext(XP_Bool safetoo);
|
|
|
|
virtual int BeginOpenFolderSock(const char *folder_name,
|
|
const char *message_id, int32 msgnum,
|
|
void **folder_ptr);
|
|
virtual int FinishOpenFolderSock(const char* folder_name,
|
|
const char* message_id,
|
|
int32 msgnum, void** folder_ptr);
|
|
virtual void CloseFolderSock(const char* folder_name, const char* message_id,
|
|
int32 msgnum, void* folder_ptr);
|
|
|
|
virtual int OpenMessageSock(const char *folder_name, const char *msg_id,
|
|
int32 msgnum, void *folder_ptr, void **message_ptr,
|
|
int32 *content_length);
|
|
virtual int ReadMessageSock(const char* folder_name, void* message_ptr,
|
|
const char* message_id, int32 msgnum, char* buffer,
|
|
int32 buffer_size);
|
|
virtual void CloseMessageSock(const char* folder_name, const char* message_id,
|
|
int32 msgnum, void* message_ptr);
|
|
|
|
virtual MsgERR GetKeyFromMessageId (const char *message_id, MessageKey *outId);
|
|
virtual int MarkMessageKeyRead(MessageKey key, const char* xref);
|
|
|
|
virtual MSG_ViewIndex GetThreadIndexOfMsg(MessageKey key);
|
|
|
|
virtual MsgERR ViewNavigate(MSG_MotionType /*motion*/,
|
|
MSG_ViewIndex /*startIndex*/,
|
|
MessageKey * /*resultKey*/, MSG_ViewIndex * /*resultIndex*/,
|
|
MSG_ViewIndex * /*pThreadIndex*/,
|
|
MSG_FolderInfo ** /*ppFolderInfo*/);
|
|
|
|
|
|
#ifdef XP_UNIX
|
|
void IncorporateFromFile(XP_File infid, void (*donefunc)(void*, XP_Bool),
|
|
void* doneclosure);
|
|
#endif
|
|
|
|
XP_Bool BeginMailDelivery();
|
|
void EndMailDelivery();
|
|
void* IncorporateBegin(FO_Present_Types format_out, char* pop3_uidl,
|
|
URL_Struct* url, uint32 flags);
|
|
MsgERR IncorporateWrite(void* closure, const char* block, int32 length);
|
|
MsgERR IncorporateComplete(void* closure);
|
|
MsgERR IncorporateAbort(void* closure, int status);
|
|
void ClearSenderAuthedFlag(void *closure);
|
|
MsgERR GetNewNewsMessages(MSG_Pane *parentPane, MSG_FolderInfo *folder, XP_Bool getOld = FALSE);
|
|
MsgERR GetNewMail(MSG_Pane *parentPane, MSG_FolderInfo *folder);
|
|
static void GetNewMailExit (URL_Struct *URL_s, int status, MWContext *window_id);
|
|
|
|
char *GetUIDL() {return m_incUidl;}
|
|
|
|
MsgERR UpdateNewsCounts(MSG_NewsHost* host);
|
|
|
|
virtual int GetURL (URL_Struct *url, XP_Bool isSafe);
|
|
// return a url_struct with a url that refers to this pane.
|
|
virtual URL_Struct * ConstructUrlForMessage(MessageKey key = MSG_MESSAGEKEYNONE);
|
|
static URL_Struct * ConstructUrl(MSG_FolderInfo *folder);
|
|
MsgERR TrashMessages (MSG_ViewIndex* indices, int32 numindices);
|
|
MsgERR DeleteMessages (MSG_FolderInfo *folder, MSG_ViewIndex* indices, int32 numindices);
|
|
|
|
static void CancelDone(URL_Struct *url, int status, MWContext *context);
|
|
int CancelMessage(MSG_ViewIndex index);
|
|
|
|
// Move/copy operations
|
|
|
|
// made these virtual for the search as view operations on the search pane.
|
|
virtual MsgERR MoveMessages (const MSG_ViewIndex *indices,
|
|
int32 numIndices,
|
|
MSG_FolderInfo *folder);
|
|
|
|
virtual MsgERR CopyMessages (const MSG_ViewIndex *indices,
|
|
int32 numIndices,
|
|
MSG_FolderInfo *folder,
|
|
XP_Bool deleteAfterCopy);
|
|
|
|
virtual MSG_DragEffect DragMessagesStatus (const MSG_ViewIndex *indices,
|
|
int32 numIndices,
|
|
MSG_FolderInfo *folder,
|
|
MSG_DragEffect request);
|
|
|
|
MsgERR CopyMessages (const MSG_ViewIndex *indices,
|
|
int32 numIndices,
|
|
const char *folderPath,
|
|
XP_Bool deleteAfterCopy);
|
|
|
|
MSG_DragEffect DragMessagesStatus (const MSG_ViewIndex *indices,
|
|
int32 numIndices,
|
|
const char *folderPath,
|
|
MSG_DragEffect request);
|
|
|
|
|
|
// moved from MSG_FolderPane; this enables compressing a folder
|
|
// in a compose pane in case we need to reclaim some disk space
|
|
// after we send/save a draft
|
|
MsgERR CompressAllFolders();
|
|
MsgERR EmptyTrash(MSG_FolderInfo *curFolder);
|
|
MsgERR EmptyImapTrash(MSG_IMAPHost *host);
|
|
|
|
// move some implementation from MSG_FolderPane. Compress the one
|
|
// specified mail folder whether it be imap or pop
|
|
MsgERR CompressOneMailFolder(MSG_FolderInfoMail *mailFolder);
|
|
|
|
int BeginCompressFolder(URL_Struct* url, const char* foldername,
|
|
void** closure);
|
|
int FinishCompressFolder(URL_Struct* url, const char* foldername,
|
|
void* closure);
|
|
int CloseCompressFolderSock(URL_Struct* url, void* closure);
|
|
|
|
// saves the corresponding keys in m_saveKeys.
|
|
int SaveIndicesAsKeys(MSG_ViewIndex* indices, int32 numindices);
|
|
|
|
virtual int32 GetNewsRCCount(MSG_NewsHost* host);
|
|
virtual char* GetNewsRCGroup(MSG_NewsHost* host);
|
|
virtual int DisplaySubscribedGroup(MSG_NewsHost* host,
|
|
const char *group,
|
|
int32 oldest_message,
|
|
int32 youngest_message,
|
|
int32 total_messages,
|
|
XP_Bool nowvisiting);
|
|
|
|
virtual int AddNewNewsGroup(MSG_NewsHost* host, const char* groupname,
|
|
int32 oldest, int32 youngest, const char *flag, XP_Bool bXactiveFlags);
|
|
|
|
MsgERR CheckForNew(MSG_NewsHost* host);
|
|
|
|
virtual UndoManager *GetUndoManager ();
|
|
virtual BacktrackManager *GetBacktrackManager();
|
|
|
|
MsgERR DeliverQueuedMessages();
|
|
int BeginDeliverQueued(URL_Struct* url, void** closure);
|
|
int FinishDeliverQueued(URL_Struct* url, void* closure);
|
|
int CloseDeliverQueuedSock(URL_Struct* url, void* closure);
|
|
static void PostDeliverQueuedExitFunc(URL_Struct *url, int status, MWContext *context);
|
|
|
|
// related to running the asynch imap filters in a pane
|
|
virtual void StoreImapFilterClosureData( tImapFilterClosure *closureData );
|
|
virtual void ClearImapFilterClosureData();
|
|
virtual tImapFilterClosure *GetImapFilterClosureData();
|
|
|
|
// set when loading an imap folder
|
|
MSG_IMAPFolderInfoMail *GetLoadingImapFolder() { return m_loadingImapFolder ; }
|
|
void SetLoadingImapFolder(MSG_IMAPFolderInfoMail *folder) { m_loadingImapFolder=folder ; }
|
|
|
|
// set when the current folder load is kicking off imap filters
|
|
void SetActiveImapFiltering(XP_Bool isFiltering) { m_ActiveImapFilters = isFiltering; }
|
|
XP_Bool GetActiveImapFiltering() { return m_ActiveImapFilters; }
|
|
|
|
|
|
void SetGoOnlineState(OfflineImapGoOnlineState *state) { m_goOnlineState = state; }
|
|
OfflineImapGoOnlineState *GetGoOnlineState() { return m_goOnlineState; }
|
|
|
|
// Removes this pane from the main pane list. This is so that calls to
|
|
// MSG_Master::FindPaneOfType() won't find this one (because, for example,
|
|
// we know we're about to delete this one.)
|
|
void UnregisterFromPaneList();
|
|
|
|
|
|
// These routines should be used only by the msg_Background class.
|
|
msg_Background* GetCurrentBackgroundJob() {return m_background;}
|
|
void SetCurrentBackgroundJob(msg_Background* b) {m_background = b;}
|
|
|
|
void ClearURLChain() {delete m_urlChain; m_urlChain = NULL;}
|
|
MSG_PaneURLChain *GetURLChain() {return m_urlChain;}
|
|
void SetURLChain(MSG_PaneURLChain *chain) {m_urlChain = chain;}
|
|
static void GetNextURLInChain_CB(URL_Struct* urlstruct, int status, MWContext* context);
|
|
void GetNextURLInChain();
|
|
|
|
// Open Message as Draft
|
|
MsgERR OpenMessageAsDraft(MSG_ViewIndex* indices, int32 numIndices,
|
|
XP_Bool bFwdInline = FALSE);
|
|
|
|
// News server admin stuff
|
|
XP_Bool ModerateNewsgroupStatus (MSG_FolderInfo *folder);
|
|
MsgERR ModerateNewsgroup (MSG_FolderInfo *folder);
|
|
XP_Bool NewNewsgroupStatus (MSG_FolderInfo *folder);
|
|
MsgERR NewNewsgroup (MSG_FolderInfo *folder, XP_Bool createCategory = FALSE);
|
|
static int CompareViewIndices (const void *v1, const void *v2);
|
|
MsgERR ApplyCommandToIndices(MSG_CommandType command, MSG_ViewIndex* indices, int32 numIndices);
|
|
void SetShowingProgress(XP_Bool showingProgress) {m_showingProgress = showingProgress;}
|
|
|
|
MsgERR ManageMailAccount(MSG_FolderInfo *folder);
|
|
static void ManageMailAccountExitFunc(URL_Struct *url,
|
|
int status,
|
|
MWContext *context);
|
|
|
|
MsgERR PreflightDeleteFolder (MSG_FolderInfo *folder, XP_Bool getUserConfirmation);
|
|
|
|
void SetNumberOfNewImapMailboxes(uint32 numberNew) { m_NumberOfNewImapMailboxes = numberNew; }
|
|
uint32 GetNumberOfNewImapMailboxes() { return m_NumberOfNewImapMailboxes; }
|
|
virtual PaneListener *GetListener();
|
|
MsgERR CloseView();
|
|
MsgERR ListThreads();
|
|
void GroupNotFound(MSG_NewsHost* host, const char *group, XP_Bool opening);
|
|
|
|
XP_Bool DisplayingRecipients ();
|
|
|
|
void SetPreImapFolderVerifyUrlExitFunction(Net_GetUrlExitFunc *func) { m_PreImapFolderVerifyUrlExitFunction = func; }
|
|
Net_GetUrlExitFunc *GetPreImapFolderVerifyUrlExitFunction() { return m_PreImapFolderVerifyUrlExitFunction; }
|
|
|
|
void SetRequestForReturnReceipt(XP_Bool isNeeded);
|
|
XP_Bool GetRequestForReturnReceipt();
|
|
|
|
void SetSendingMDNInProgress(XP_Bool inProgress);
|
|
XP_Bool GetSendingMDNInProgress();
|
|
|
|
MSG_PostDeliveryActionInfo *GetPostDeliveryActionInfo ();
|
|
void SetPostDeliveryActionInfo ( MSG_PostDeliveryActionInfo *actionInfo );
|
|
virtual void SetIMAPListInProgress(XP_Bool inProgress);
|
|
virtual XP_Bool IMAPListInProgress();
|
|
virtual void SetIMAPListMailboxExist(XP_Bool bExist);
|
|
virtual XP_Bool IMAPListMailboxExist();
|
|
|
|
static void PostLiteSelectExitFunc( URL_Struct *url, int status, MWContext *context);
|
|
static void PostDeleteIMAPOldDraftUID(URL_Struct* url_struct, int status, MWContext *context);
|
|
void DeleteIMAPOldDraftUID(MSG_PostDeliveryActionInfo *actionInfo, MSG_Pane *urlPane = NULL);
|
|
int GetNumstack() { return m_numstack; };
|
|
void AdoptProgressContext(MWContext *context);
|
|
|
|
char* MakeMailto(const char *to, const char *cc,
|
|
const char *newsgroups,
|
|
const char *subject, const char *references,
|
|
const char *attachment, const char *host_data,
|
|
XP_Bool xxx_p, XP_Bool sign_p);
|
|
|
|
/* used with the new address book....all panes must register a entry property sheet call back function if
|
|
they want the ability to add sender/all to the address book */
|
|
void SetShowPropSheetForEntryFunc(AB_ShowPropertySheetForEntryFunc * func) { m_entryPropSheetFunc = func; }
|
|
AB_ShowPropertySheetForEntryFunc * GetShowPropSheetForEntryFunc() { return m_entryPropSheetFunc;}
|
|
|
|
protected:
|
|
char* ComputeNewshostArg();
|
|
// GetNewMail helper routines
|
|
msg_incorporate_state *CreateIncorporateState ();
|
|
int OpenDestFolder(msg_incorporate_state* state);
|
|
int CloseDestFolder(msg_incorporate_state* state);
|
|
void ResolveIndices (MessageDBView *view, const MSG_ViewIndex *indices, int32 numIndices, IDArray*);
|
|
static void IncorporateShufflePartial_s(URL_Struct *url, int status,
|
|
MWContext *context);
|
|
virtual void IncorporateShufflePartial(URL_Struct *url, int status,
|
|
MWContext *context);
|
|
|
|
void ClearNewInOpenFolders(MSG_FolderInfo *folderOfGetNewMsgs);
|
|
ParseMailboxState *GetParseMailboxState(const char *folderName);
|
|
|
|
// Callback for FE_PromptForFileName
|
|
static void SaveMessagesAsCB(MWContext *context, char *file_name,
|
|
void *closure);
|
|
|
|
// callback function for showing a property sheet pane. Used by address book panes, message pane and thread pane...
|
|
AB_ShowPropertySheetForEntryFunc * m_entryPropSheetFunc;
|
|
|
|
static void UpdateNewsCountsDone_s(URL_Struct*, int status, MWContext*);
|
|
virtual void UpdateNewsCountsDone(int status);
|
|
|
|
// Whether newly discovered newsgroups should have the "new" bit set on
|
|
// them.
|
|
virtual XP_Bool AddGroupsAsNew();
|
|
|
|
static void CheckForNewDone_s(URL_Struct* url_struct, int status,
|
|
MWContext* context);
|
|
virtual void CheckForNewDone(URL_Struct* url_struct, int status,
|
|
MWContext* context);
|
|
|
|
virtual XP_Bool ShouldDeleteInBackground();
|
|
|
|
|
|
IDArray m_saveKeys; // this is used to save keys used for a
|
|
// pane command in a callback from FE_PromptForFileName.
|
|
// This is ugly but we only get one closure
|
|
// and that's our this ptr.
|
|
|
|
static MSG_Pane* MasterList;
|
|
MSG_Pane* m_nextInMasterList;
|
|
|
|
|
|
MSG_Pane* m_nextPane; // Link of panes created with the same master.
|
|
|
|
|
|
MSG_Master* m_master;
|
|
MWContext* m_context;
|
|
MSG_Prefs* m_prefs;
|
|
void* m_fedata;
|
|
int m_numstack; // used for DEBUG, and to tell listeners
|
|
// if we're in an update block.
|
|
|
|
// get new mail handling state
|
|
char *m_incUidl; // Special UIDL to inc from, if any. hack
|
|
|
|
int32 m_numNewGroups; // How many new newsgroups have been noticed
|
|
// from the news server.
|
|
|
|
UndoManager *m_undoManager;
|
|
BacktrackManager *m_backtrackManager;
|
|
|
|
tImapFilterClosure *m_ImapFilterData;
|
|
|
|
OfflineImapGoOnlineState *m_goOnlineState;
|
|
|
|
XP_Bool m_ActiveImapFilters;
|
|
MSG_IMAPFolderInfoMail *m_loadingImapFolder;
|
|
|
|
static XP_Bool m_warnedInvalidHostTable;
|
|
|
|
msg_Background* m_background;
|
|
MSG_PaneURLChain *m_urlChain;
|
|
MSG_NewsHost* m_hostCheckingForNew;
|
|
time_t m_checkForNewStartTime;
|
|
XP_Bool m_showingProgress;
|
|
XP_Bool m_requestForReturnReceipt;
|
|
XP_Bool m_sendingMDNInProgress;
|
|
|
|
uint32 m_NumberOfNewImapMailboxes;
|
|
|
|
Net_GetUrlExitFunc *m_PreImapFolderVerifyUrlExitFunction;
|
|
MSG_PostDeliveryActionInfo *m_actionInfo;
|
|
XP_Bool m_imapListInProgress;
|
|
XP_Bool m_imapListMailboxExist;
|
|
|
|
msg_YesNoDontKnow m_displayRecipients;
|
|
MWContext *m_progressContext;
|
|
};
|
|
|
|
|
|
/* Message post delivery action info
|
|
* Used for deleting draft message when done sending
|
|
* or turning on the Replied/Forwarded flag after
|
|
* successfully sending/forwarding a message
|
|
*/
|
|
|
|
class MSG_PostDeliveryActionInfo : public MSG_ZapIt
|
|
{
|
|
public:
|
|
MSG_PostDeliveryActionInfo(MSG_FolderInfo *folderInfo);
|
|
|
|
MSG_FolderInfo *m_folderInfo;
|
|
XPDWordArray m_msgKeyArray; /* origianl message keyArray */
|
|
uint32 m_flags;
|
|
};
|
|
|
|
|
|
|
|
#endif /* _MsgPane_H_ */
|