/* -*- 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. */ /* msgcom.h --- prototypes for the mail/news reader module. Created: Jamie Zawinski , 10-May-95. */ #ifndef _MSGCOM_H_ #define _MSGCOM_H_ #include "libmime.h" #define SUBSCRIBE_USE_OLD_API /* =========================================================================== This file defines all of the types and prototypes for communication between the msg library, which implements the mail and news applications, and the various front ends. Functions beginning with MSG_ are defined in the library, and are invoked by the front ends in response to user activity. Functions beginning with FE_ are defined by the front end, and are invoked by the message library to get things to happen on the screen. The main parts of this file are listed below: COMMAND NUMBERS CONSTANTS AND ENUMS FLAGS AND MASKS TYPES AND STRUCTS INIT/CREATE RANDOM CORE FUNCTIONS (to sort) PREFERENCES LIST CALLBACKS HOSTS SUBSCRIBE WINDOW OFFLINE NEWS OFFLINE IMAP QUERIES BIFF OTHER INTERFACES SECURE MAIL COMPOSE WINDOW =========================================================================== */ #include "xp_mcom.h" #include "xp_core.h" #include "ntypes.h" #include "msgtypes.h" /* =========================================================================== COMMAND NUMBERS =========================================================================== */ /* This enumerates all of the mail/news-specific commands (those which are not shared with the web browsers. The front ends should invoke each of these menu items through the MSG_Command() function like so: MSG_Command (context, MSG_PostReply); This interface is used for selections of normal menu items, toolbar buttons, and keyboard equivalents. Clicks in the scrolling list windows, drag-and-drop, and the "folders" menus are handled differently. Different items are meaningful in different sets of panes. The comments indicate which: f: Usable in folder panes (either mail or news) fn: Usable only in news folderpanes fm: Usable only in mail folderpanes t: Usable in thread panes tn: Usable only in news threadpanes tm: Usable only in mail threadpanes m: Usable in message panes mn: Usable only in news messagepanes mm: Usable only in mail messagepanes c: Usable in composition panes sub: Usable in the subscribe pane In general, an item which works on folders can either be called on the folder pane (in which case it effects the specified folders), or on a threadpane (in which case it effects the folder being displayed in the threadpane). Similarly, items which work on messages can be either called on a threadpane or on a messagepane. Also, in general, commands useable in news folder pane work in the category pane as well. */ typedef enum { /* FILE MENU ========= */ MSG_GetNewMail, /* fm: Gets new mail messages, and appends them to the appropriate folders. This is an asynchronous operation; it will eventually cause FE_ListChangeStarting and FE_ListChangeFinished to be called on any threadpanes displaying a folder which is modified. */ MSG_GetNextChunkMessages, /* f,t Get the next N news messages, based on chunk size. */ MSG_UpdateMessageCount, /* f,t,m News only - Update the message counts */ MSG_DeliverQueuedMessages, /* f,t,m: Deliver messages waiting to be delivered in the queued folder. */ MSG_OpenFolder, /* fm: Prompt the user for the full pathname of a mail file, and creates an entry for it (i.e., calls MSG_CreateFolder). */ MSG_NewFolder, /* f,t,m: Prompt the user for a new folder or subfolder name, and creates it (i.e., calls MSG_CreateFolder) */ MSG_CompressFolder, /* fm: Causes the given folders to be compressed. */ MSG_CompressAllFolders, /* fm: Causes all the folders to be compressed. */ MSG_DoRenameFolder, /* fm: Prompt the user for a new folder or subfolder name, and renames the selected folder to have that name (i.e., calls MSG_RenameFolder()). */ MSG_AddNewsGroup, /* fn: Prompts the user for a newsgroup name, and adds it to the list of newsgroups (i.e., subscribes the user). */ MSG_EmptyTrash, /* fm: Causes the trash folder to be emptied, and all the folders to be compressed. */ MSG_Unsubscribe, /* f, Unsubscribe to the selected newsgroup(s) Delete currently does this as well. */ MSG_ManageMailAccount, /* f: Prompts the user for mail account password if needed and brings up the GURL web page */ MSG_Print, /* not a command - used for selectability only */ MSG_NewNewsgroup, /* ft: Prompts the user for a new newsgroup name */ /* and brings up the NGURL web page */ MSG_ModerateNewsgroup, /* ft: brings up the MODURL web page for the */ /* selected group */ MSG_NewCategory, /* ft: Prompts the user for a new category name */ /* and brings up the NGURL web page */ /* VIEW/SORT MENUS =============== */ MSG_ReSort, /* t: Re-apply the current sort. */ MSG_SortBackward, /* t: Reverse the order of the sort. */ MSG_SortByDate, /* t: Sort in chronological order. */ MSG_SortBySubject, /* t: Sort alphabetized by subject. */ MSG_SortBySender, /* t: Sort alphabetized by sender. */ MSG_SortByMessageNumber, /* t: Sort in order stored in mail folder, or in numerical article number if news. */ MSG_SortByThread, /* t: Sort in threads. */ MSG_SortByPriority, /* t: Sort by priority - highest first. */ MSG_SortByStatus, /* t: Sort by message status - new first. */ MSG_SortBySize, /* t: Sort by size */ MSG_SortByFlagged, /* t: Sort by flag state */ MSG_SortByUnread, /* t: Sort by unread state */ MSG_ViewAllThreads, /* t: (except for killed threads) -default */ MSG_ViewKilledThreads, /* t: Show all incl. killed threads */ MSG_ViewThreadsWithNew, /* t: Show only threads with new messages */ MSG_ViewWatchedThreadsWithNew,/* t: Show only watched thrds with new msgs */ MSG_ViewNewOnly, /* t: Show only new messages */ MSG_Rot13Message, /* m: Apply fancy rot13 encryption. */ MSG_AttachmentsInline, /* m: Display attachments in line. */ MSG_AttachmentsAsLinks, /* m: Display attachments as links */ MSG_WrapLongLines, /* EDIT MENU ========= */ MSG_Undo, /* ftm: Undoes the last operation. */ MSG_Redo, /* ftm: Redoes the last undone operation. */ MSG_DeleteMessage, /* tm, mm: Causes the given messages to be deleted. */ MSG_DeleteFolder, /* fm, tm: Causes the given folders to be deleted. */ MSG_CancelMessage, /* tn, mn: Causes the given messages to be cancelled, if possible. */ MSG_DeleteMessageNoTrash, /* tm, mm: Causes the given messages to be deleted w/o getting copied to trash. */ /* MESSAGE MENU ============ */ MSG_EditAddressBook, /* f,t,m,c: Bring up the address book. */ MSG_EditAddress, /* m: Bring up the address book entry for the sender of this message. */ MSG_AddSender, /* t,m: Add the sender of this message. to the address book */ MSG_AddAll, /* t,m: Add all recipients of this message. to the address book */ MSG_PostNew, /* fn,tn: Post a new message to this newsgroup. */ MSG_PostReply, /* tn,mn: Post a followup message to this article. */ MSG_PostAndMailReply, /* tn,mn: Post a followup message to this article, mailing a copy to the author. */ MSG_MailNew, /* f,t,m,c: Create a new mail composition. */ MSG_ReplyToSender, /* t,m: E-mail a reply to the sender of this message. */ MSG_ReplyToAll, /* t,m: E-mail (& possibly post) a reply to everyone who saw this message. */ MSG_ForwardMessage, /* t,m: Forward these messages to someone. */ MSG_ForwardMessageQuoted, /* t,m: Forward this message, quoting it inline. */ MSG_MarkMessagesRead, /* t,m: Mark the message as read. */ MSG_MarkMessagesUnread, /* t,m: Mark the message as unread. */ MSG_ToggleMessageRead, /* t,m: Toggle whether the message has been read. */ MSG_MarkMessages, /* tn: flag the passed messages,either for retrieval or just to mark them */ MSG_UnmarkMessages, /* tn: unflag passed messages */ MSG_ToggleThreadKilled, /* t: toggle the killed status of the message's thread */ MSG_ToggleThreadWatched, /* t: toggle the watched status of the message's thread */ MSG_SaveMessagesAs, /* t,m: Prompt the user for a filename, and save the given messages into it. */ MSG_SaveMessagesAsAndDelete, /* t,m: Prompt the user for a filename, and save the given messages into it, and then delete the messages. */ MSG_RetrieveMarkedMessages, /* fn, tn Retrieve the messages marked for retrieval */ MSG_RetrieveSelectedMessages, /* fn, tn Retrieve the selected messages for offline use. */ MSG_OpenMessageAsDraft, /* t,m: Open the selected message as a draft message. Ready to send or further editing. */ /* GO MENU ======= */ MSG_MarkThreadRead, /* t,m: Mark all messages in the same thread as these as read.*/ MSG_MarkAllRead, /* t: Mark all messages in this folder as read. */ /* OPTIONS MENU ============ */ MSG_ShowAllMessages, /* t: Change the view to show all messages. */ MSG_ShowOnlyUnreadMessages, /* t: Change the view to show only unread messages. */ MSG_ShowMicroHeaders, /* m: Change to show very compact headers. */ MSG_ShowSomeHeaders, /* m: Change to show interesting headers. */ MSG_ShowAllHeaders, /* m: Change to show all headers. */ /* COMPOSITION FILE MENU ===================== */ MSG_SendMessage, /* c: Send the composition. */ MSG_SendMessageLater, /* c: Queue the composition to be sent later. */ MSG_Attach, /* c: Bring up the attachment dialogs. */ MSG_SaveDraft, /* c: Save draft */ MSG_SaveDraftThenClose, /* c: Save draft and then close the compose pane */ MSG_SaveTemplate, /* c: Save as template */ /* COMPOSITION VIEW MENU ===================== */ MSG_ShowFrom, /* c: Toggle showing the From header. */ MSG_ShowReplyTo, /* c: Toggle showing the ReplyTo header. */ MSG_ShowTo, /* c: Toggle showing the To header. */ MSG_ShowCC, /* c: Toggle showing the Const Char header. */ MSG_ShowBCC, /* c: Toggle showing the BCC header. */ MSG_ShowFCC, /* c: Toggle showing the FCC header. */ MSG_ShowPostTo, /* c: Toggle showing the PostTo header. */ MSG_ShowFollowupTo, /* c: Toggle showing the FollowupTo header. */ MSG_ShowSubject, /* c: Toggle showing the Subject header. */ MSG_ShowAttachments, /* c: Toggle showing the Attachments header. */ /* COMPOSITION OPTIONS MENU ======================== */ MSG_SendFormattedText, /* c: Toggle HTML mode. */ MSG_AttachAsText, /* c: ??? ###tw */ MSG_SendEncrypted, MSG_SendSigned, /* SUBSCRIBE PANE ============== */ MSG_ToggleSubscribed, /* sub: Changes the subscribed state of the given newsgroups. */ MSG_SetSubscribed, /* sub: Sets the subscribed state of given newsgroups / IMAP folders to Subscribed */ MSG_ClearSubscribed, /* sub: Sets the subscribed state of given newsgroups / IMAP folders to Unsubscribed */ MSG_FetchGroupList, /* sub: Causes us to go to the newsserver and re-fetch the entire list of newsgroups. */ MSG_ExpandAll, /* sub: Expands everything under the given lines. */ MSG_CollapseAll, /* sub: Collapses everything under the given lines. */ MSG_ClearNew, /* sub: Clears the list of new newsgroups. */ MSG_CheckForNew, /* sub: Checks the server for new newsgroups. */ /* CATEGORY PANE ============= */ MSG_MarkCategoryRead, /* cat: Mark the passed categories read */ MSG_MarkCategoryUnRead, /* cat: Mark the passed categories unread */ MSG_KillCategory /* cat: kill/ignore/unsubscribe the category */ } MSG_CommandType; /* =========================================================================== CONSTANTS AND ENUMS =========================================================================== */ /* Several things want to know this (including libnet/mknews.c) */ #define NEWS_PORT 119 #define SECURE_NEWS_PORT 563 #define MSG_MAXSUBJECTLENGTH 160 #define MSG_MAXAUTHORLENGTH 60 #define MSG_MAXGROUPNAMELENGTH 128 typedef enum { MSG_Pop3 = 0, MSG_Imap4 = 1, MSG_MoveMail = 2, MSG_Inbox = 3 } MSG_SERVER_TYPE; /* The font type which should be used for presentation of cited text. The values are the same numeric values that are stored in the prefs db. */ typedef enum { MSG_PlainFont = 0, MSG_BoldFont = 1, MSG_ItalicFont = 2, MSG_BoldItalicFont = 3 } MSG_FONT; /* The font size which should be used for presentation of cited text. */ typedef enum { MSG_NormalSize, MSG_Bigger, MSG_Smaller } MSG_CITATION_SIZE; typedef enum { MSG_NotUsed, MSG_Checked, MSG_Unchecked } MSG_COMMAND_CHECK_STATE; /* UndoStatus is returned by Undo and Redo to indicate whether the undo/redo action is complete (i.e., operation is synchronous and was successful), or in progress (undo action kicked off a url), or it failed. */ typedef enum { UndoError, /* Should we remove the undo obj (?) Hmmm ...*/ UndoComplete, /* Synchronous undo status*/ UndoInProgress, /* Asynchronous undo status*/ UndoFailed, /* Should we remove the undo obj (?) Hmmm...*/ UndoInterrupted } UndoStatus; typedef enum { UndoIdle, /* Normal situation */ UndoUndoing, /* We are Undoing ...*/ UndoRedoing /* We are Redoing ...*/ } UndoMgrState; /* Message priorities as determined by X-Priority hdr, or Priority header? */ typedef enum { MSG_PriorityNotSet = 0, MSG_NoPriority = 1, MSG_LowestPriority, MSG_LowPriority, MSG_NormalPriority, MSG_HighPriority, MSG_HighestPriority } MSG_PRIORITY; /* Message Compose Editor Type */ typedef enum { MSG_DEFAULT = 0, MSG_PLAINTEXT_EDITOR, MSG_HTML_EDITOR } MSG_EditorType; /* What kind of change was made to a list. Used in calls to FE_ListChangeStarting and FE_ListChangeFinished. */ typedef enum { MSG_NotifyNone, /* No change; this call is just being used to potentially nest other sets of calls inside it. The "where" and "num" parameters are unused. */ MSG_NotifyInsertOrDelete, /* Some lines have been inserted or deleted. The "where" parameter will indicate the first line that has been added or removed; the "num" parameter will indicate how many lines, and will be positive on an insertion and negative on a deletion. */ MSG_NotifyChanged, /* Some lines have had their contents changed (e.g., messages have been marked read or something.) "where" indicates the first line with a change; "num" indicates how many chaged. */ MSG_NotifyScramble, /* Everything changed. Probably means we resorted the folder. We are still working with the same set of items, or at least have some overlap, but all the indices are invalid. The "where" and "num" parameters are unused. */ MSG_NotifyAll /* Everything changed. We're now not displaying anything like what we were; we probably opened a new folder or something. The FE needs to forget anything it ever knew about what was being displayed, and start over. The "where" and "num" parameters are unused. */ } MSG_NOTIFY_CODE; /* How has a pane changed? Used in calls to FE_PaneChanged. If the value passed to FE_PaneChanged becomes meaningful, it should be documented here. */ typedef enum { MSG_PaneDirectoriesChanged, /* The list of directories has changed. The user has edited them by either reordering or deleting or changing the name. The address book window will need to rebuild its directory list. */ MSG_PaneNotifyMessageLoaded, /* a new message has started to be loaded into a message pane. */ MSG_PaneNotifyFolderInfoChanged, /* the folder info for a thread pane has changed. */ MSG_PaneNotifyFolderLoaded, /* a folder has finished loading into a thread pane */ MSG_PaneNotifyFolderLoadedSync, /* a folder has finished loading synchronously into athread pane */ MSG_PaneNotifyLastMessageDeleted,/* User has deleted the last message in a folder. Some FE's may want to close the message window. */ MSG_PaneNotifyFolderDeleted, /* User has deleted a folder. If it is open in a thread window, the FE should close the window */ MSG_PaneNotifyMessageDeleted, /* User has deleted a message. If it is open in a standalone msg window, the FE should close the window */ MSG_PanePastPasswordCheck, /* Get New mail is past password check. Might be a good time to show progress window. */ MSG_PaneProgressDone, /* Send this when you are a libmsg API that usually runs a url in a progress pane but you don't start a url. FE's, do something reasonable (like take down progress pane)*/ MSG_PaneNotifySelectNewFolder, /* Sent when a new folder is created, and is supposed to be selected by the FE */ MSG_PaneNotifyNewFolderFailed, /* Sent when a new folder creation attempt fails */ MSG_PaneNotifyIMAPClosed, /* Sent to a folder or message pane when the IMAP connection with which it is associated is closing. */ MSG_PaneNotifyCopyFinished, /* Tell the FE that a message copy operation has completed. They may have disabled selection in order to prevent interruption */ MSG_PaneChanged, /* Introduced for the 2 pane Address Book. Contents have changed through another pane. This pane's data is no longer up to date */ MSG_PaneClose /* Introduced for the 2 pane AB. This pane needs to be closed */ } MSG_PANE_CHANGED_NOTIFY_CODE; /* =========================================================================== FLAGS AND MASKS =========================================================================== */ /* Flags about a single message. These values are used in the MSG_MessageLine struct and in a folder's mozilla-status line. The summary file database uses a different internal set of flags. */ #define MSG_FLAG_READ 0x0001 /* has been read */ #define MSG_FLAG_REPLIED 0x0002 /* a reply has been successfully sent */ #define MSG_FLAG_MARKED 0x0004 /* the user-provided mark */ #define MSG_FLAG_EXPUNGED 0x0008 /* already gone (when folder not compacted.) Since actually removing a message from a folder is a semi-expensive operation, we tend to delay it; messages with this bit set will be removed the next time folder compaction is done. Once this bit is set, it never gets un-set. */ #define MSG_FLAG_HAS_RE 0x0010 /* whether subject has "Re:" on the front. The folder summary uniquifies all of the strings in it, and to help this, any string which begins with "Re:" has that stripped first. This bit is then set, so that when presenting the message, we know to put it back (since the "Re:" is not itself stored in the file.) */ #define MSG_FLAG_ELIDED 0x0020 /* Whether the children of this sub-thread are folded in the display. */ #define MSG_FLAG_EXPIRED 0x0040 /* If this flag is set, then this is not a "real" message, but is a dummy container representing an expired parent in a thread. */ #define MSG_FLAG_OFFLINE 0x0080 /* db has offline news or imap article */ #define MSG_FLAG_WATCHED 0x0100 /* If set, then this thread is watched (in 3.0, this was MSG_FLAG_UPDATING).*/ #define MSG_FLAG_SENDER_AUTHED 0x0200 /* If set, then this message's sender has been authenticated when sending this msg. */ #define MSG_FLAG_PARTIAL 0x0400 /* If set, then this message's body is only the first ten lines or so of the message, and we need to add a link to let the user download the rest of it from the POP server. */ #define MSG_FLAG_QUEUED 0x0800 /* If set, this message is queued for delivery. This only ever gets set on messages in the queue folder, but is used to protect against the case of other messages having made their way in there somehow -- if some other program put a message in the queue, we don't want to later deliver it! */ #define MSG_FLAG_FORWARDED 0x1000 /* this message has been forwarded */ #define MSG_FLAG_PRIORITIES 0xE000 /* These are used to remember the message priority in the mozilla status flags so we can regenerate a priority after a rule (or user) has changed it. They are not returned in MSG_MessageLine.flags, just in mozilla-status, so if you need more non-persistent flags, you could share these bits. But it would be wrong. . */ #define MSG_FLAG_NEW 0x10000 /* This msg is new since the last time the folder was closed. */ #define MSG_FLAG_IGNORED 0x40000 /* the thread is ignored */ #define MSG_FLAG_IMAP_DELETED 0x200000 /* message is marked deleted on the server */ #define MSG_FLAG_MDN_REPORT_NEEDED 0x400000 /* This msg required to send an MDN * to the sender of the message */ #define MSG_FLAG_MDN_REPORT_SENT 0x800000 /* An MDN report message has been * sent for this message. No more * MDN report should be sent to the * sender */ #define MSG_FLAG_TEMPLATE 0x1000000 /* this message is a template */ #define MSG_FLAG_ATTACHMENT 0x10000000 /* this message has files attached to it */ /* Flags about a folder or a newsgroup. Used in the MSG_FolderLine struct; also used internally in libmsg (the `flags' slot in MSG_Folder). Note that these don't have anything to do with the above MSG_FLAG flags; they belong to different objects entirely. */ /* These flags say what kind of folder this is: mail or news, directory or leaf. */ #define MSG_FOLDER_FLAG_NEWSGROUP 0x0001 /* The type of this folder. */ #define MSG_FOLDER_FLAG_NEWS_HOST 0x0002 /* Exactly one of these three */ #define MSG_FOLDER_FLAG_MAIL 0x0004 /* flags will be set. */ #define MSG_FOLDER_FLAG_DIRECTORY 0x0008 /* Whether this is a directory: NEWS_HOSTs are always directories; NEWS_GROUPs can be directories if we are in ``show all groups'' mode; MAIL folders will have this bit if they are really directories, not files. (Note that directories may have zero children.) */ #define MSG_FOLDER_FLAG_ELIDED 0x0010 /* Whether the children of this folder are currently hidden in the listing. This will only be present if the DIRECTORY bit is on. */ /* These flags only occur in folders which have the MSG_FOLDER_FLAG_NEWSGROUP bit set, and do not have the MSG_FOLDER_FLAG_DIRECTORY or MSG_FOLDER_FLAG_ELIDED bits set. */ #define MSG_FOLDER_FLAG_MODERATED 0x0020 /* Whether this folder represents a moderated newsgroup. */ #define MSG_FOLDER_FLAG_SUBSCRIBED 0x0040 /* Whether this folder represents a subscribed newsgroup. */ #define MSG_FOLDER_FLAG_NEW_GROUP 0x0080 /* A newsgroup which has just been added by the `Check New Groups' command. */ /* These flags only occur in folders which have the MSG_FOLDER_FLAG_MAIL bit set, and do not have the MSG_FOLDER_FLAG_DIRECTORY or MSG_FOLDER_FLAG_ELIDED bits set. The numeric order of these flags is important; folders with these flags on get displayed first, in reverse numeric order, before folders that have none of these flags on. (Note that if a folder is, say, *both* inbox and sentmail, then its numeric value will be even bigger, and so will bubble up to where the inbox generally is. What a hack!) */ #define MSG_FOLDER_FLAG_TRASH 0x0100 /* Whether this is the trash folder. */ #define MSG_FOLDER_FLAG_SENTMAIL 0x0200 /* Whether this is a folder that sent mail gets delivered to. This particular magic flag is used only during sorting of folders; we generally don't care otherwise. */ #define MSG_FOLDER_FLAG_DRAFTS 0x0400 /* Whether this is the folder in which unfinised, unsent messages are saved for later editing. */ #define MSG_FOLDER_FLAG_QUEUE 0x0800 /* Whether this is the folder in which messages are queued for later delivery. */ #define MSG_FOLDER_FLAG_INBOX 0x1000 /* Whether this is the primary inbox folder. */ #define MSG_FOLDER_FLAG_IMAPBOX 0x2000 /* Whether this folder on online IMAP */ #define MSG_FOLDER_FLAG_CAT_CONTAINER 0x4000 /* This group contains categories */ #define MSG_FOLDER_FLAG_PROFILE_GROUP 0x8000 /* This is a virtual newsgroup */ #define MSG_FOLDER_FLAG_CATEGORY 0x10000 /* this is a category */ #define MSG_FOLDER_FLAG_GOT_NEW 0x20000 /* folder got new msgs */ #define MSG_FOLDER_FLAG_IMAP_SERVER 0x40000 /* folder is an IMAP server */ #define MSG_FOLDER_FLAG_IMAP_PERSONAL 0x80000 /* folder is an IMAP personal folder */ #define MSG_FOLDER_FLAG_IMAP_PUBLIC 0x100000 /* folder is an IMAP public folder */ #define MSG_FOLDER_FLAG_IMAP_OTHER_USER 0x200000 /* folder is another user's IMAP folder */ /* Think of it like a folder that someone would share. */ #define MSG_FOLDER_FLAG_TEMPLATES 0x400000 /* Whether this is the template folder */ #define MSG_FOLDER_FLAG_PERSONAL_SHARED 0x800000 /* This folder is one of your personal folders that ` is shared with other users */ /* Flags in the subscribe pane (used inside of MSG_GroupNameLine). Where the flags overlap with the MSG_FOLDER_FLAG_* flags, it has the same value, to reduce the chance of someone using the wrong constant. */ #define MSG_GROUPNAME_FLAG_ELIDED 0x0010 /* Whether the children of this group are currently hidden in the listing. This will only be present if it has any children. */ #define MSG_GROUPNAME_FLAG_MODERATED 0x0020 /* Whether this folder represents a moderated newsgroup. */ #define MSG_GROUPNAME_FLAG_SUBSCRIBED 0x0040 /* Whether this folder represents a subscribed newsgroup. */ #define MSG_GROUPNAME_FLAG_NEW_GROUP 0x0080 /* A newsgroup which has just been added by the `Check New Groups' command. */ #define MSG_GROUPNAME_FLAG_HASCHILDREN 0x40000 /* Whether there are children of this group. Whether those chilren are visible in this list is determined by the above "ELIDED" flag. Setting this to the same value as a MSG_FOLDER_FLAG_* IMAP server, since an IMAP _server_ will never appear in the subscribe pane. */ #define MSG_GROUPNAME_FLAG_IMAP_PERSONAL 0x80000 /* folder is an IMAP personal folder */ #define MSG_GROUPNAME_FLAG_IMAP_PUBLIC 0x100000 /* folder is an IMAP public folder */ #define MSG_GROUPNAME_FLAG_IMAP_OTHER_USER 0x200000 /* folder is another user's IMAP folder */ #define MSG_GROUPNAME_FLAG_IMAP_NOSELECT 0x400000 /* A \NoSelect IMAP folder */ #define MSG_GROUPNAME_FLAG_PERSONAL_SHARED 0x800000 /* whether or not this folder is one of your personal folders that ` is shared with other users */ /* This set enumerates the header fields which may be displayed in the message composition window. */ typedef uint32 MSG_HEADER_SET; #define MSG_FROM_HEADER_MASK 0x00000001 #define MSG_REPLY_TO_HEADER_MASK 0x00000002 #define MSG_TO_HEADER_MASK 0x00000004 #define MSG_CC_HEADER_MASK 0x00000008 #define MSG_BCC_HEADER_MASK 0x00000010 #define MSG_FCC_HEADER_MASK 0x00000020 #define MSG_NEWSGROUPS_HEADER_MASK 0x00000040 #define MSG_FOLLOWUP_TO_HEADER_MASK 0x00000080 #define MSG_SUBJECT_HEADER_MASK 0x00000100 #define MSG_ATTACHMENTS_HEADER_MASK 0x00000200 /* These next four are typically not ever displayed in the UI, but are still stored and used internally. */ #define MSG_ORGANIZATION_HEADER_MASK 0x00000400 #define MSG_REFERENCES_HEADER_MASK 0x00000800 #define MSG_OTHERRANDOMHEADERS_HEADER_MASK 0x00001000 #define MSG_NEWSPOSTURL_HEADER_MASK 0x00002000 #define MSG_PRIORITY_HEADER_MASK 0x00004000 #define MSG_NEWS_FCC_HEADER_MASK 0x00008000 #define MSG_MESSAGE_ENCODING_HEADER_MASK 0x00010000 #define MSG_CHARACTER_SET_HEADER_MASK 0x00020000 #define MSG_MESSAGE_ID_HEADER_MASK 0x00040000 #define MSG_NEWS_BCC_HEADER_MASK 0x00080000 /* This is also not exposed to the UI; it's used internally to help remember whether the original message had an HTML portion that we can quote. */ #define MSG_HTML_PART_HEADER_MASK 0x00100000 /* The "body=" pseudo-header (as in "mailto:me?body=hi+there") */ #define MSG_DEFAULTBODY_HEADER_MASK 0x00200000 #define MSG_X_TEMPLATE_HEADER_MASK 0x00400000 /* IMAP folders for posting */ #define MSG_IMAP_FOLDER_HEADER_MASK 0x02000000 typedef enum { MSG_RETURN_RECEIPT_BOOL_HEADER_MASK = 0, MSG_ENCRYPTED_BOOL_HEADER_MASK, MSG_SIGNED_BOOL_HEADER_MASK, MSG_UUENCODE_BINARY_BOOL_HEADER_MASK, MSG_ATTACH_VCARD_BOOL_HEADER_MASK, MSG_LAST_BOOL_HEADER_MASK /* last boolean header mask; must be the last one * DON'T remove. */ } MSG_BOOL_HEADER_SET; /* =========================================================================== TYPES AND STRUCTS =========================================================================== */ /* These can be passed to MSG_Navigate and MSG_NavigateStatus */ typedef enum MSG_MotionType { MSG_FirstMessage, MSG_NextMessage, MSG_PreviousMessage, MSG_LastMessage, MSG_FirstUnreadMessage, MSG_NextUnreadMessage, MSG_PreviousUnreadMessage, MSG_LastUnreadMessage, MSG_NextUnreadThread, MSG_NextCategory, MSG_NextUnreadCategory, MSG_NextUnreadGroup, MSG_NextFolder, MSG_ReadMore, MSG_LaterMessage, MSG_Back, /* t,m: Go back to theprevious visited message */ MSG_Forward, /* t,m: Go forward to the previous visited message. */ MSG_FirstFlagged, MSG_NextFlagged, MSG_PreviousFlagged, MSG_FirstNew, MSG_EditUndo, MSG_EditRedo } MSG_MotionType; /* The different views a subscribepane supports. */ typedef enum MSG_SubscribeMode { MSG_SubscribeAll, MSG_SubscribeSearch, MSG_SubscribeNew } MSG_SubscribeMode; /* Backtrack state */ typedef enum MSG_BacktrackState { MSG_BacktrackIdle, MSG_BacktrackBackward, MSG_BacktrackForward } MSG_BacktrackState; /* INSTANCES of MSG_Prefs are used to communicate to the msglib what the values of various preferences are. It's really a temporary hack; I hope a more general XP method of preferences evolves instead. */ #ifdef XP_CPLUSPLUS class MSG_Prefs; #else typedef struct MSG_Prefs MSG_Prefs; #endif /* Instances of MSG_Master represent the entire universe of either mail or news. */ #ifdef XP_CPLUSPLUS class MSG_Master; #else typedef struct MSG_Master MSG_Master; #endif /* The various types of panes available. */ typedef enum { MSG_ANYPANE, MSG_PANE, /* vanilla MSG_Pane, probably just a placeholder for MSG_ProgressPane */ MSG_MAILINGLISTPANE, MSG_ADDRPANE, MSG_FOLDERPANE, MSG_THREADPANE, MSG_MESSAGEPANE, MSG_COMPOSITIONPANE, MSG_SEARCHPANE, MSG_SUBSCRIBEPANE, AB_CONTAINERPANE, AB_ABPANE, AB_MAILINGLISTPANE, AB_PERSONENTRYPANE } MSG_PaneType; /* MSG_ViewIndex is an index into the list of messages or folders or groups, where zero is the first one to show, one is the second, etc... */ typedef uint32 MSG_ViewIndex; typedef MSG_ViewIndex MsgViewIndex; /* MSG_VIEWINDEXNONE is used to indicate an invalid or non-existent index. */ #ifdef XP_CPLUSPLUS const MSG_ViewIndex MSG_VIEWINDEXNONE = 0xffffffff; #else #define MSG_VIEWINDEXNONE 0xffffffff #endif /* imap message flags */ typedef uint16 imapMessageFlagsType; /* MessageKey is a unique ID for a particular message in a folder. If you want a handle to a message that will remain valid even after resorting the folder or otherwise changing their indices, you want one of these rather than a MSG_ViewIndex. */ typedef uint32 MessageKey; /* in the process of removing because of confusion with message-id string */ typedef uint32 MessageId; /* MSG_MESSAGEKEYNONE is used to indicate an invalid or non-existant message. */ #ifdef XP_CPLUSPLUS const MessageId MSG_MESSAGEIDNONE = 0xffffffff; const MessageKey MSG_MESSAGEKEYNONE = 0xffffffff; #else #define MSG_MESSAGEIDNONE 0xffffffff #define MSG_MESSAGEKEYNONE 0xffffffff #endif /* Similarly, MSG_FolderInfo* is a unique ID for a particular folder. */ #ifdef XP_CPLUSPLUS class MSG_FolderInfo; #else typedef struct MSG_FolderInfo *MSG_FolderInfo; #endif /* And MSG_GroupName is a unique ID for a group name in the subscribe pane. */ #ifdef XP_CPLUSPLUS class MSG_GroupName; #else typedef struct MSG_GroupName *MSG_GroupName; #endif /* MSG_NewsHost represents a newsserver that we know about. */ #ifdef XP_CPLUSPLUS class MSG_NewsHost; #else typedef struct MSG_NewsHost *MSG_NewsHost; #endif /* MSG_IMAPHost represents an imap server that we know about. */ #ifdef XP_CPLUSPLUS class MSG_IMAPHost; #else typedef struct MSG_IMAPHost *MSG_IMAPHost; #endif /* MSG_Host represents a news or imap server that we know about. */ /* SUBSCRIBE_USE_OLD_API: REVISIT */ #ifdef XP_CPLUSPLUS class MSG_Host; #else typedef struct MSG_Host *MSG_Host; #endif /* XP_CPLUSPLUS */ /* used in MWContext to communicate IMAP stuff between libmsg and libnet */ #ifdef XP_CPLUSPLUS class MSG_IMAPFolderInfoMail; class TImapServerState; class TNavigatorImapConnection; #else typedef struct MSG_IMAPFolderInfoMail *MSG_IMAPFolderInfoMail; typedef struct TImapServerState *TImapServerState; typedef struct TNavigatorImapConnection TNavigatorImapConnection; #endif struct MSG_AttachmentData { char *url; /* The URL to attach. This should be 0 to signify "end of list". */ char *desired_type; /* The type to which this document should be converted. Legal values are NULL, TEXT_PLAIN and APPLICATION_POSTSCRIPT (which are macros defined in net.h); other values are ignored. */ char *real_type; /* The type of the URL if known, otherwise NULL. For example, if you were attaching a temp file which was known to contain HTML data, you would pass in TEXT_HTML as the real_type, to override whatever type the name of the tmp file might otherwise indicate. */ char *real_encoding; /* Goes along with real_type */ char *real_name; /* The original name of this document, which will eventually show up in the Content-Disposition header. For example, if you had copied a document to a tmp file, this would be the original, human-readable name of the document. */ char *description; /* If you put a string here, it will show up as the Content-Description header. This can be any explanatory text; it's not a file name. */ char *x_mac_type, *x_mac_creator; /* Mac-specific data that should show up as optional parameters to the content-type header. */ }; /* This structure is the interface between compose.c and composew.c. When we have downloaded a URL to a tmp file for attaching, this represents everything we learned about it (and did to it) in the process. */ /* Used by libmime -- mimedrft.c * Front end shouldn't use this structure. */ typedef struct MSG_AttachedFile { char *orig_url; /* Where it came from on the network (or even elsewhere on the local disk.) */ char *file_name; /* The tmp file in which the (possibly converted) data now resides. */ char *type; /* The type of the data in file_name (not necessarily the same as the type of orig_url.) */ char *encoding; /* Likewise, the encoding of the tmp file. This will be set only if the original document had an encoding already; we don't do base64 encoding and so forth until it's time to assemble a full MIME message of all parts. */ /* #### I'm not entirely sure where this data is going to come from... */ char *description; /* For Content-Description header */ char *x_mac_type, *x_mac_creator; /* mac-specific info */ char *real_name; /* The real name of the file. */ /* Some statistics about the data that was written to the file, so that when it comes time to compose a MIME message, we can make an informed decision about what Content-Transfer-Encoding would be best for this attachment. (If it's encoded already, we ignore this information and ship it as-is.) */ uint32 size; uint32 unprintable_count; uint32 highbit_count; uint32 ctl_count; uint32 null_count; uint32 max_line_length; XP_Bool decrypted_p; /* S/MIME -- when attaching a message that was encrypted, it's necessary to decrypt it first (since nobody but the original recipient can read it -- if you forward it to someone in the raw, it will be useless to them.) This flag indicates whether decryption occurred, so that libmsg can issue appropriate warnings about doing a cleartext forward of a message that was originally encrypted. */ } MSG_AttachedFile; /* This structure represents a single line in the folder pane. */ typedef struct MSG_FolderLine { MSG_FolderInfo* id; const char* name; /* The name of the folder to display. */ const char* prettyName; /* The pretty name to display */ uint8 level; /* How many parent folders we have. */ uint32 flags; uint32 prefFlags; /* The below are used only if the icon type is MSG_NewsgroupIcon or MSG_FolderIcon. */ int32 unseen; /* Number of unseen articles. (If negative, then we don't know yet; display question marks or something.*/ int32 total; /* Total number of articles. */ uint16 numChildren; /* How many immediate children of this folder exist. */ int32 deepUnseen; /* Totals for this and child folders */ int32 deepTotal; int32 deletedBytes; /* mail only - total size of deleted messages */ } MSG_FolderLine; /* This structure represents a single line in the thread pane. */ typedef struct MSG_MessageLine { MessageKey threadId; /* (article # of thread - article could be expired) */ MessageKey messageKey; /* news: article num, mail: mbox offset */ char subject[MSG_MAXSUBJECTLENGTH]; char author[MSG_MAXAUTHORLENGTH]; time_t date; uint32 messageLines; /* Number of lines in this message. */ uint32 flags; MSG_PRIORITY priority; /* message priority (mail only?) */ uint16 numChildren; /* for top-level threads */ uint16 numNewChildren; /* for top-level threads */ int8 level; /* indentation level */ } MSG_MessageLine; /* This structure represents a single line in the subscribe pane. */ typedef struct MSG_GroupNameLine { char name[MSG_MAXGROUPNAMELENGTH]; int8 level; uint32 flags; int32 total; } MSG_GroupNameLine; /* This structure is used as an annotation about the font and size information included in a text string passed to us by the front end after the user has edited their message. */ typedef struct MSG_FontCode { uint32 pos; uint32 length; MSG_FONT font; uint8 font_size; XP_Bool fixed_width_p; } MSG_FontCode; /* MSG_CompositionFields represents the desired initial state of the various fields in a composition. */ #ifdef XP_CPLUSPLUS class MSG_CompositionFields; #else typedef struct MSG_CompositionFields MSG_CompositionFields; #endif /* MSG_HTMLComposeAction lists what action to take with a message composed with HTML. */ typedef enum { MSG_HTMLAskUser, MSG_HTMLUseMultipartAlternative, MSG_HTMLConvertToPlaintext, MSG_HTMLSendAsHTML } MSG_HTMLComposeAction; /* MSG_RecipientList specifies a list of recipients to be displayed in the recipients dialog box. It is terminated by an entry which has name set to NULL and value set to something negative. */ typedef struct { int32 value; const char* name; } MSG_RecipientList; /* Secure mail related */ typedef enum { certNone, certValid, certExpired, certRevoked } MSG_CertStatus; typedef struct { char *PrettyName; char *EmailAddress; MSG_CertStatus CertStatus; } MSG_CertInfo; typedef enum { msgNoRecipients = 0, msgNoCerts = 1, msgHasCerts = 2, msgSomeCerts = 4 } MSG_SecurityLevel; typedef enum { crypto_RC4_40bit, crypto_RC4_128bit } MSG_CryptoGrade; typedef struct { /* DoFetchGroups() requests the front end do a MSG_Command(MSG_FetchGroupList) on the subscribe pane, also doing whatever side effects the front end usually does on such a request. */ void (*DoFetchGroups)(MSG_Pane* pane, void* closure); /* FetchCompleted() tells the FE that a MSG_FetchGroupList or MSG_CheckForNew command has completed. */ void (*FetchCompleted)(MSG_Pane* pane, void* closure); } MSG_SubscribeCallbacks; typedef struct { /* AttachmentCount() tells the FE the number of attachments currently known for the message being displayed in the given messagepane. finishedloading is TRUE iff we have finished loading the message. If finishedloading is FALSE, then the FE must be prepared to have this callback fire again soon, as more attachments may be found as downloading proceeds. */ void (*AttachmentCount)(MSG_Pane* messagepane, void* closure, int32 numattachments, XP_Bool finishedloading); /* UserWantsToSeeAttachments() gets called when the user clicks on the little "show me attachment info" at the top of a mail message. */ void (*UserWantsToSeeAttachments)(MSG_Pane* messagepane, void* closure); } MSG_MessagePaneCallbacks; typedef struct { /* CreateAskHTMLDialog() tells the FE to bring up the dialog that lets the user choose the disposition of this HTML composition. If the user chooses a format for HTML and clicks "Send", then the FE must call MSG_SetHTMLAction() and return 0. If the FE returns > 0, then the message send is cancelled. If the user presses the "Recipients" button, then the the FE must call MSG_PutUpRecipientsDialog(). If the FE does not provide this CreateAskHTMLDialog() callback, or if this routine returns a negative number, then the back end will implement it using HTML dialogs. */ int (*CreateAskHTMLDialog)(MSG_Pane* composepane, void* closure); /* CreateRecipientsDialog() tells the FE to bring up the dialog that lets the user choose whether the recipients of a message can deal with HTML. The FE must notify the back end of the results by calling MSG_ResultsRecipients(). If the FE does not provide this callback, or if this routine returns a negative number, then the back end will implement it using HTML dialogs. The last two arguments specify the initial contents of the two scrolling lists. The given strings are to be displayed; the given ID's are to be used in the call to MSG_ResultsRecipients(). (These ID's are also to be used as a sort key so that the recipient list is always displayed sorted in the right order.) These structures are only valid for the length of this call; the FE must copy any data it needs out of them before the call returns. The void* pWnd parameter is used to pass the in parent window of the RecipientsDialog.*/ int (*CreateRecipientsDialog)(MSG_Pane* composepane, void* closure, MSG_RecipientList* nohtml, MSG_RecipientList* htmlok,void* pWnd); } MSG_CompositionPaneCallbacks; /* =========================================================================== INIT / CREATE =========================================================================== */ XP_BEGIN_PROTOS void MSG_InitMsgLib(void); /* one-time initialization of libmsg */ void MSG_ShutdownMsgLib(void); /* shut down LibMsg part of app. */ /* launch a url to compress mail folders and purge news dbs. */ XP_Bool MSG_CleanupNeeded(MSG_Master *master); void MSG_CleanupFolders(MSG_Pane *pane); /* currently just to give db time to clean up */ void MSG_OnIdle(void); int32 MSG_SetLibNeoCacheSize(int32 newCacheSize); /* Initialize the mail/news universe. A MSG_Master* object must be created before anything else can be done. Only one MSG_Master* object can exist at any time. */ extern MSG_Master* MSG_InitializeMail(MSG_Prefs* prefs); /* Routines to create the various panes. Those panes that require a true MWContext* take it as a parameter. Any given thread pane is always associated with a particular folder pane; any given message pane is always associated with a particular thread pane. The entire creation process goes like this: - The FE decides to create a new pane. - The FE creates any necessary contexts and maybe some windows and stuff that it will associate with the pane. - The FE calls MSG_Create*Pane() to create the pane object itself. When creating a folderpane, the FE must also provide a pointer to a MSG_Prefs object that contains the preferences to be used for the folderpane. The FE must be sure not to destroy that MSG_Prefs object as long as the folderpane exists. Any later change made to the MSG_Prefs will automatically be reflected in the folderpane and all related panes. (Also note that when creating a folderpane, msglib uses the context type to determine whether this is for mail or news.) - The FE puts the resulting pane structure into its datastructures somewhere, and probably calls MSG_SetFEData() to assocatiate that datastructure with the pane. */ extern MSG_Pane* MSG_CreateFolderPane(MWContext* context, MSG_Master* master); extern MSG_Pane* MSG_CreateThreadPane(MWContext* context, MSG_Master* master); extern MSG_Pane* MSG_CreateMessagePane(MWContext* context, MSG_Master* master); extern int MSG_SetMessagePaneCallbacks(MSG_Pane* messagepane, MSG_MessagePaneCallbacks* callbacks, void* closure); extern MSG_MessagePaneCallbacks* MSG_GetMessagePaneCallbacks(MSG_Pane* messagepane, void** closure); extern MSG_Pane* MSG_CreateCompositionPane(MWContext* context, MWContext* old_context, MSG_Prefs* prefs, MSG_CompositionFields* fields, MSG_Master* master); extern int MSG_SetCompositionPaneCallbacks(MSG_Pane* composepane, MSG_CompositionPaneCallbacks* callbacks, void* closure); /* Typically, progress panes come down when you receive all connections complete, or you get a FE_PaneChanged MSG_PaneProgressDone, which gets sent when a command runs in a progress pane which doesn't launch a url. */ extern MSG_Pane* MSG_CreateProgressPane (MWContext *context, MSG_Master *master, MSG_Pane *parentPane); /* WinFE (at least) has found that creating the composition pane in one swell foop is too much to handle. They really want to create the pane pointer, but not start its initializing until some later point. (The reason this is nasty is that composition pane initialization can sometimes happen in the background as we download attachments.) So, if you don't want to call MSG_CreateCompositionPane(), you can instead call MSG_CreateCompositionPaneNoInit() and then soon call MSG_InitializeCompositionPane(). What fun. */ extern MSG_Pane* MSG_CreateCompositionPaneNoInit(MWContext* context, MSG_Prefs* prefs, MSG_Master* master); extern int MSG_InitializeCompositionPane(MSG_Pane* comppane, MWContext* old_context, MSG_CompositionFields* fields); extern MSG_Pane* MSG_CreateSearchPane (MWContext *context, MSG_Master *master); #ifdef SUBSCRIBE_USE_OLD_API /* This routine is obsoleted; instead, use MSG_CreateSubscribePaneOnHost(). */ extern MSG_Pane* MSG_CreateSubscribePane(MWContext* context, MSG_Master* master); /* Bring up the subscribe UI on the given newshost. If host is NULL, uses the default newshost. */ extern MSG_Pane* MSG_CreateSubscribePaneOnHost(MWContext* context, MSG_Master* master, MSG_NewsHost* host); #endif /* SUBSCRIBE_USE_OLD_API */ /* Bring up the subscribe UI on the given news or imap host. If host is NULL, uses the default newshost. */ extern MSG_Pane* MSG_CreateSubscribePaneForHost(MWContext* context, MSG_Master* master, MSG_Host* host); /* Tells the FEs to bring up the subscribe UI on the given news or imap host. */ extern XP_Bool FE_CreateSubscribePaneOnHost(MSG_Master* master, MWContext* parentContext, MSG_Host* host); /* Message compositions sometimes (usually) get kicked off by the backend (like, the user clicks on a "mailto" link). So, this call requests the FE to create a new context, and call MSG_CreateCompositionPane and bring up a composition window. The given context and MSG_CompositionFields* are to be passed on to MSG_CreateCompositionPane(), and lets the backend know what the initial values of all the fields are to be. The FE should then query the pane (using MSG_GetCompHeader() and MSG_GetCompBody()) so that it can find out what to display in the UI. The FE should bring up either the plaintext composition or the html composition window, depending on the user's preference. One exception, though: the FE must first check MSG_GetForcePlainText(). If TRUE, then we are replying to a plaintext message, and the FE *must* bring up the plaintext composition window. */ extern MSG_Pane* FE_CreateCompositionPane(MWContext* old_context, MSG_CompositionFields* fields, const char* initialText, MSG_EditorType editorType); /* =========================================================================== RANDOM CORE FUNCTIONS (to sort) =========================================================================== */ /* Due to addition of Java/JavaScript MailNews API, other things in addition to composition can be kicked off by the backend, so we provide the following FE functions to handle those cases. */ /* Ask the FE for the current master. FE should create one if it doesn't exist */ extern MSG_Master* FE_GetMaster(); /* Routines to associate or get arbitrary FE-specific data from a pane. */ extern void MSG_SetFEData(MSG_Pane* pane, void* data); extern void* MSG_GetFEData(MSG_Pane* pane); /* Routines to to special things when Netscape mail is not being used */ extern XP_Bool FE_IsAltMailUsed(MWContext * context); /* Routine to bring up the IMAP Subscription Upgrade dialog box */ /* Return value based on selection: Automatic = 0, Custom = 1 */ extern int FE_PromptIMAPSubscriptionUpgrade (MWContext * context); /* This function is called by the backend to notify the frontend details about new mail state so that the FE can notify the stand-alone biff that something has changed. */ #ifdef XP_WIN32 /* only supported on Win32 now */ typedef enum { MSG_IMAPHighWaterMark, /* data is the IMAP UID highwater mark for the inbox */ } MSG_BiffInfoType; #define FE_SetBiffInfoDefined /* this symbol used in the back-end to know if FE_SetBiffInfo is defined */ extern uint32 FE_SetBiffInfo(MSG_BiffInfoType type, uint32 data); #endif /* run the url in the given pane. This will set the msg_pane member in url, interrupt the context, and then call FE_GetURL */ extern int MSG_GetURL(MSG_Pane *pane, URL_Struct* url); /* routines to set and get the text type, setting true indicates that the text is HTML */ extern XP_Bool MSG_GetHTMLMarkup(MSG_Pane * composepane); extern void MSG_SetHTMLMarkup(MSG_Pane * composepane,XP_Bool flag); /* Returns the type of the given pane. */ extern MSG_PaneType MSG_GetPaneType(MSG_Pane* pane); /* Finds a pane with the given type. First, it looks for a pane which has the given context associated with it; failing that, it returns any pane it can find. */ extern MSG_Pane* MSG_FindPane(MWContext* context, MSG_PaneType type); /* really find the pane of passed type with given context, NULL otherwise */ extern MSG_Pane *MSG_FindPaneOfContext (MWContext *context, MSG_PaneType type); extern MSG_Pane *MSG_FindPaneOfType(MSG_Master *master, MSG_FolderInfo *id, MSG_PaneType type); extern MSG_Pane *MSG_FindPaneFromUrl (MSG_Pane *pane, const char *url, MSG_PaneType type); /* Returns the context associated with a given pane. If this pane doesn't have a context (i.e., it's a threadpane), then it will return NULL. */ extern MWContext* MSG_GetContext(MSG_Pane* pane); /* Returns the MSG_Prefs* object that is being used to determine the preferences for this pane. */ extern MSG_Prefs* MSG_GetPrefs(MSG_Pane* pane); /* Returns the MSG_Prefs* object that is being used to determine the preferences for this master object. */ extern MSG_Prefs* MSG_GetPrefsForMaster(MSG_Master* master); /* Returns the MSG_Master* object for the given pane. */ extern MSG_Master* MSG_GetMaster(MSG_Pane* pane); extern XP_Bool MSG_DeliveryInProgress(MSG_Pane * composepane); /* This is the front end's single interface to executing mail/news menu and toolbar commands. See the comment above the definition of the MSG_CommandType enum. The indices and numindices arguments indicates which folders or threads are to be affected by this command. For many commands, they'll be ignored. They should always be NULL if not specifying a folderpane or a threadpane. */ extern void MSG_Command (MSG_Pane* pane, MSG_CommandType command, MSG_ViewIndex* indices, int32 numindices); /* Before the front end displays any menu (each time), it should call this function for each command on that menu to determine how it should be displayed. selectable_p: whether the user should be allowed to select this item; if this is FALSE, the item should be grayed out. selected_p: if this command is a toggle or multiple-choice menu item, this will be MSG_Checked if the item should be `checked', MSG_Unchecked if it should not be, and MSG_NotUsed if the item is a `normal' menu item that never has a checkmark. display_string: the string to put in the menu. l10n handwave handwave. plural_p: if it happens that you're not using display_string, then this tells you whether the string you display in the menu should be singular or plural ("Delete Message" versus "Delete Selected Messages".) If you're using display_string, you don't need to look at this value. Returned value is negative if something went wrong. */ extern int MSG_CommandStatus (MSG_Pane* pane, MSG_CommandType command, MSG_ViewIndex* indices, int32 numindices, XP_Bool *selectable_p, MSG_COMMAND_CHECK_STATE *selected_p, const char **display_string, XP_Bool *plural_p); /* Set the value of a toggle-style command to the given value. Returns negative if something went wrong (like, you gave it a non-toggling command, or you passed in MSG_NotUsed for the check state.) */ extern int MSG_SetToggleStatus(MSG_Pane* pane, MSG_CommandType command, MSG_ViewIndex* indices, int32 numindices, MSG_COMMAND_CHECK_STATE value); /* Queries whether the given toggle-style command is on or off. */ extern MSG_COMMAND_CHECK_STATE MSG_GetToggleStatus(MSG_Pane* pane, MSG_CommandType command, MSG_ViewIndex* indices, int32 numindices); /* Navigation commands */ extern int MSG_DataNavigate(MSG_Pane* pane, MSG_MotionType motion, MessageKey startId, MessageKey *resultId, MessageKey *resultThreadId); /* This routine will automatically expand the destination thread, if needs be. */ extern int MSG_ViewNavigate(MSG_Pane* pane, MSG_MotionType motion, MSG_ViewIndex startIndex, MessageKey *resultId, MSG_ViewIndex *resultIndex, MSG_ViewIndex *pThreadIndex, MSG_FolderInfo **folderInfo); /* Indicates if navigation of the passed motion type is valid. */ extern int MSG_NavigateStatus (MSG_Pane* pane, MSG_MotionType command, MSG_ViewIndex index, XP_Bool *selectable_p, const char **display_string); extern int MSG_MarkReadByDate (MSG_Pane* pane, time_t startDate, time_t endDate); /* notification from Server Admin page via JavaScript that an imap folder has changed */ extern void MSG_IMAPFolderChangedNotification(const char *folder_url); /* record the imap connection in the move state of the current context */ extern void MSG_StoreNavigatorIMAPConnectionInMoveState(MWContext *context, TNavigatorImapConnection *connection); /* Determines whether we are currently actually showing the recipients in the "Sender" column of the display (because we are in the "sent" folder). FE's should call this in their FE_UpdateToolbar to change the title of this column.*/ extern XP_Bool MSG_DisplayingRecipients(MSG_Pane* threadpane); /* The msg library calls FE_ListChangeStarting() to tell the front end that the contents of the message or folder list are about to change. It means that any MSG_ViewIndex values that the FE may be keeping around might become invalid. The FE should adjust them, throw them out, or convert them into MessageKey or MSG_FolderInfo* values, instead. This call will be quickly followed by a matching call to FE_ListChangeFinished(). The "asynchronous" flag will be TRUE if this change happened due to some completely asynchronous event, and FALSE if we are in the middle of a call to MSG_Command() or other calls from the FE that directly manipulate the msglib. Some FE's (Mac) will choose to ignore these calls if asynchronous is FALSE, while other FE's (XFE) will likely ignore the parameter. The notify parameter describes what changed, along with the where and num parameters. See the documentation in the declaration of MSG_NOTIFY_CODE, above. */ extern void FE_ListChangeStarting(MSG_Pane* pane, XP_Bool asynchronous, MSG_NOTIFY_CODE notify, MSG_ViewIndex where, int32 num); /* FE_ListChangeFinished() gets called only after a call to FE_ListChangeStarting(). It means that it is safe for the FE to convert back from MessageKey or MSG_FolderInfo* into MSG_ViewIndex. It's also a good clue that the FE ought to redisplay the list. If the folderpane is given, then the FE probably will want to regenerate any list of folders presented in menus. */ extern void FE_ListChangeFinished(MSG_Pane* pane, XP_Bool asynchronous, MSG_NOTIFY_CODE notify, MSG_ViewIndex where, int32 num); /* The backend calls this when something changed about the pane other than the list. For example, if we load a different message into a message pane, we call FE_PaneChanged with a notify code of MSG_PaneNotifyMessageLoaded. Or, if the folder info for a folder displayed in a thread pane changes, we call FE_PaneChanged with a notify code of MSG_PaneNotifyFolderInfoChanged. */ extern void FE_PaneChanged(MSG_Pane *pane, XP_Bool asynchronous, MSG_PANE_CHANGED_NOTIFY_CODE, int32 value); /* The front end calls this *after* it has handled the FE_PaneChanged notification. This function handles callbacks set up by back-end code to detect changes in the mail system. Currently, it is used by the netscape.messaging.* classes to allow callbacks in the java classes when stuff in the mail backend changes. */ extern void MSG_HandlePaneChangedNotifications(MSG_Pane *pane, XP_Bool asynchronous, MSG_PANE_CHANGED_NOTIFY_CODE, int32 value); /* Declaration for backend pane change callback */ typedef void (*MSG_PANE_CHANGED_CALLBACK)(MSG_Pane *pane, XP_Bool asynchronous, MSG_PANE_CHANGED_NOTIFY_CODE, int32 value); /* Registration function to register call backs. Currently allows only one, but should be expanded to allow multiple observers */ extern void MSG_RegisterPaneChangedCallback(MSG_PANE_CHANGED_CALLBACK cb); /* The front end can use this call to determine what the indentation depth is needed to display all the icons in the folder list. The XFE uses this to dynamically resize the icon column. In true C style, the number returned is actually one bigger than the biggest depth the FE will ever get. */ extern int MSG_GetFolderMaxDepth(MSG_Pane* folderpane); /* The front end uses these calls to determine what to display on particular lines in the outline lists. They return TRUE on success, FALSE if the given line doesn't exist or if there are less than numlines worth of data to get. The given data pointer must point to an array of at least numlines elements. */ extern XP_Bool MSG_GetFolderLineByIndex(MSG_Pane* folderpane, MSG_ViewIndex firstline, int32 numlines, MSG_FolderLine* data); /* get the flags for a folder w/o the whole MSG_FolderLine */ extern uint32 MSG_GetFolderFlags(MSG_FolderInfo *folder); extern int32 MSG_GetFolderSizeOnDisk (MSG_FolderInfo *folder); extern XP_Bool MSG_GetThreadLineByIndex(MSG_Pane* threadpane, MSG_ViewIndex firstline, int32 numlines, MSG_MessageLine* data); extern int MSG_GetFolderLevelByIndex( MSG_Pane *folderpane, MSG_ViewIndex line ); extern int MSG_GetThreadLevelByIndex( MSG_Pane *threadpane, MSG_ViewIndex line ); /* If the FE wants to find out info about a particular folder or thread by its id rather than by its index, it can use these calls. */ extern XP_Bool MSG_GetFolderLineById(MSG_Master* master, MSG_FolderInfo* info, MSG_FolderLine* data); extern XP_Bool MSG_GetThreadLineById(MSG_Pane* pane, /* thread or message */ MessageKey id, MSG_MessageLine* data); /* returns the view index of the first message in the thread containing key */ extern MSG_ViewIndex MSG_ThreadIndexOfMsg(MSG_Pane* pane, MessageKey key); /* Takes a time (most likely, the one returned in the MSG_MessageLine structure by MSG_GetThreadLine()) and formats it into a compact textual representation (like "Thursday" or "09:53:17" or "10/3 16:15"), based on how that date relates to the current time. This is returned in a statically allocated buffer; the caller should copy it somewhere. */ extern const char* MSG_FormatDate(MSG_Pane* pane, time_t date); /* If you don't have a pane and need to format a date ... */ extern const char* MSG_FormatDateFromContext(MWContext *context, time_t date); /* Change the priority on a mail message */ extern XP_Bool MSG_SetPriority(MSG_Pane *pane, /* thread or message */ MessageKey key, MSG_PRIORITY priority); /* The msg library calls this to get a temporary filename and type (suitable for passing to XP_FileOpen, etc) to be used for storing a temporary working copy of the given filename and type. The returned file will usually be renamed back onto the given filename, using XP_FileRename(). The returned filename will be freed using XP_FREE(). */ /* #### this should be replaced with a backup-version-hacking XP_FileOpen */ extern char* FE_GetTempFileFor(MWContext* context, const char* fname, XP_FileType ftype, XP_FileType* rettype); /* Delete the master object, meaning that we're all done with mail or news. It's not legal to do this unless all associated panes have already been destroyed. */ extern void MSG_DestroyMaster(MSG_Master* master); /* A pane is going away. */ extern void MSG_DestroyPane(MSG_Pane* pane); /* Load the given folder into the given threadpane. */ extern int MSG_LoadFolder(MSG_Pane* threadpane, MSG_FolderInfo* folder); /* Load the given message into the given messagepane. Also have to specify the folder that the pane is in. */ extern int MSG_LoadMessage(MSG_Pane* messagepane, MSG_FolderInfo* folder, MessageKey id); /* Open Draft Message into a compose window */ extern int MSG_OpenDraft (MSG_Pane* threadpane, MSG_FolderInfo* folder, MessageKey id); /* Draft -- backend helper function; FE don't use it */ extern void MSG_SetLineWidth(MSG_Pane* composepane, int width); extern void MSG_AddBacktrackMessage(MSG_Pane* pane, MSG_FolderInfo* folder, MessageKey id); extern void MSG_SetBacktrackState (MSG_Pane* pane, MSG_BacktrackState state); extern MSG_BacktrackState MSG_GetBacktrackState (MSG_Pane* pane); /* Set what action to take when the user sends an HTML message. This is set by a pull-down in the compose window, or as a result of the AskHTMLDialog. */ extern int MSG_SetHTMLAction(MSG_Pane* composepane, MSG_HTMLComposeAction action); /* Gets the value set above. */ extern MSG_HTMLComposeAction MSG_GetHTMLAction(MSG_Pane* composepane); /* Asks that the recipients dialog appear. This should only happen as a result of the user pressing the "Recipients" button on the AskHTMLDialog. the void* parameter is used to pass in the parent window for the dialog */ extern int MSG_PutUpRecipientsDialog(MSG_Pane* composepane,void *pWnd); /* For more details on this routine, see comments for MSG_CompositionPaneCallbacks. */ extern int MSG_ResultsRecipients(MSG_Pane* composepane, XP_Bool cancelled, int32* nohtml, /* List of IDs, terminated with a negative entry. */ int32* htmlok /* Another list of IDs. */ ); extern void MSG_SetPostDeliveryActionInfo (MSG_Pane* pane, void *actionInfo); /* Setting the preloaded attachments to a compose window. Drafts only */ extern int MSG_SetPreloadedAttachments ( MSG_Pane *composepane, MWContext *context, void *attachmentData, void *attachments, int attachments_count ); #ifdef XP_UNIX /* This is how the XFE implements non-POP message delivery. The given donefunc will be called when the incorporate actually finishes, which may be before or after this function returns. The boolean passed to the donefunc will be TRUE if the incorporate succeeds, and FALSE if it fails for any reason. */ extern void MSG_IncorporateFromFile(MSG_Pane* pane, XP_File infid, void (*donefunc)(void*, XP_Bool), void* doneclosure); #endif /* XP_UNIX */ /* =========================================================================== PREFERENCES =========================================================================== */ /* Create a new place to store mail/news preferences. */ extern MSG_Prefs* MSG_CreatePrefs(void); /* Destroy a previously created MSG_Prefs* object. it is illegal to call this unless any MSG_Master* or compositionpane objects associated with this prefs object have already been destroyed.*/ extern void MSG_DestroyPrefs(MSG_Prefs*); /* This is the directory where mail folders are stored. */ extern void MSG_SetFolderDirectory(MSG_Prefs* prefs, const char* directory); extern const char* MSG_GetFolderDirectory(MSG_Prefs* prefs); extern void MSG_GetCitationStyle(MSG_Prefs* prefs, MSG_FONT* font, MSG_CITATION_SIZE* size, const char** color); /* Gets/Sets the current Queue Folder name, i.e. "Outbox" or "Unsent Messages." Don't free the return result. */ extern const char * MSG_GetQueueFolderName(); /* Should be called with a #define'd string, i.e. QUEUE_FOLDER_NAME or QUEUE_FOLDER_NAME_OLD */ extern const char * MSG_SetQueueFolderName(const char *newName); /* Variation on XP_GetString for special folders, except this function returns safer, longer-duration strings */ extern const char * MSG_GetSpecialFolderName(int whichOne); #ifdef XP_OS2 extern const char * MSG_GetSpecialFolderPrettyName(int whichOne); #endif /* Whether to automatically quote original message when replying. */ extern XP_Bool MSG_GetAutoQuoteReply(MSG_Prefs* prefs); /* Whether to show attachments as links instead of inline. */ extern XP_Bool MSG_GetNoInlineAttachments(MSG_Prefs* prefs); /* there are going to be a set of per-folder preferences, including 1 pane or 2 Configured for off-line use I think these can be represented with bits. If wrong, we'll have to change this. They should be stored in the database, NeoFolderInfo obj, and cached in MSG_FolderInfo. */ #define MSG_FOLDER_PREF_OFFLINE 0x00000001 #define MSG_FOLDER_PREF_ONEPANE 0x00000002 #define MSG_FOLDER_PREF_SHOWIGNORED 0x00000004 #define MSG_FOLDER_PREF_IMAPMARKED 0x00000008 /* server says this folder is 'special' */ #define MSG_FOLDER_PREF_IMAPUNMARKED 0x00000010 /* different from !marked? RFC says yes */ #define MSG_FOLDER_PREF_IMAPNOINFERIORS 0x00000020 /* cannot have children folders, pity */ #define MSG_FOLDER_PREF_IMAPNOSELECT 0x00000040 /* cannot hold messages, only other folders */ #define MSG_FOLDER_PREF_OFFLINEEVENTS 0x00000080 /* this folder has offline events to play back */ #define MSG_FOLDER_PREF_LSUB_DISCOVERED 0x00000100 /* this folder was discovered using LSUB */ #define MSG_FOLDER_PREF_CREATED_OFFLINE 0x00000200 /* this folder created offline, so don't delete it */ #define MSG_FOLDER_PREF_NAMESPACE_STRIPPED 0x00000400 /* this folder has had its personal namespace stripped off */ #define MSG_FOLDER_PREF_IMAP_ACL_READ 0x00000800 /* SELECT, CHECK, FETCH, PARTIAL, SEARCH, COPY from folder */ #define MSG_FOLDER_PREF_IMAP_ACL_STORE_SEEN 0x00001000 /* STORE SEEN flag */ #define MSG_FOLDER_PREF_IMAP_ACL_WRITE 0x00002000 /* STORE flags other than SEEN and DELETED */ #define MSG_FOLDER_PREF_IMAP_ACL_INSERT 0x00004000 /* APPEND, COPY into folder */ #define MSG_FOLDER_PREF_IMAP_ACL_POST 0x00008000 /* Can I send mail to the submission address for folder? */ #define MSG_FOLDER_PREF_IMAP_ACL_CREATE_SUBFOLDER 0x00010000 /* Can I CREATE a subfolder of this folder? */ #define MSG_FOLDER_PREF_IMAP_ACL_DELETE 0x00020000 /* STORE DELETED flag, perform EXPUNGE */ #define MSG_FOLDER_PREF_IMAP_ACL_ADMINISTER 0x00040000 /* perform SETACL */ #define MSG_FOLDER_PREF_IMAP_ACL_RETRIEVED 0x00080000 /* ACL info for this folder has been initialized */ #define MSG_FOLDER_PREF_FEVALID 0x40000000 /* prefs have actually been set */ #define MSG_FOLDER_PREF_CACHED 0x80000000 /* we've retrieved prefs from db */ extern void MSG_SetFolderPrefFlags(MSG_FolderInfo *info, int32 flag); extern int32 MSG_GetFolderPrefFlags(MSG_FolderInfo *info); /* allow FE's to remember default CSID's on a per-folder basis. It would be nice if there were a type other than int16 for csid's! */ extern void MSG_SetFolderCSID(MSG_FolderInfo *info, int16 csid); extern int16 MSG_GetFolderCSID(MSG_FolderInfo *info); typedef enum MSG_AdminURLType { MSG_AdminServer, MSG_AdminServerSideFilters, MSG_AdminFolder, MSG_AdminServerLists } MSG_AdminURLType; /* use this to run the url */ extern XP_Bool MSG_GetAdminUrlForFolder(MWContext *context, MSG_FolderInfo *folder, MSG_AdminURLType type); /* use this to decide to show buttons and/or menut items */ extern XP_Bool MSG_HaveAdminUrlForFolder(MSG_FolderInfo *folder, MSG_AdminURLType type); /* =========================================================================== LIST CALLBACKS =========================================================================== */ /* The FE calls these in response to mouse gestures on the scrolling lists. Note that folderpanes, threadpanes, and subscribepanes all have scrolling lists; most of these calls are valid in any of them. */ /* Change the flippy state on this thread line, if possible. The numchanged returns how many lines that were added to the view (if positive), or how many were removed (if negative). If you don't care, pass in NULL. */ extern void MSG_ToggleExpansion (MSG_Pane* pane, MSG_ViewIndex line, int32* numchanged); /* Returns how many lines would get added or removed from the message pane if MSG_ToggleExpansion were to be called. Returns positive if lines will be added; negative if lines will be removed. */ extern int32 MSG_ExpansionDelta(MSG_Pane* pane, MSG_ViewIndex line); /* These are invoked by the items on the `Copy/Move Message Into' cascading menus, and by drag-and-drop. The folder name should be the full pathname of the folder in URL (Unix) file name syntax. This does not have to be an existing folder; it can be any file on the system. It doesn't even have to exist yet. (If you do want to use an existing folder, you can get the right string to pass using MSG_GetFolderName().) */ typedef enum { MSG_Drag_Not_Allowed = 0x00000000 , MSG_Require_Copy = 0x00000001 , MSG_Require_Move = 0x00000002 , MSG_Default_Drag = 0xFFFFFFFF } MSG_DragEffect; /* Status calls. Caller passes in requested action. If it's a required action, the returned value will be the request value, or MSG_Drag_Not_Allowed. If it's a default drag request, the returned value will show whether the drag should be interpreted as a move or copy. */ extern MSG_DragEffect MSG_DragMessagesStatus(MSG_Pane* pane, const MSG_ViewIndex* indices, int32 numindices, const char *folder, MSG_DragEffect request); extern MSG_DragEffect MSG_DragMessagesIntoFolderStatus(MSG_Pane* pane, const MSG_ViewIndex* indices, int32 numindices, MSG_FolderInfo *folder, MSG_DragEffect request); extern MSG_DragEffect MSG_DragFoldersIntoStatus(MSG_Pane *folderPane, const MSG_ViewIndex *indices, int32 numIndices, MSG_FolderInfo *destFolder, MSG_DragEffect request); extern int MSG_CopyMessagesInto(MSG_Pane* pane, const MSG_ViewIndex* indices, int32 numindices, const char *folder); extern int MSG_MoveMessagesInto(MSG_Pane* pane, const MSG_ViewIndex* indices, int32 numindices, const char *folder); extern int MSG_CopyMessagesIntoFolder(MSG_Pane* pane, const MSG_ViewIndex* indices, int32 numindices, MSG_FolderInfo *folder); extern int MSG_MoveMessagesIntoFolder(MSG_Pane* pane, const MSG_ViewIndex* indices, int32 numindices, MSG_FolderInfo *folder); extern int MSG_MoveFoldersInto (MSG_Pane *folderPane, const MSG_ViewIndex *indices, int32 numIndices, MSG_FolderInfo *destFolder); /* =========================================================================== HOSTS =========================================================================== */ /* These operations on hosts are mostly used for the subscribe pane. */ /* Returns the number of known newshosts. If the result pointer is not NULL, fills it in with the list of newshosts (providing up to resultsize entries.) */ extern int32 MSG_GetNewsHosts(MSG_Master* master, MSG_NewsHost** result, int32 resultsize); /* Same as above for imap hosts */ extern int32 MSG_GetIMAPHosts(MSG_Master* master, MSG_IMAPHost** result, int32 resultsize); /* Same as above for imap hosts that support subscription */ extern int32 MSG_GetSubscribingIMAPHosts(MSG_Master* master, MSG_IMAPHost** result, int32 resultsize); /* Same as above for news hosts + imap hosts that support subscription */ extern int32 MSG_GetSubscribingHosts(MSG_Master* master, MSG_Host** result, int32 resultsize); /* Get the host type */ extern XP_Bool MSG_IsNewsHost(MSG_Host* host); extern XP_Bool MSG_IsIMAPHost(MSG_Host* host); /* Returns a pointer to the associated MSG_Host object for this MSG_NewsHost */ extern MSG_Host* MSG_GetMSGHostFromNewsHost(MSG_NewsHost *newsHost); /* Returns a pointer to the associated MSG_Host object for this MSG_IMAPHost */ extern MSG_Host* MSG_GetMSGHostFromIMAPHost(MSG_IMAPHost *imapHost); /* Returns a pointer to the associated MSG_NewsHost object for this MSG_Host, if it is a MSG_NewsHost. Otherwise, returns NULL. */ extern MSG_NewsHost* MSG_GetNewsHostFromMSGHost(MSG_Host *host); /* Returns a pointer to the associated MSG_IMAPHost object for this MSG_Host, if it is a MSG_IMAPHost. Otherwise, returns NULL. */ extern MSG_IMAPHost* MSG_GetIMAPHostFromMSGHost(MSG_Host *host); /* this should be in msgnet.h, but winfe uses it - this is dangerous in a multiple host world. */ extern XP_Bool MSG_GetMailServerIsIMAP4(MSG_Prefs* prefs); /* Creates a new newshost. If the given info matches an existing newshost, then returns that newshost. */ extern MSG_NewsHost* MSG_CreateNewsHost(MSG_Master* master, const char* hostname, XP_Bool isSecure, int32 port /* If 0, use default */ ); /* Gets the default newshost. Could be NULL, if the user has managed to configure himself that way. */ extern MSG_NewsHost* MSG_GetDefaultNewsHost(MSG_Master* master); /* Deletes a newshost. This deletes everything known about this hosts -- the newsrc files, the databases, everything. The user had better have confirmed this operation before making this call. */ extern int MSG_DeleteNewsHost(MSG_Master* master, MSG_NewsHost* host); /* IMAP Hosts API's */ /* Creates a new imap host. If the given info matches an existing imap host, then returns that imap host. */ extern MSG_IMAPHost* MSG_CreateIMAPHost(MSG_Master* master, const char* hostname, XP_Bool isSecure, const char *userName, XP_Bool checkNewMail, int biffInterval, XP_Bool rememberPassword, XP_Bool usingSubscription, XP_Bool overrideNamespaces, const char *personalOnlineDir, const char *publicOnlineDir, const char *otherUsersOnlineDir ); /* Gets the default imap host. Could be NULL, if the user has managed to configure himself that way. */ extern MSG_IMAPHost* MSG_GetDefaultIMAPHost(MSG_Master* master); /* Deletes an imap host. This deletes everything known about this hosts -- the preferences, the databases, everything. The user had better have confirmed this operation before making this call. */ extern int MSG_DeleteIMAPHost(MSG_Master* master, MSG_IMAPHost* host); /* Get info about a host. */ #ifdef SUBSCRIBE_USE_OLD_API /* these are being obsoleted */ extern const char* MSG_GetNewsHostUIName(MSG_NewsHost* host); extern const char* MSG_GetNewsHostName(MSG_NewsHost* host); extern XP_Bool MSG_IsNewsHostSecure(MSG_NewsHost* host); extern int32 MSG_GetNewsHostPort(MSG_NewsHost* host); #endif /* SUBSCRIBE_USE_OLD_API */ extern const char* MSG_GetHostUIName(MSG_Host* host); extern const char* MSG_GetHostName(MSG_Host* host); extern XP_Bool MSG_IsHostSecure(MSG_Host* host); extern int32 MSG_GetHostPort(MSG_Host* host); extern void MSG_SetNewsHostPostingAllowed (MSG_NewsHost *host, XP_Bool allowed); extern XP_Bool MSG_GetNewsHostPushAuth (MSG_NewsHost *host); extern void MSG_SetNewsHostPushAuth (MSG_NewsHost *host, XP_Bool pushAuth); /* =========================================================================== SUBSCRIBE WINDOW =========================================================================== */ /* Set list of callback routines that the subscribe pane can call to the FE. */ extern int MSG_SubscribeSetCallbacks(MSG_Pane* subscribepane, MSG_SubscribeCallbacks* callbacks, void* callbackclosure); /* The cancel button was hit. Forget any subscriptions or unsubscriptions that had been requested. (This call is usually quickly followed by a call to MSG_DestroyPane). */ extern int MSG_SubscribeCancel(MSG_Pane* subscribepane); /* The OK button was hit. Commit any subscriptions or unsubscriptions to the IMAP server, if there are any changes. If the changes are on a news server, the commit will happen in the destructor, just like they used to (ack). This needs to change for IMAP because we do network I/O. */ extern int MSG_SubscribeCommit(MSG_Pane* subscribepane); /* Get which newshost we're currently viewing. */ #ifdef SUBSCRIBE_USE_OLD_API extern MSG_NewsHost* MSG_SubscribeGetNewsHost(MSG_Pane* subscribepane); #endif /* SUBSCRIBE_USE_OLD_API */ /* Get which news or imap host we're currently viewing. */ extern MSG_Host* MSG_SubscribeGetHost(MSG_Pane* subscribepane); /* Set our view to the given newshost. */ #ifdef SUBSCRIBE_USE_OLD_API extern int MSG_SubscribeSetNewsHost(MSG_Pane* subscribepane, MSG_NewsHost* host); #endif /* SUBSCRIBE_USE_OLD_API */ /* Set our view to the given news or imap host. */ extern int MSG_SubscribeSetHost(MSG_Pane* subscribepane, MSG_Host* host); /* Gets the mode of the pane. */ extern MSG_SubscribeMode MSG_SubscribeGetMode(MSG_Pane* subscribepane); /* Sets the mode of the pane */ extern int MSG_SubscribeSetMode(MSG_Pane* subscribepane, MSG_SubscribeMode mode); /* Finds the first newsgroup whose name matches the given string. Expansions will automatically be done as necessary. Returns the index that matches; the FE should then scroll to and select that index. The pane must be in the "MSG_SubscribeAll" mode. */ extern MSG_ViewIndex MSG_SubscribeFindFirst(MSG_Pane* subscribepane, const char* str); /* Finds all the newsgroups that have the given string as a substring, and changes the view to show only those groups. The pane must be in the "MSG_SubscribeSearch" mode. */ extern int MSG_SubscribeFindAll(MSG_Pane* subscribepane, const char* str); /* Get information to display on these lines in the subscription pane outline list. Returns TRUE on success, FALSE if the given line doesn't exist or if there are less than numlines worth of data to get. The given data pointer must point to an array of at least numlines elements. */ extern XP_Bool MSG_GetGroupNameLineByIndex(MSG_Pane* subscribepane, MSG_ViewIndex firstline, int32 numlines, MSG_GroupNameLine* data); /* =========================================================================== OFFLINE NEWS =========================================================================== */ typedef enum MSG_PurgeByPreferences { MSG_PurgeNone, MSG_PurgeByAge, MSG_PurgeByNumHeaders } MSG_PurgeByPreferences; extern int MSG_SetOfflineRetrievalInfo( MSG_FolderInfo *newsGroup, XP_Bool useDefaults, XP_Bool byReadness, XP_Bool unreadOnly, XP_Bool byDate, int32 daysOld); extern int MSG_SetArticlePurgingInfo( MSG_FolderInfo *newsGroup, XP_Bool useDefaults, MSG_PurgeByPreferences purgeBy, int32 daysToKeep); extern int MSG_SetHeaderPurgingInfo( MSG_FolderInfo *newsGroup, XP_Bool useDefaults, MSG_PurgeByPreferences purgeBy, XP_Bool unreadOnly, int32 daysToKeep, int32 numHeadersToKeep ); extern void MSG_GetOfflineRetrievalInfo( MSG_FolderInfo *newsGroup, XP_Bool *pUseDefaults, XP_Bool *pByReadness, XP_Bool *pUnreadOnly, XP_Bool *pByDate, int32 *pDaysOld); extern void MSG_GetArticlePurgingInfo(MSG_FolderInfo *newsGroup, XP_Bool *pUseDefaults, MSG_PurgeByPreferences *pPurgeBy, int32 *pDaysToKeep); extern void MSG_GetHeaderPurgingInfo(MSG_FolderInfo *newsGroup, XP_Bool *pUseDefaults, MSG_PurgeByPreferences *pPurgeBy, XP_Bool *pUnreadOnly, int32 *pDaysToKeep, int32 *pNumHeadersToKeep); /* run the url to download mail and news articles for offline use for those folders so configured. */ extern int MSG_DownloadForOffline(MSG_Master *master, MSG_Pane *pane); extern int MSG_GoOffline(MSG_Master *master, MSG_Pane *pane, XP_Bool downloadDiscussions, XP_Bool getNewMail, XP_Bool sendOutbox); extern int MSG_DownloadFolderForOffline(MSG_Master *master, MSG_Pane *pane, MSG_FolderInfo *folder); /* =========================================================================== QUERIES =========================================================================== */ /* Get the filename for the folder on the given line. This string is perfect for passing to calls to MSG_MoveMessagesInto() and friends. String is allocated with XP_STRDUP so client needs to free. This should only be used for mail folders, it appears from the code. */ extern const char* MSG_GetFolderName(MSG_Pane* folderpane, MSG_ViewIndex line); /* return the full folder name from a folder id. String is not allocated so caller should duplicate it. For mail boxes, this returns the full folder path. This is currently used for filters to remember a full folder path. */ extern const char *MSG_GetFolderNameFromID(MSG_FolderInfo *); /* Get how many lines are in the list for this folderpane or threadpane or subscribepane. */ extern int32 MSG_GetNumLines(MSG_Pane* pane); /* Convert a MSG_FolderInfo* into a MSG_ViewIndex. Returns MSG_VIEWINDEXNONE if the given MSG_FolderInfo* is not being displayed anywhere. */ extern MSG_ViewIndex MSG_GetFolderIndex(MSG_Pane* folderpane, MSG_FolderInfo* info); /* This routine should replace the above routine when people port over to it. If expand is TRUE, we will expand the folderPane enough to expose the passed in folder info. Otherwise, if the folder is collapsed, we return MSG_ViewIndexNone. */ extern MSG_ViewIndex MSG_GetFolderIndexForInfo(MSG_Pane *folderpane, MSG_FolderInfo *info, XP_Bool expand); /* Converts a MSG_ViewIndex into a MSG_FolderInfo*. */ extern MSG_FolderInfo* MSG_GetFolderInfo(MSG_Pane* folderpane, MSG_ViewIndex index); extern MSG_FolderInfo* MSG_GetFolderInfoFromURL(MSG_Master* master, const char *url); /* returns folder info of host owning this folder*/ MSG_FolderInfo* GetHostFolderInfo(MSG_FolderInfo* info); extern MSG_FolderInfo* MSG_GetThreadFolder(MSG_Pane *threadpane); extern MSG_FolderInfo* MSG_GetCategoryContainerForCategory(MSG_FolderInfo *category); #ifdef SUBSCRIBE_USE_OLD_API /* Finds the newshost that contains the given folder. If the given folder is not a newsgroup, returns NULL. */ extern MSG_NewsHost* MSG_GetNewsHostForFolder(MSG_FolderInfo* folder); /* Converts a MSG_ViewIndex into a MSG_NewsHost */ extern MSG_NewsHost *MSG_GetNewsHostFromIndex (MSG_Pane *folderPane, MSG_ViewIndex index); #endif /* SUBSCRIBE_USE_OLD_API */ /* Finds the host that contains the given folder. If the given folder is not a newsgroup or IMAP folder, returns NULL. */ extern MSG_Host *MSG_GetHostForFolder(MSG_FolderInfo* folder); /* Converts a MSG_ViewIndex into a MSG_Host */ extern MSG_Host *MSG_GetHostFromIndex (MSG_Pane *folderPane, MSG_ViewIndex index); /* Gets the MSG_FolderInfo object associated with a given MSG_Host. */ extern MSG_FolderInfo *MSG_GetFolderInfoForHost(MSG_Host *host); /* given a url containing a message id, fill in the message line info for the msg. For news urls, the news group will need to be open! */ extern int MSG_GetMessageLineForURL(MSG_Master* master, const char *url, MSG_MessageLine *msgLine); /* This routine should replace the MSG_GetMessageIndex when people port over to it. If expand is TRUE, we will expand the folderPane enough to expose the passed in folder info. Otherwise, if the folder is collapsed, we return MSG_ViewIndexNone. */ extern MSG_ViewIndex MSG_GetMessageIndexForKey(MSG_Pane* threadpane, MessageKey key, XP_Bool expand); /* Look up the MessageKey based on the message ID */ extern int MSG_GetKeyFromMessageId (MSG_Pane *message_pane, const char *message_id, MessageKey *outKey); /* Converts a MSG_ViewIndex into a MessageKey. */ extern MessageKey MSG_GetMessageKey(MSG_Pane* threadpane, MSG_ViewIndex index); /* Getting a message key from the undo manager for dsiplay */ extern XP_Bool MSG_GetUndoMessageKey (MSG_Pane* pane, MSG_FolderInfo** pFolderInfo, MessageKey* pKey); /* Get current undo operation status */ extern UndoStatus MSG_GetUndoStatus (MSG_Pane* pane); /* Get Undo Manager State */ extern UndoMgrState MSG_GetUndoState(MSG_Pane* pane); /* Given a MSG_FolderInfo*, returns the number of children folders. If the result pointer is not NULL, fills it in with the list of children (providing up to resultsize entries.) If the given MSG_FolderInfo* is NULL, then returns the list of top-level folders. */ extern int32 MSG_GetFolderChildren(MSG_Master* master, MSG_FolderInfo* folder, MSG_FolderInfo** result, int32 resultsize); /* Returns the container of all local (off-line) mail folders. */ extern MSG_FolderInfo* MSG_GetLocalMailTree(MSG_Master* master); /* Returns the number of mail folders (both local and IMAP). If this number is greater than zero, an array of pointers to the MSG_FolderInfos is allocated and returned in result. The caller is responsible for freeing the array. This function is not recursive, it only returns the top level mail folders. */ extern int32 MSG_ListMailFolders(MSG_Master *master, MSG_FolderInfo ***result); /* Given a flag or set of flags, returns the number of folders that have that flag set. If the result pointer is not NULL, fills it in with the list of folders (providing up to resultsize entries). */ extern int32 MSG_GetFoldersWithFlag(MSG_Master* master, uint32 flags, MSG_FolderInfo** result, int32 resultsize); /* Returns what folder a threadpane is viewing (NULL if not viewing anything.) */ extern MSG_FolderInfo* MSG_GetCurFolder(MSG_Pane* threadpane); /* Call this from the new Create Folder UI with the dropdown list. The MSG_Command will go away when everyone uses this. This should not be called anymore - keeping it for a smooth transition to MSG_CreateMailFolderWithPane (below) */ extern int MSG_CreateMailFolder (MSG_Master *master, MSG_FolderInfo *parent, const char *childName); /* Call this from the new Create Folder UI with the dropdown list. The MSG_Command will go away when everyone uses this. Call with invokingPane set to the pane with which to run any IMAP Create-Folder URLs. (probably the pane from which it was invoked, or a progress pane) */ extern int MSG_CreateMailFolderWithPane (MSG_Pane *invokingPane, MSG_Master *master, MSG_FolderInfo *parent, const char *childName); /* FEs should call this to determine what folder we should suggest as the parent folder, when creating a new folder. current is the MSG_FolderInfo of the currently selected folder or host. Returns the MSG_FolderInfo for the suggested parent, given the currently selected folder or host. Returns NULL if current is NULL. */ extern MSG_FolderInfo *MSG_SuggestNewFolderParent(MSG_FolderInfo *current); /* Call this from the new folder properties UI */ extern int MSG_RenameMailFolder (MSG_Pane *folderPane, MSG_FolderInfo *folder, const char *newName); /* Returns what folder and message a messagepane is currently displaying. (Sets the folder to NULL and the key to MSG_MESSAGEKEYNONE if the messagepane is currently displaying nothing.) */ extern void MSG_GetCurMessage(MSG_Pane* messagepane, MSG_FolderInfo** folder, MessageKey* key, MSG_ViewIndex *index); /* Returns what attachments are being viewed in the messagepane, and whether we're certain it's the entire list. (If the data is still being downloaded, then there could still be attachments that we don't know about.) The returned data must be free'd using MSG_FreeAttachmentList(). */ extern int MSG_GetViewedAttachments(MSG_Pane* messagepane, MSG_AttachmentData** data, XP_Bool* iscomplete); /* Frees the attachemnt data returned by MSG_GetViewedAttachments(). */ extern void MSG_FreeAttachmentList(MSG_Pane* messagepane, MSG_AttachmentData* data); /* These return NULL if they fail. Caller must call NET_FreeURLStruct */ extern URL_Struct* MSG_ConstructUrlForPane(MSG_Pane *pane); extern URL_Struct* MSG_ConstructUrlForMessage(MSG_Pane *pane, MessageKey key); extern URL_Struct* MSG_ConstructUrlForFolder(MSG_Pane *pane, MSG_FolderInfo *folder); /* Returns whether the user has asked to rot13 messages displayed in this pane. (Used by libmime.) */ extern XP_Bool MSG_ShouldRot13Message(MSG_Pane* messagepane); /* =========================================================================== BIFF =========================================================================== */ /* biff is the unixy name for "Check for New Mail". It comes from the unix command of the same name; the author of that command named it after his dog, who would bark at him whenever he had new mail... */ /* The different biff states we can be in: */ typedef enum { MSG_BIFF_NewMail, /* User has new mail waiting. */ MSG_BIFF_NoMail, /* No new mail is waiting. */ MSG_BIFF_Unknown /* We dunno whether there is new mail. */ } MSG_BIFF_STATE; /* Register and unregister biff callback functions */ typedef void (*MSG_BIFF_CALLBACK)(MSG_BIFF_STATE oldState, MSG_BIFF_STATE newState); extern void MSG_RegisterBiffCallback( MSG_BIFF_CALLBACK cb ); extern void MSG_UnregisterBiffCallback(); /* Get and set the current biff state */ extern MSG_BIFF_STATE MSG_GetBiffState(); extern void MSG_SetBiffStateAndUpdateFE(MSG_BIFF_STATE newState); /* Set the preference of how often to run biff. If zero is passed in, then never check. */ extern void MSG_SetBiffInterval(int32 seconds); #ifdef XP_UNIX /* Set the file to stat, instead of using pop3. This is for the Unix movemail nonsense. If the filename is NULL (the default), then use pop3. */ extern void MSG_SetBiffStatFile(const char* filename); #endif /* Initialize the biff context. Note that biff contexts exist entirely independent of mail contexts; it's up to the FE to decide what order they get created and stuff. */ extern int MSG_BiffInit(MWContext* context, MSG_Prefs* prefs); /* The biff context is about to go away. The FE must call this first to clean up. */ extern int MSG_BiffCleanupContext(MWContext* context); /* Causes a biff check to occur immediately. This gets caused automatically by MSG_SetBiffInterval or whenever libmsg gets new mail. */ extern void MSG_BiffCheckNow(MWContext* context); /* Tell the FE to render in all the right places this latest knowledge as to whether we have new mail waiting. */ extern void FE_UpdateBiff(MSG_BIFF_STATE state); /* =========================================================================== OTHER INTERFACES =========================================================================== */ /* Certain URLs must always be displayed in certain types of windows: for example, all "mailbox:" URLs must go in the mail window, and all "http:" URLs must go in a browser window. These predicates look at the address and say which window type is required. */ extern XP_Bool MSG_RequiresMailWindow (const char *url); extern XP_Bool MSG_RequiresNewsWindow (const char *url); extern XP_Bool MSG_RequiresBrowserWindow (const char *url); extern XP_Bool MSG_RequiresComposeWindow (const char *url); /* If this URL requires a particular kind of window, and this is not that kind of window, then we need to find or create one. */ extern XP_Bool MSG_NewWindowRequired (MWContext *context, const char *url); /* If this URL requires a particular kind of window, and this is not that kind of window, then we need to find or create one. This routine takes a URL_Struct, which allows it to be smarter than the above routine. */ extern XP_Bool MSG_NewWindowRequiredForURL (MWContext *context, URL_Struct *urlStruct); /* If we're in a mail window, and clicking on a link which will itself require a mail window, then don't allow this to show up in a different window - since there can be only one mail window. */ extern XP_Bool MSG_NewWindowProhibited (MWContext *context, const char *url); /* When the front end loads a url, it needs to know what kind of pane the url should be loaded into. */ extern MSG_PaneType MSG_PaneTypeForURL(const char *url); /* Returns the number of bytes available on the disk where the given directory is - this is so we know whether there is room to incorporate new mail. */ extern uint32 FE_DiskSpaceAvailable (MWContext* context, const char* dir); /* =========================================================================== SECURE MAIL =========================================================================== */ extern MSG_SecurityLevel MSG_GetMessageSecurityLevel(MSG_Pane *pPane); extern const XP_List *MSG_GetRecipientsWithNoCerts(MSG_Pane *pPane); extern XP_Bool MSG_ShouldEncryptMessage(MSG_Pane *pPane); extern XP_Bool MSG_ShouldSignMessage(MSG_Pane *pPane); /* FEs call this any time the set of recipients on the compose window changes. They should make the state (and sensitivity) of the "sign" and "encrypt" checkboxes, and the state of the "security" button, correspond to the returned boolean values. Maybe this function doesn't really belong here, but it's as good a place as any... */ /* (This is maybe not the most appropriate header file for this proto.) */ extern void SEC_GetMessageCryptoViability(const char *from, const char *reply_to, const char *to, const char *cc, const char *bcc, const char *newsgroups, const char *followup_to, XP_Bool *signing_possible_return, XP_Bool *encryption_possible_return); /* Returns TRUE if the user has selected the preference that says that new mail messages should be encrypted by default. */ extern XP_Bool MSG_GetMailEncryptionPreference(void); /* Returns TRUE if the user has selected the preference that says that new mail messages should be cryptographically signed by default. */ extern XP_Bool MSG_GetMailSigningPreference(void); /* Returns TRUE if the user has selected the preference that says that new news messages should be cryptographically signed by default. */ extern XP_Bool MSG_GetNewsSigningPreference(void); /* =========================================================================== COMPOSE WINDOW =========================================================================== */ /* This is how the `mailto' parser asks the message library to create a message composition window. That window has its own context. The `old_context' arg is the context from which the mailto: URL was loaded. It may be NULL. Any of the fields may be 0 or "". Some of them (From, BCC, Organization, etc) will be given default values if none is provided. This returns the new composition pane. */ extern MSG_Pane* MSG_ComposeMessage(MWContext *old_context, const char *from, const char *reply_to, const char *to, const char *cc, const char *bcc, const char *fcc, const char *newsgroups, const char *followup_to, const char *organization, const char *subject, const char *references, const char *other_random_headers, const char *priority, const char *attachment, const char *newspost_url, const char *body, XP_Bool encrypt_p, XP_Bool sign_p, XP_Bool force_plain_text, const char* html_part); extern MSG_CompositionFields* MSG_CreateCompositionFields( const char *from, const char *reply_to, const char *to, const char *cc, const char *bcc, const char *fcc, const char *newsgroups, const char *followup_to, const char *organization, const char *subject, const char *references, const char *other_random_headers, const char *priority, const char *attachment, const char *newspost_url, XP_Bool encrypt_p, XP_Bool sign_p); extern void MSG_DestroyCompositionFields(MSG_CompositionFields *fields); /* Tell the FE that something has changed in the composition (like, we finished quoting or something) so that it needs to update the status of toolbars and stuff. This call should go away. ###tw */ extern void FE_UpdateCompToolbar(MSG_Pane* comppane); /* Tell the FE that we're all done with the given context (which was associated with a composition pane that we're destroying). Presumably, the FE will then destroy the context. */ extern void FE_DestroyMailCompositionContext(MWContext* context); /* Determines whether this is a mail composition that ought to have a "quote message" operation done at startup. If so, the FE must call MSG_QuoteMessage and handle it, and when done call MSG_SetInitialState(). */ extern XP_Bool MSG_ShouldAutoQuote(MSG_Pane* comppane); /* Get and set the various things that a user may have typed. These are all initialized automatically by the constructor from the MSG_CompositionFields* object. The FE needs to done setting everything before doing sanity checks or sending the message. MSG_SetCompHeader should not be made with the header MSG_ATTACHMENTS_HEADER_MASK; instead, call MSG_SetAttachmentList(). However, the FE may call MSG_GetCompHeader() with MSG_ATTACHMENTS_HEADER_MASK to find the summary line to display. */ extern const char* MSG_GetCompHeader(MSG_Pane* comppane, MSG_HEADER_SET header); extern int MSG_SetCompHeader(MSG_Pane* comppane, MSG_HEADER_SET header, const char* value); extern const char* MSG_GetCompFieldsHeader(MSG_CompositionFields *fields, MSG_HEADER_SET header); extern int MSG_SetCompFieldsHeader(MSG_CompositionFields *fields, MSG_HEADER_SET header, const char* value); extern void MSG_SetCompFieldsReceiptType(MSG_CompositionFields *fields, int32 type); extern int32 MSG_GetCompFieldsReceiptType(MSG_CompositionFields *fields); extern XP_Bool MSG_GetCompBoolHeader(MSG_Pane* comppane, MSG_BOOL_HEADER_SET header); extern int MSG_SetCompBoolHeader(MSG_Pane* comppane, MSG_BOOL_HEADER_SET header, XP_Bool value); extern XP_Bool MSG_GetCompFieldsBoolHeader(MSG_CompositionFields *fields, MSG_BOOL_HEADER_SET header); extern int MSG_SetCompFieldsBoolHeader(MSG_CompositionFields *fields, MSG_BOOL_HEADER_SET header, XP_Bool value); /* Get whether we should force plain-text composition by default. */ extern XP_Bool MSG_GetForcePlainText(MSG_CompositionFields* fields); extern const char* MSG_GetCompBody(MSG_Pane* comppane); extern int MSG_SetCompBody(MSG_Pane* comppane, const char* body); /* These following four functions are provided to make implementing the grid-based compose window a bit easier. A new type definition (MSG_HeaderEntry) is introduced which is used to store individual address entries. -- jevering */ typedef struct { MSG_HEADER_SET header_type; char * header_value; } MSG_HeaderEntry; /* MSG_ExplodeHeaderField() parses a single header entry and returns a list of MSG_HeaderEntry structures. The return value is the number of items in the return list or -1 for an error. The return list as well as its contents should be freed by the caller. */ extern int MSG_ExplodeHeaderField( MSG_HEADER_SET msg_header, const char * field, MSG_HeaderEntry **return_list); /* This function retrieve the contents of the current compose window headers and parses them into a MSG_HeaderEntry list with one address per line. Call this function when constructing the compose window in order to initialize the grid-widget. This function returns the number of items in the list or -1 indicating an error. The return list should be freed by the caller. */ extern int MSG_RetrieveStandardHeaders(MSG_Pane * pane, MSG_HeaderEntry ** return_list); /* This function accepts a list of single-entry address items and condenses it down to a list of comma separated addressed. The order of occurance is maintained on a MSG_HEADER_SET basis. The return value indicated the size of the list. A return value of -1 indicates that an error has occured. The returned list as well as its contents should be freed by the caller. */ extern int MSG_CompressHeaderEntries(MSG_HeaderEntry * in_list, int list_size, MSG_HeaderEntry ** return_list); /* call this function with the list returned by MSG_CompressHeaderEntries(). pane - message pane, count - number of entries in list. The previous headers are cleared and the contents of the new list is used. The memory is freed as well. */ extern void MSG_SetHeaderEntries(MSG_Pane * pane, MSG_HeaderEntry * in_list, int count); /* Clears all compose window headers (except the attachment list). */ extern void MSG_ClearComposeHeaders(MSG_Pane * pane); /* Begin a "quote message" operation. This is complicated, because this is an asynchronous operation. (Getting the message to quote can be a network operation). So, the FE must provide a callback routine that inserts the quoted data, piecemeal. The callback will get called with a NULL string when things are all done (or if things failed or were cancelled.) The callback routine should return a negative value on error. Actually, if we're an HTML composition, we call the editor functions directly, and ignore the given func(). Pretty rude, huh. */ #ifdef XP_OS2 typedef int (*PNSQMFN)(void *, const char *); extern void MSG_QuoteMessage(MSG_Pane* comppane, PNSQMFN func, void* closure); #else extern void MSG_QuoteMessage(MSG_Pane* comppane, int (*func)(void* closure, const char* data), void* closure); #endif /* The FE is about to call MSG_SendComposition to cause things to be sent, but first, it wants to make sure that the user isn't trying to send something blatently stupid (like, no subject, or no body, or no "To:", or whatever). So, there's various sanity checks for it to make, and the FE can then take appropriate actions if the check failed. Each sanity check returns an error code describing the problem. The FE can pop up the string for that error code in a FE_Confirm() call. If FE_Confirm() returns TRUE, then the user doesn't care and wants to send the message anyway, so the FE can just call MSG_SanityCheck() again and pass the given errorcode as the skippast parameter. libmsg will skip that sanity check, and all the previous ones, and confirm that the other things work. It's up to the FE how to handle each error code; the FE_Confirm() method is just the suggested default. In particular, the FE should prompt the user for the subject if we return MK_MSG_MISSING_SUBJECT. The current sanity checks are: MK_MSG_MISSING_SUBJECT: There is no subject line. MK_MSG_EMPTY_MESSAGE: There is no real body, and no attachments. MK_MSG_DOUBLE_INCLUDE: The original message was both quoted and attached. MK_MSG_MIXED_SECURITY: Some recipients have certificates; some not. */ extern int MSG_SanityCheck(MSG_Pane* comppane, int skippast); /* Get the URL associated with this context (the "X-Url" field.) */ extern const char* MSG_GetAssociatedURL(MSG_Pane* comppane); /* This is completely foul, but the FE needs to call this from within FE_AllConnectionsComplete() when the context->type is MWContextMessageComposition. */ extern void MSG_MailCompositionAllConnectionsComplete (MSG_Pane* pane); /* */ /* Bring up the dialog box that presents the user with the list of domains that have been marked for HTML, and let the user edit them. */ extern int MSG_DisplayHTMLDomainsDialog(MWContext* context); /* Returns whether the given folderinfo represents a newsgroup where HTML postings are OK. This is to be used in the property dialog for that newsgroup. This call should only be done on newsgroups. */ extern XP_Bool MSG_IsHTMLOK(MSG_Master* master, MSG_FolderInfo* group); /* Sets whether the given newsgroup can have HTML. This can potentially pop up a confirmation window, so we ask for a MWContext* to use for that (yick). The folderinfo provided must represent a newsgroup. This is to be used in the property dialog for that newsgroup. */ extern int MSG_SetIsHTMLOK(MSG_Master* master, MSG_FolderInfo* group, MWContext* context, XP_Bool value); /* Utility function that prefixes each line with "> " (for Paste As Quote). */ extern char *MSG_ConvertToQuotation (const char *string); /* Paste the given plaintext into the running HTML editor as a quotation. This can only be used if the given composition pane is in HTML mode. */ extern int MSG_PastePlaintextQuotation(MSG_Pane* comppane, const char* string); /* The user has just finished editing a given header (the field has lost focus or something like that.) Find out if some magic change needs to be made (e.g., the user typed a nickname from the addressbook and we want to replace it with the specified address.) If so, a new value to be displayed is returned. The returned string, if any, must be freed using XP_FREE(). This should be called before calling MSG_SetCompHeader(). */ extern char* MSG_UpdateHeaderContents(MSG_Pane* comppane, MSG_HEADER_SET header, const char* value); /* If the sanity check return MK_MSG_MIXED_SECURITY, then the user may choose to remove non-secure people from the list. The FE can do so by calling this routine. It will then have to call MSG_GetCompHeader a few times to get and redisplay the new values for the To, Cc, and Bcc fields. */ extern void MSG_RemoveNoCertRecipients(MSG_Pane* comppane); /* Inform the backend what is to be attached. The MSG_AttachmentData structure is defined in mime.h. The "list" parameter is an array of these fields, terminated by one which has a NULL url field. In each entry, all that you have to fill in is "url" and probably "desired_type"; NULL is generally fine for all the other fields (but you can fill them in too). See mime.h for all the spiffy details. Note that this call copies (sigh) all the data into libmsg; it is up to the caller to free any data it had to allocate to create the MSG_AttachmentData structure. */ extern int MSG_SetAttachmentList(MSG_Pane* comppane, struct MSG_AttachmentData* list); /* Get what msglib's idea of what the current attachments are. DO NOT MODIFY THE DATA RETURNED; you can look, but don't touch. If you want to change the data, you have to copy out the whole structure somewhere, make your changes, call MSG_SetAttachmentList() with your new data, and then free your copy. If there are no attachments, this routine always returns NULL. */ extern const struct MSG_AttachmentData* MSG_GetAttachmentList(MSG_Pane* comppane); /* The FE should call this in response to a `Show Interesting Headers' command, and when first initializing the composition window.. It returns the set of headers that ought to be displayed (and checked in the "view" menu.) */ extern MSG_HEADER_SET MSG_GetInterestingHeaders(MSG_Pane* comppane); /* This function creates a new, blank mail message composition window. It causes calls to FE_CreateCompositionPane, which should drive the creation of the window. */ MSG_Pane* MSG_Mail(MWContext *old_context); /* Convenience function to start composing a mail message from a web browser window - the currently-loaded document will be the default attachment should the user choose to attach it. The context may be of any type, or NULL. Returns the new message composition pane. This is going away, you should call MSG_MailDocumentURL with NULL for the second argument. */ extern MSG_Pane* MSG_MailDocument(MWContext *context); /* Another version of MSG_MailDocument where pAttachmentURL explicitly gives the URL to attach. MSG_MailDocument() is still there for backwards compatability. */ extern MSG_Pane* MSG_MailDocumentURL(MWContext *context,const char *pAttachmentURL); /* These routines were in mime.h, but defined in libmsg...*/ /* Given a string which contains a list of RFC822 addresses, parses it into their component names and mailboxes. The returned value is the number of addresses, or a negative error code; the names and addresses are returned into the provided pointers as consecutive null-terminated strings. It is up to the caller to free them. Note that some of the strings may be zero-length. Either of the provided pointers may be NULL if the caller is not interested in those components. */ extern int MSG_ParseRFC822Addresses (const char *line, char **names, char **addresses); /* Given a string which contains a list of RFC822 addresses, returns a comma-seperated list of just the `mailbox' portions. */ extern char *MSG_ExtractRFC822AddressMailboxes (const char *line); /* Given a string which contains a list of RFC822 addresses, returns a comma-seperated list of just the `user name' portions. If any of the addresses doesn't have a name, then the mailbox is used instead. */ extern char *MSG_ExtractRFC822AddressNames (const char *line); /* Like MSG_ExtractRFC822AddressNames(), but only returns the first name in the list, if there is more than one. */ extern char *MSG_ExtractRFC822AddressName (const char *line); /* Given a string which contains a list of RFC822 addresses, returns a new string with the same data, but inserts missing commas, parses and reformats it, and wraps long lines with newline-tab. */ extern char * MSG_ReformatRFC822Addresses (const char *line); /* Returns a copy of ADDRS which may have had some addresses removed. Addresses are removed if they are already in either ADDRS or OTHER_ADDRS. (If OTHER_ADDRS contain addresses which are not in ADDRS, they are not added. That argument is for passing in addresses that were already mentioned in other header fields.) Addresses are considered to be the same if they contain the same mailbox part (case-insensitive.) Real names and other comments are not compared. */ extern char *MSG_RemoveDuplicateAddresses (const char *addrs, const char *other_addrs); /* Given an e-mail address and a person's name, cons them together into a single string of the form "name
", doing all the necessary quoting. A new string is returned, which you must free when you're done with it. */ extern char *MSG_MakeFullAddress (const char* name, const char* addr); /* MSG_ParseRFC822Addresses returns quoted parsable addresses This function removes the quoting if you want to show the names to users. e.g. summary file, address book */ extern int MSG_UnquotePhraseOrAddr (char *line, char** lineout); /* Returns the address book context, creating it if necessary. A mail pane is passed in, on the unlikely chance that it might be useful for the FE. If "viewnow" is TRUE, then present the address book window to the user; otherwise, don't (unless it is already visible).*/ extern MWContext* FE_GetAddressBookContext(MSG_Pane* pane, XP_Bool viewnow); /* Notify the address book panes that the list of directory servers has changed This is only called from the address book. */ extern int MSG_NotifyChangeDirectoryServers(); XP_END_PROTOS #endif /* _MSGCOM_H_ */