Bommels05/Mozilla
Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Mozilla/mozilla/cmd/xfe/src/ThreadView.cpp
akkana d42d73c42b 226857: Normandy landing didn't include kini's notification center fix. 
git-svn-id: svn://10.0.0.236/trunk@4882 18797224-902f-48f8-a5cc-f745e15eee43
1998-07-02 01:31:12 +00:00

3763 lines
101 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.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.
*/
/*
ThreadView.cpp -- presents view of mail threads.
Created: Chris Toshok <toshok@netscape.com>, 7-Aug-96.
*/
#include "MozillaApp.h"
#include "ThreadView.h"
#include "MsgFrame.h"
#include "FolderFrame.h"
#include "FolderMenu.h"
#include "ViewGlue.h"
#if defined(USE_MOTIF_DND)
#include "OutlinerDrop.h"
#endif /* USE_MOTIF_DND */
#include "xpassert.h"
#include "xfe.h"
#include "icondata.h"
#include "msgcom.h"
#if defined(USE_ABCOM)
#include "ABListSearchView.h"
#endif /* USE_ABCOM */
//#include "allxpstr.h"
#include "felocale.h" /* for fe_ConvertToLocalEncoding */
#include "xp_mem.h"
#include "Xfe/Xfe.h"
#include <Xm/ArrowB.h>
#include <Xm/Form.h>
#include <Xm/Label.h>
#include <Xm/PanedW.h>
#include "MNSearchFrame.h"
#include "MailFilterDlg.h"
#include "LdapSearchFrame.h"
#include "prefs.h"
#include "prefapi.h"
#ifdef DEBUG_toshok
#define D(x) x
#else
#define D(x)
#endif
#ifdef DEBUG_dora
#define DD(x) x
#else
#define DD(x)
#endif
#define OUTLINER_GEOMETRY_PREF "mail.threadpane.outliner_geometry"
#define MESSAGEPANE_HEIGHT_PREF "mail.threadpane.messagepane_height"
#include "xpgetstr.h"
/*
extern int MSG_HasAttachments(MSG_Pane* pane, MessageKey msgKey, XP_Bool *pHasThem);
*/
extern int XFE_RE;
extern int XFE_WINDOW_TITLE_NEWSGROUP;
extern int XFE_WINDOW_TITLE_FOLDER;
extern int XFE_SIZE_IN_LINES;
extern int XFE_SIZE_IN_BYTES;
extern int XFE_THREAD_OUTLINER_COLUMN_SUBJECT;
extern int XFE_THREAD_OUTLINER_COLUMN_DATE;
extern int XFE_THREAD_OUTLINER_COLUMN_PRIORITY;
extern int XFE_THREAD_OUTLINER_COLUMN_STATUS;
extern int XFE_THREAD_OUTLINER_COLUMN_SENDER;
extern int XFE_THREAD_OUTLINER_COLUMN_RECIPIENT;
extern int XP_STATUS_NEW;
extern int XP_STATUS_REPLIED_AND_FORWARDED;
extern int XP_STATUS_FORWARDED;
extern int XP_STATUS_REPLIED;
extern int MK_MSG_CANCEL_MESSAGE;
extern int MK_MSG_DELETE_SEL_MSGS;
extern int XFE_DND_MESSAGE_ERROR;
const int XFE_ThreadView::OUTLINER_COLUMN_SUBJECT = 0;
const int XFE_ThreadView::OUTLINER_COLUMN_SENDERRECIPIENT = 1;
const int XFE_ThreadView::OUTLINER_COLUMN_UNREADMSG = 2;
const int XFE_ThreadView::OUTLINER_COLUMN_DATE = 3;
const int XFE_ThreadView::OUTLINER_COLUMN_PRIORITY = 4;
const int XFE_ThreadView::OUTLINER_COLUMN_FLAG = 5;
const int XFE_ThreadView::OUTLINER_COLUMN_STATUS = 6;
const int XFE_ThreadView::OUTLINER_COLUMN_SIZE = 7;
// Minimum and maximum sizes for the paned window panes:
#define PANE_MIN 50
#define PANE_MAX 6000
fe_icon XFE_ThreadView::threadonIcon = { 0 };
fe_icon XFE_ThreadView::threadoffIcon = { 0 };
MenuSpec XFE_ThreadView::priority_popup_submenu[] = {
{ xfeCmdSetPriorityHighest, PUSHBUTTON },
{ xfeCmdSetPriorityHigh, PUSHBUTTON },
{ xfeCmdSetPriorityNormal, PUSHBUTTON },
{ xfeCmdSetPriorityLow, PUSHBUTTON },
{ xfeCmdSetPriorityLowest, PUSHBUTTON },
{ NULL }
};
MenuSpec XFE_ThreadView::news_popup_spec[] = {
{ xfeCmdOpenSelected, PUSHBUTTON },
// open in new window
MENU_SEPARATOR,
// Setting the call data to non-null is a signal to commandToString
// not to reset the menu string
{ xfeCmdReplyToSender, PUSHBUTTON, NULL, NULL, False, "reply-to-sender" },
{ xfeCmdReplyToAll, PUSHBUTTON, NULL, NULL, False, "reply-to-all" },
{ xfeCmdReplyToNewsgroup, PUSHBUTTON, NULL, NULL, False, "reply-to-newsgroup" },
{ xfeCmdReplyToSenderAndNewsgroup, PUSHBUTTON, NULL, NULL, False, "reply-to-sender-and-newsgroup" },
{ xfeCmdForwardMessage, PUSHBUTTON },
{ xfeCmdForwardMessageQuoted, PUSHBUTTON },
{ xfeCmdForwardMessageInLine, PUSHBUTTON },
MENU_SEPARATOR,
{ "addToABSubmenu", CASCADEBUTTON,
(MenuSpec *) &addrbk_submenu_spec },
MENU_SEPARATOR,
{ xfeCmdIgnoreThread, PUSHBUTTON },
{ xfeCmdWatchThread, PUSHBUTTON },
MENU_SEPARATOR,
{ "fileSubmenu", DYNA_CASCADEBUTTON, NULL, NULL, False, (void*)xfeCmdMoveMessage, XFE_FolderMenu::generate },
{ xfeCmdDeleteMessage, PUSHBUTTON },
{ xfeCmdSaveMessagesAs, PUSHBUTTON },
{ xfeCmdPrint, PUSHBUTTON },
{ NULL }
};
MenuSpec XFE_ThreadView::mail_popup_spec[] = {
{ xfeCmdOpenSelected, PUSHBUTTON },
MENU_SEPARATOR,
// Setting the call data to non-null is a signal to commandToString
// not to reset the menu string
{ xfeCmdReplyToSender, PUSHBUTTON, NULL, NULL, False, "reply-to-sender" },
{ xfeCmdReplyToAll, PUSHBUTTON, NULL, NULL, False, "reply-to-all" },
{ xfeCmdForwardMessage, PUSHBUTTON },
{ xfeCmdForwardMessageQuoted, PUSHBUTTON },
{ xfeCmdForwardMessageInLine, PUSHBUTTON },
MENU_SEPARATOR,
{ "addToABSubmenu", CASCADEBUTTON,
(MenuSpec *) &addrbk_submenu_spec },
MENU_SEPARATOR,
{ xfeCmdIgnoreThread, PUSHBUTTON },
{ xfeCmdWatchThread, PUSHBUTTON },
MENU_SEPARATOR,
{ "changePriority", CASCADEBUTTON, priority_popup_submenu },
MENU_SEPARATOR,
{ "fileSubmenu", DYNA_CASCADEBUTTON, NULL, NULL, False, (void*)xfeCmdMoveMessage, XFE_FolderMenu::generate },
{ xfeCmdDeleteMessage, PUSHBUTTON },
{ xfeCmdSaveMessagesAs, PUSHBUTTON },
{ xfeCmdPrint, PUSHBUTTON },
{ NULL }
};
MenuSpec XFE_ThreadView::addrbk_submenu_spec[] = {
{ xfeCmdAddSenderToAddressBook, PUSHBUTTON },
{ xfeCmdAddAllToAddressBook, PUSHBUTTON },
// { xfeCmdAddCardToAddressBook, PUSHBUTTON } ?
{ NULL }
};
extern "C" void fe_showSubscribeDialog(XFE_NotificationCenter *toplevel,
Widget parent, MWContext *context,
MSG_Host *host = NULL);
XFE_ThreadView::XFE_ThreadView(XFE_Component *toplevel_component,
Widget parent,
XFE_View *parent_view, MWContext *context,
MSG_Pane *p)
: XFE_MNListView(toplevel_component, parent_view, context, p)
{
/* initialize
*/
m_nLoadingFolders = 0;
m_frameDeleted = False;
/* timer
*/
m_scrollTimer = 0 ;
m_targetIndex = MSG_VIEWINDEXNONE;
#if HANDLE_CMD_QUEUE
m_lastLoadedInd = MSG_VIEWINDEXNONE;
m_lastLoadedKey = MSG_MESSAGEKEYNONE;
m_lineChanged = MSG_VIEWINDEXNONE;
m_selected = NULL;
m_selectedCount = 0;
m_deleted = NULL;
m_deletedCount = 0;
m_collapsed = NULL;
m_collapsedCount = 0;
#endif /* HANDLE_CMD_QUEUE */
Widget panedw;
int num_columns = 8;
XtWidgetGeometry arrow_geo;
static int default_column_widths[] = {30, 20, 3, 20, 9, 3, 15, 6};
panedw = XtVaCreateWidget("panedw",
xmPanedWindowWidgetClass,
parent,
NULL);
// create the outliner message list.
m_outliner = new XFE_Outliner("messageList",
this,
getToplevel(),
panedw,
FALSE, // constantSize
TRUE, // hasHeadings
num_columns,
5,
default_column_widths,
OUTLINER_GEOMETRY_PREF);
// initialize the icons if they haven't already been
{
Pixel bg_pixel;
XtVaGetValues(m_outliner->getBaseWidget(), XmNbackground, &bg_pixel, 0);
initMessageIcons(getToplevel()->getBaseWidget(),
getToplevel()->getFGPixel(),
bg_pixel);
}
// now that we've created the icons, we can size the two icon-only columns to be
// the widths required of the pixmaps.
m_outliner->setColumnWidth ( OUTLINER_COLUMN_UNREADMSG, msgUnreadIcon.width + 2 /* for the outliner's shadow */);
m_outliner->setColumnWidth ( OUTLINER_COLUMN_FLAG, msgFlagIcon.width + 2 /* for the outliner's shadow */);
m_outliner->setPipeColumn( OUTLINER_COLUMN_SUBJECT );
m_outliner->setMultiSelectAllowed( True );
m_outliner->setColumnResizable( OUTLINER_COLUMN_UNREADMSG, False );
m_outliner->setColumnResizable( OUTLINER_COLUMN_FLAG, False );
m_outliner->setHideColumnsAllowed( True );
#if !defined(USE_MOTIF_DND)
fe_dnd_CreateDrop(m_outliner->getBaseWidget(), drop_func, this);
#endif /* USE_MOTIF_DND */
XtVaSetValues(m_outliner->getBaseWidget(),
XmNallowResize, TRUE,
XmNpaneMinimum, PANE_MIN, // should this be a resource?
XmNpaneMaximum, PANE_MAX, // why is the limit in HPaned 1000???
NULL);
m_outliner->show();
// create the arrow button stuff
m_arrowform = XtVaCreateManagedWidget("arrowform",
xmFormWidgetClass,
panedw,
XmNallowResize, FALSE,
XmNskipAdjust, TRUE,
NULL);
m_arrowb = XtVaCreateManagedWidget("arrowb",
xmArrowButtonWidgetClass,
m_arrowform,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_NONE,
XmNarrowDirection, XmARROW_DOWN,
XmNshadowThickness, 0,
NULL);
XtAddCallback(m_arrowb, XmNactivateCallback, toggleMsgExpansionCallback, this);
// Arrow label should be blank initially.
XmString tempString = XmStringCreateSimple(" ");
m_arrowlabel = XtVaCreateManagedWidget("arrowlabel",
xmLabelWidgetClass,
m_arrowform,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, m_arrowb,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNalignment, XmALIGNMENT_BEGINNING,
XmNlabelString, tempString,
NULL);
XmStringFree(tempString);
arrow_geo.request_mode = CWHeight;
XtQueryGeometry(m_arrowform, NULL, &arrow_geo);
XtVaSetValues(m_arrowform,
XmNpaneMaximum, arrow_geo.height,
XmNpaneMinimum, arrow_geo.height,
NULL);
// create the message viewing area.
m_msgview = new XFE_MsgView(toplevel_component, panedw, this, m_contextData);
addView(m_msgview);
XtVaSetValues(m_msgview->getBaseWidget(),
XmNallowResize, TRUE,
XmNpaneMinimum, PANE_MIN, // should this be a resource?
XmNpaneMaximum, PANE_MAX, // why is the limit in PanedW 1000???
NULL);
m_msgview->registerInterest(XFE_MsgView::spacebarAtMsgBottom,
this,
(XFE_FunctionNotification)spaceAtMsgEnd_cb);
m_msgview->registerInterest(XFE_MsgView::messageHasChanged,
this,
(XFE_FunctionNotification)newMessageLoading_cb);
getToplevel()->registerInterest(XFE_Frame::allConnectionsCompleteCallback,
this,
(XFE_FunctionNotification)allConnectionsComplete_cb);
if (!p)
setPane(MSG_CreateThreadPane(m_contextData,
XFE_MNView::m_master));
m_msgExpanded = TRUE;
{
Widget scrolled = XtNameToWidget (m_msgview->getBaseWidget(), "*scroller");
int32 message_pane_desired_height;
PREF_GetIntPref(MESSAGEPANE_HEIGHT_PREF, &message_pane_desired_height);
XtVaSetValues(scrolled,
XmNheight, message_pane_desired_height,
NULL);
m_msgview->show();
}
/* safe default, for now. It'll be overriden (if need be), when
a folder is loaded. */
m_displayingDraft = FALSE;
m_commandPending = noPendingCommand;
m_getNewMsg = False;
m_selectionAfterDeleting = MSG_VIEWINDEXNONE;
m_popup = NULL;
m_folderInfo = NULL;
#if defined(USE_ABCOM)
int error =
AB_SetShowPropertySheetForEntryFunc((MSG_Pane *) m_pane,
&XFE_ABListSearchView::ShowPropertySheetForEntryFunc);
#endif /* USE_ABCOM */
setBaseWidget(panedw);
}
XFE_ThreadView::~XFE_ThreadView()
{
D(printf ("In XFE_ThreadView::~XFE_ThreadView()\n");)
/* save off the height of the message pane. */
{
Dimension message_pane_height;
Widget scrolled = XtNameToWidget (m_msgview->getBaseWidget(), "*scroller");
XtVaGetValues(scrolled,
XmNheight, &message_pane_height,
NULL);
PREF_SetIntPref(MESSAGEPANE_HEIGHT_PREF, (int32)message_pane_height);
}
delete m_outliner;
destroyPane();
if (m_popup)
delete m_popup;
// XFE_View destroys m_msgview for us.
}
void XFE_ThreadView::setGetNewMsg(XP_Bool b)
{
m_getNewMsg = b;
}
fe_icon*
XFE_ThreadView::flagToIcon(int folder_flags, int message_flags)
{
if (folder_flags & MSG_FOLDER_FLAG_NEWSGROUP)
return (message_flags & MSG_FLAG_READ ? &newsPostIcon : &newsNewIcon);
else if (folder_flags & MSG_FOLDER_FLAG_DRAFTS)
return &draftIcon;
else if (message_flags & MSG_FLAG_IMAP_DELETED
|| message_flags & MSG_FLAG_EXPUNGED)
return &deletedIcon;
else if (message_flags & MSG_FLAG_ATTACHMENT)
{
return &mailMessageAttachIcon;
}
else if (folder_flags & MSG_FOLDER_FLAG_TEMPLATES)
{
return &templateIcon;
}
else
{
return (message_flags & MSG_FLAG_READ ? &mailMessageReadIcon : &mailMessageUnreadIcon);
}
}
#if defined(USE_MOTIF_DND)
fe_icon_data*
XFE_ThreadView::flagToIconData(int folder_flags, int message_flags)
{
if (folder_flags & MSG_FOLDER_FLAG_NEWSGROUP)
return (message_flags & MSG_FLAG_READ ? &MN_Newspost : &MN_NewsNew);
else if (folder_flags & MSG_FOLDER_FLAG_DRAFTS)
return &MN_Draftfile;
else if (message_flags & MSG_FLAG_IMAP_DELETED
else if (folder_flags & MSG_FOLDER_FLAG_DRAFTS)
|| message_flags & MSG_FLAG_EXPUNGED)
return &MN_Delete;
else
return (message_flags & MSG_FLAG_READ ? &MN_MailRead : &MN_MailUnread);
}
#endif /* USE_MOTIF_DND */
void
XFE_ThreadView::initMessageIcons(Widget widget,
Pixel bg_pixel,
Pixel fg_pixel)
{
static Boolean init_icons_done = False;
if (init_icons_done)
return;
init_icons_done = True;
if (!mailMessageReadIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&mailMessageReadIcon,
NULL,
MN_MailRead.width, MN_MailRead.height,
MN_MailRead.mono_bits, MN_MailRead.color_bits, MN_MailRead.mask_bits, FALSE);
if (!mailMessageUnreadIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&mailMessageUnreadIcon,
NULL,
MN_MailUnread.width, MN_MailUnread.height,
MN_MailUnread.mono_bits, MN_MailUnread.color_bits, MN_MailUnread.mask_bits, FALSE);
if (!draftIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&draftIcon,
NULL,
MN_Draftfile.width, MN_Draftfile.height,
MN_Draftfile.mono_bits, MN_Draftfile.color_bits, MN_Draftfile.mask_bits, FALSE);
if (!templateIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&templateIcon,
NULL,
MN_Templatefile.width, MN_Templatefile.height,
MN_Templatefile.mono_bits, MN_Templatefile.color_bits, MN_Templatefile.mask_bits, FALSE);
if (!newsPostIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&newsPostIcon,
NULL,
MN_Newspost.width, MN_Newspost.height,
MN_Newspost.mono_bits, MN_Newspost.color_bits, MN_Newspost.mask_bits, FALSE);
if (!newsNewIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&newsNewIcon,
NULL,
MN_NewsNew.width, MN_NewsNew.height,
MN_NewsNew.mono_bits, MN_NewsNew.color_bits, MN_NewsNew.mask_bits, FALSE);
if (!msgReadIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&msgReadIcon,
NULL,
MN_DotRead.width, MN_DotRead.height,
MN_DotRead.mono_bits, MN_DotRead.color_bits, MN_DotRead.mask_bits, FALSE);
if (!msgUnreadIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&msgUnreadIcon,
NULL,
MN_Unread.width, MN_Unread.height,
MN_Unread.mono_bits, MN_Unread.color_bits, MN_Unread.mask_bits, FALSE);
if (!msgFlagIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&msgFlagIcon,
NULL,
MN_Flag.width, MN_Flag.height,
MN_Flag.mono_bits, MN_Flag.color_bits, MN_Flag.mask_bits, FALSE);
if (!mailMessageAttachIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&mailMessageAttachIcon,
NULL,
MN_MailAttach.width, MN_MailAttach.height,
MN_MailAttach.mono_bits, MN_MailAttach.color_bits, MN_MailAttach.mask_bits, FALSE);
if (!threadonIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&threadonIcon,
NULL,
threadon.width, threadon.height,
threadon.mono_bits, threadon.color_bits,
threadon.mask_bits, FALSE);
if (!threadoffIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&threadoffIcon,
NULL,
threadoff.width, threadoff.height,
threadoff.mono_bits, threadoff.color_bits,
threadoff.mask_bits, FALSE);
if (!openSpoolIgnoredIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&openSpoolIgnoredIcon,
NULL,
MN_ThreadIgnoreO.width, MN_ThreadIgnoreO.height,
MN_ThreadIgnoreO.mono_bits, MN_ThreadIgnoreO.color_bits,
MN_ThreadIgnoreO.mask_bits, FALSE);
if (!closedSpoolIgnoredIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&closedSpoolIgnoredIcon,
NULL,
MN_ThreadIgnore.width, MN_ThreadIgnore.height,
MN_ThreadIgnore.mono_bits, MN_ThreadIgnore.color_bits,
MN_ThreadIgnore.mask_bits, FALSE);
if (!openSpoolWatchedIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&openSpoolWatchedIcon,
NULL,
MN_ThreadWatchO.width, MN_ThreadWatchO.height,
MN_ThreadWatchO.mono_bits, MN_ThreadWatchO.color_bits,
MN_ThreadWatchO.mask_bits, FALSE);
if (!closedSpoolWatchedIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&closedSpoolWatchedIcon,
NULL,
MN_ThreadWatch.width, MN_ThreadWatch.height,
MN_ThreadWatch.mono_bits, MN_ThreadWatch.color_bits,
MN_ThreadWatch.mask_bits, FALSE);
if (!openSpoolNewIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&openSpoolNewIcon,
NULL,
MN_ThreadNew/*O*/.width, MN_ThreadNew/*O*/.height,
MN_ThreadNew/*O*/.mono_bits, MN_ThreadNew/*O*/.color_bits,
MN_ThreadNew/*O*/.mask_bits, FALSE);
if (!closedSpoolNewIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&closedSpoolNewIcon,
NULL,
MN_ThreadNew.width, MN_ThreadNew.height,
MN_ThreadNew.mono_bits, MN_ThreadNew.color_bits,
MN_ThreadNew.mask_bits, FALSE);
if (!openSpoolIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&openSpoolIcon,
NULL,
MN_ThreadO.width, MN_ThreadO.height,
MN_ThreadO.mono_bits, MN_ThreadO.color_bits,
MN_ThreadO.mask_bits, FALSE);
if (!closedSpoolIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&closedSpoolIcon,
NULL,
MN_Thread.width, MN_Thread.height,
MN_Thread.mono_bits, MN_Thread.color_bits,
MN_Thread.mask_bits, FALSE);
if (!deletedIcon.pixmap)
fe_NewMakeIcon(widget,
fg_pixel,
bg_pixel,
&deletedIcon,
NULL,
MN_Delete.width, MN_Delete.height,
MN_Delete.mono_bits, MN_Delete.color_bits,
MN_Delete.mask_bits, FALSE);
}
#if HANDLE_CMD_QUEUE
/* It looks like a selectInvalid here
*/
void XFE_ThreadView::processCmdQueue()
{
int count =0;
int *Arr = NULL;
if (m_deletedCount && m_deleted) {
count = m_deletedCount;
Arr = m_deleted;
}/* else if */
#if defined(DEBUG_tao)
printf("\n->XFE_ThreadView::processCmdQueue, count=%d", count);
if (count > 1)
XP_ASSERT(0);
#endif
int lastInd = count?Arr[count-1]:-1;
for (int i=count-2; i >= 0; i--)
if (Arr[i] < lastInd)
lastInd--;
int nLines = MSG_GetNumLines(m_pane);
if (lastInd >= nLines)
/* the worst case is -1 ;
* which we do deal with it in paneChanged already!
*/
lastInd = nLines-1;
if (lastInd >= 0 &&
m_lastLoadedInd != MSG_VIEWINDEXNONE)
showMessage(lastInd);
#if defined(DEBUG_tao)
else
printf("\n->XFE_ThreadView::processCmdQueue,m_lastLoadedInd=%d,",
m_lastLoadedInd);
#endif
/* final step
*/
/* reset
*/
XP_FREEIF(m_selected);
m_selectedCount = 0;
XP_FREEIF(m_deleted);
m_deletedCount = 0;
XP_FREEIF(m_collapsed);
m_collapsedCount = 0;
}
#endif /* HANDLE_CMD_QUEUE */
#if defined(DEL_5_0)
void
XFE_ThreadView::listChangeStarting(XP_Bool /* asynchronous */,
MSG_NOTIFY_CODE notify,
MSG_ViewIndex /* where */,
int32 /* num */)
{
#if defined(DEBUG_tao)
int listChangeDepth = m_outliner->getListChangeDepth()-1;
printf("\n>>XFE_ThreadView::listChangeStarting, depth=%d, m_lastLoadedInd=%d",
listChangeDepth, m_lastLoadedInd);
#endif
if (notify == MSG_NotifyScramble ||
notify == MSG_NotifyAll) {
m_lastLoadedInd = MSG_VIEWINDEXNONE;
}/* if */
else if (notify == MSG_NotifyNone) {
}/* MSG_NotifyNone */
}
#endif /* DEL_5_0 */
void
XFE_ThreadView::listChangeFinished(XP_Bool /* asynchronous */,
MSG_NOTIFY_CODE notify,
MSG_ViewIndex where,
int32 num)
{
int listChangeDepth = m_outliner->getListChangeDepth()-1;
#if defined(DEBUG_tao)
printf("\n>>XFE_ThreadView::listChangeFinished, depth=%d, m_lastLoadedInd=%d",
listChangeDepth, m_lastLoadedInd);
#endif
if (notify == MSG_NotifyNone &&
where == 0 &&
num == 0 &&
listChangeDepth == 0 &&
m_deletedCount &&
m_deleted) {
processCmdQueue();
}/* */
else if (notify == MSG_NotifyScramble ||
notify == MSG_NotifyAll) {
m_lastLoadedInd = MSG_GetMessageIndexForKey(m_pane,
m_lastLoadedKey,
False);
}/* if */
else if (notify == MSG_NotifyChanged) {
m_lineChanged = where;
/* when a msg header info changed on certain row,
backend will use this notification to warn fe.
we are suppose to re-acquire line m_messageLine info
from the backend and invalidate this row on display only
*/
acquireLineData((int)m_lineChanged);
return;
}/* if */
else if (notify == MSG_NotifyInsertOrDelete &&
m_lastLoadedInd != MSG_VIEWINDEXNONE) {
/* there was a msg loaded
*/
if (num < 0) {
/* 1. collapsing ??
*/
if ((m_lineChanged != MSG_VIEWINDEXNONE) &&
(m_lineChanged == (where -1)) && /* essential */
(listChangeDepth == 0)) { /* must be collapsing */
/* collapsed
*/
if ((m_lastLoadedInd >= where) &&
(m_lastLoadedInd < (where-num))) {
/* one of the "reply" is being hidden
* selection would go to thread leader;
* thus needs reload right away
*/
/* load the thread leader: where -1*/
if (!m_deletedCount && !m_deleted) {
m_deleted = (int *) XP_CALLOC(1, sizeof(int));
m_deleted[m_deletedCount++] = where-1;
processCmdQueue();
}/* if */
#if 0
else
XP_ASSERT(0);
#endif
}/* if collapsed */
else {
#if defined(DEBUG_tao)
printf("\n***XFE_ThreadView::listChangeFinished, collapsing not selected\n");
#endif /* DEBUG_tao */
m_lastLoadedInd += num; /* re-adjust */
}/* else */
}/* collapsed */
else if (where == m_lastLoadedInd) {
/* the selected one is gone
*/
if (!m_deletedCount && !m_deleted) {
m_deleted = (int *) XP_CALLOC(1, sizeof(int));
m_deleted[m_deletedCount++] = where;
if (listChangeDepth == 0) // non-nested
#if 1
processCmdQueue();
#endif
}/* if */
#if 0
else
XP_ASSERT(0);
#endif
}/* where == m_lastLoadedInd */
else if (where <= m_lastLoadedInd)
m_lastLoadedInd += num; /* re-adjust */
}/* num < 0 */
else if (num == 0) {
/* SPECIAL case: the header got deleted
*/
/* we do not care deletion on non-focusing line
*/
if (m_lastLoadedInd == where) {
/* deleted
*/
if (!m_deletedCount && !m_deleted) {
m_deleted = (int *) XP_CALLOC(1, sizeof(int));
m_deleted[m_deletedCount++] = where;
processCmdQueue();
}/* if */
#if 0
else
XP_ASSERT(0);
#endif
#if defined(DEBUG_tao)
printf("\n**>SPECIAL case:listChangeFinished=%d, m_deletedCount=%d\n",
where, m_deletedCount);
#endif
}/* m_lastLoadedInd == where */
}/* if num == 0 */
else if (num > 0 && where <= m_lastLoadedInd)
m_lastLoadedInd += num; /* re-adjust */
}/* notify == MSG_NotifyInsertOrDelete */
#if defined(DEBUG_tao)
printf("\n<<XFE_ThreadView::listChangeFinished, m_lastLoadedInd=%d",
m_lastLoadedInd);
#endif
m_lineChanged = MSG_VIEWINDEXNONE;
}/* XFE_ThreadView::listChangeFinished() */
void
XFE_ThreadView::paneChanged(XP_Bool asynchronous,
MSG_PANE_CHANGED_NOTIFY_CODE code,
int32 value)
{
#if defined(DEBUG_tao)
printf("\n XFE_ThreadView::paneChanged, pane=0x%x, asynchronous=%d, code=%d, value=%d",
m_pane, asynchronous, code, value);
#endif
switch (code)
{
case MSG_PaneNotifyFolderDeleted:
{
/* bug 95564: check folderInfo before closing
*/
MSG_FolderInfo *deleted = (MSG_FolderInfo *) value;
DD(printf("Blank out message view...\n");)
#if defined(USE_3PANE)
if (m_folderInfo == deleted) {
/* clear msgPane
*/
m_msgview->loadMessage(deleted, MSG_MESSAGEKEYNONE );
showMessage(-1);
m_outliner->change(0,0,0);
}/* if m_folderInfo == deleted */
#else
m_msgview->loadMessage(deleted, MSG_MESSAGEKEYNONE );
if (m_folderInfo == deleted) {
/* test frame type
*/
XFE_Frame *frame = (XFE_Frame*)m_toplevel;
if (frame &&
FRAME_MAILNEWS_THREAD == frame->getType()) {
/* standalone frame
*/
if (!m_frameDeleted) {
frame->delete_response();
m_frameDeleted = True;
}/* if */
}/* if */
}/* if m_folderInfo == deleted */
#endif /* USE_3PANE */
#if defined(DEBUG_tao)
else
printf("\n---Wrong folder IGNORing MSG_PaneNotifyFolderDeleted\n");
#endif
}
/* shall we update banner or simply return?
*/
return;
case MSG_PaneNotifyCopyFinished:
#if defined(DEBUG_tao)
printf("\n++XFE_ThreadView, MSG_PaneNotifyCopyFinished++\n");
/* It happens in loading mails.
* XP_ASSERT(0);
*/
#endif
break;
case MSG_PaneNotifyMessageLoaded:
#if defined(DEBUG_tao)
printf("\n++XFE_ThreadView, MSG_PaneNotifyMessageLoaded++\n");
XP_ASSERT(0);
#endif
break;
case MSG_PaneNotifyLastMessageDeleted:
/* clear msgPane
*/
showMessage(-1);
break;
case MSG_PaneNotifyMessageDeleted:
{
// If we delete a message from the threadview, and
// there's currently a message view showing that message,
// we need to tell the msg view so it can pop down:
XFE_MozillaApp::theApp()->notifyInterested(msgWasDeleted, (void*)value);
#if HANDLE_CMD_QUEUE
#if defined(DEBUG_tao)
MessageKey id = (MessageKey) value;
MSG_ViewIndex index = MSG_GetMessageIndexForKey(m_pane,
id,
False);
printf("\n MSG_PaneNotifyMessageDeleted,index=%d", index);
#endif
#endif /* HANDLE_CMD_QUEUE */
}
break;
case MSG_PaneNotifyFolderLoadedSync:
case MSG_PaneNotifyFolderLoaded:
{
D(printf ("Inside pane changed -- folder loaded\n");)
#if defined(DEBUG_tao)
if (code == MSG_PaneNotifyFolderLoadedSync)
printf("\n**XFE_ThreadView::paneChanged: code == MSG_PaneNotifyFolderLoadedSync \n");
#endif
if (m_nLoadingFolders > 0) {
/* release the block
*/
m_outliner->setBlockSel(False);
m_nLoadingFolders--;
}/* if */
/* Call this after folder is loaded
*/
if ((code == MSG_PaneNotifyFolderLoaded) &&
m_getNewMsg) {
/* Do it for movemail/pop3 only
*/
if (fe_globalPrefs.mail_server_type != MAIL_SERVER_IMAP)
getNewMail();
/* reset
*/
m_getNewMsg = False;
}/* if */
/* select first msg
*/
if (m_commandPending == noPendingCommand
&& m_outliner->getTotalLines() > 0)
{
m_commandPending = selectByIndex;
m_pendingSelectionIndex = 0;
/* when a msg being loaded after folder loaded, we should change
focus of the three pane UI to thread view bug #109659
*/
getToplevel()->notifyInterested(XFE_MNListView::changeFocus, (void*) this);
/* end of #109659 */
}
/* we only actually handle the command here
* if the folder was loaded synchronously.
*/
if (code == MSG_PaneNotifyFolderLoadedSync)
handlePendingCommand();
XFE_MozillaApp::theApp()->notifyInterested(XFE_MNView::MNChromeNeedsUpdating);
notifyInterested(XFE_MNView::bannerNeedsUpdating, (void*)code);
XP_Bool invalidate_needed = False;
if (MSG_GetToggleStatus(m_pane, MSG_SortByThread, NULL, 0) == MSG_Checked)
{
invalidate_needed = m_outliner->getDescendantSelectAllowed() == False;
m_outliner->setDescendantSelectAllowed( True );
m_outliner->setSortColumn(-1, OUTLINER_SortAscending);
}
else
{
invalidate_needed = m_outliner->getDescendantSelectAllowed() == True;
m_outliner->setDescendantSelectAllowed( False );
}
if (invalidate_needed)
m_outliner->invalidate();
}
break;
default:
break;
}
// This can result in flickering of the banner, but if we don't call it,
// the number of unread and total messages isn't updated correctly
XFE_MNListView::paneChanged(asynchronous, code, value);
}
void
XFE_ThreadView::loadFolder(MSG_FolderInfo *folderInfo)
{
MSG_FolderLine folderLine;
char *newsgroup_format = XP_GetString(XFE_WINDOW_TITLE_NEWSGROUP);
char *folder_format = XP_GetString(XFE_WINDOW_TITLE_FOLDER);
char *window_title;
int window_title_length;
// must be valid.
XP_ASSERT(folderInfo);
if (!folderInfo) return;
// only need to do everything below here if the folder being
// loaded is different than what's currently displayed.
if (m_folderInfo != folderInfo) {
// clear the currently display message, since we're in a different folder now.
DD(printf("Load Folder: Blank out message view...\n");)
m_msgview->loadMessage(folderInfo, MSG_MESSAGEKEYNONE );
updateExpandoFlippyText(-1);
m_outliner->deselectAllItems();
MSG_GetFolderLineById(XFE_MNView::getMaster(), folderInfo, &folderLine);
#if defined(USE_MOTIF_DND)
m_outliner->enableDragDrop(this,
NULL, /* no dropping -- of anything but outliner columns. */
XFE_ThreadView::getDragTargets,
XFE_ThreadView::getDragIconData,
XFE_ThreadView::dragConvert);
#endif /* USE_MOTIF_DND */
if (folderLine.flags & MSG_FOLDER_FLAG_NEWSGROUP)
{
// it's a newsgroup
window_title_length = strlen(newsgroup_format) - 2 /* %s */ + strlen(folderLine.name) + 1;
window_title = (char*)XP_CALLOC(sizeof(char), window_title_length);
sprintf (window_title, newsgroup_format, folderLine.name);
m_displayingNewsgroup = TRUE;
m_displayingDraft = FALSE;
#if !defined(USE_MOTIF_DND)
m_outliner->setDragType( FE_DND_NEWS_MESSAGE, &newsPostIcon,
this, (fe_dnd_SourceDropFunc)&XFE_ThreadView::source_drop_func);
#endif /* USE_MOTIF_DND */
}
else
{
window_title_length = strlen(folder_format) - 2 /* %s */ + strlen(folderLine.name) + 1;
window_title = (char*)XP_CALLOC(sizeof(char), window_title_length);
sprintf (window_title, folder_format, folderLine.name);
if (folderLine.flags & MSG_FOLDER_FLAG_DRAFTS)
{
// it's the draft folder
m_displayingDraft = TRUE;
m_displayingNewsgroup = FALSE;
#if !defined(USE_MOTIF_DND)
m_outliner->setDragType(FE_DND_MAIL_MESSAGE, &mailMessageUnreadIcon,
this,
(fe_dnd_SourceDropFunc)&XFE_ThreadView::source_drop_func);
#endif /* USE_MOTIF_DND */
}
else
{
// it's a normal mail folder
m_displayingNewsgroup = FALSE;
m_displayingDraft = FALSE;
#if !defined(USE_MOTIF_DND)
m_outliner->setDragType(FE_DND_MAIL_MESSAGE, &mailMessageUnreadIcon,
this,
(fe_dnd_SourceDropFunc)&XFE_ThreadView::source_drop_func);
#endif /* USE_MOTIF_DND */
}
}
// getContainer()->setTitle(window_title);
XP_FREE(window_title);
D(printf("Loading folder into ThreadView\n");)
/* if it doesn't have categories, we can load it directly
into the threadview's pane. */
m_folderInfo = folderInfo;
/* keep track of on loading folders
*/
if (m_nLoadingFolders == 0) {
m_nLoadingFolders++; // FYI
/* block selection
*/
m_outliner->setBlockSel(True);
}/* if */
else
XP_ASSERT(0);
MSG_LoadFolder(m_pane, m_folderInfo);
XFE_MozillaApp::theApp()->notifyInterested(XFE_MNView::MNChromeNeedsUpdating);
/* either open or close the message view, depending on the folder prefs */
{
int32 new_folder_prefs = MSG_GetFolderPrefFlags(m_folderInfo);
if (new_folder_prefs & MSG_FOLDER_PREF_FEVALID)
{
if (new_folder_prefs & MSG_FOLDER_PREF_ONEPANE)
{
if (m_msgview->isShown())
{
toggleMsgExpansion();
}
}
else
{
if (!m_msgview->isShown())
{
toggleMsgExpansion();
}
}
}
}
}/* if diff folder */
else /* if the same loaded folder, we need to invoke handlePendingCommand */
handlePendingCommand();
}
MSG_FolderInfo *
XFE_ThreadView::getFolderInfo()
{
return m_folderInfo;
}
void
XFE_ThreadView::updateExpandoFlippyText(int row)
{
char *subjectStr;
XmString subject;
XmString oldsubject = 0;
char *oldsubjectStr = NULL;
XP_Bool needsChange = TRUE;
#if defined(DEBUG_tao)
printf("\nXFE_ThreadView::updateExpandoFlippyText(row=%d)\n",row);
#endif
if (row == -1)
{
subjectStr = "";
}
else
{
acquireLineData(row);
subjectStr = getColumnText(OUTLINER_COLUMN_SUBJECT);
}
XtVaGetValues (m_arrowlabel,
XmNlabelString, &oldsubject,
NULL);
if (XmStringGetLtoR(oldsubject, XmFONTLIST_DEFAULT_TAG, &oldsubjectStr))
if (oldsubjectStr && !strcmp(oldsubjectStr, subjectStr))
{
needsChange = FALSE;
if (oldsubjectStr) XtFree(oldsubjectStr);
}
if (needsChange)
{
subject = XmStringCreate (subjectStr, XmFONTLIST_DEFAULT_TAG);
XtVaSetValues (m_arrowlabel,
XmNlabelString, subject,
NULL);
XmStringFree (subject);
}
XmStringFree (oldsubject);
XFlush(XtDisplay(m_arrowlabel));
}
//
// show a message at a particular row in the thread's outliner.
// sending -1 to this function will clear the label and the message
// area.
//
void
XFE_ThreadView::showMessage(int row)
{
/* sometimes this can get called before we've loaded a folder. */
if (!m_folderInfo)
return;
if (row > -1) {
m_lastLoadedInd = (MSG_ViewIndex) row;
m_lastLoadedKey = MSG_GetMessageKey(m_pane, row);
#if defined(DEBUG_tao)
printf("\nXFE_ThreadView::showMessage m_lastLoadedInd=%d\n",
m_lastLoadedInd);
#endif
}/* if */
/*
** if the message area is expanded we just load the message, since
** we will turn around and call the makeVisible/selectItemExclusive/etc
** in our newMessageLoading method.
** If the message area isn't expanded, we handle it here.
*/
if (m_msgExpanded)
{
MSG_ViewIndex index;
MessageKey key;
MSG_FolderInfo *info = NULL;
MSG_GetCurMessage(m_msgview->getPane(), &info, &key, &index);
if (key != m_lastLoadedKey) {
m_msgview->loadMessage(m_folderInfo,
(row == -1 ?
MSG_MESSAGEKEYNONE :
MSG_GetMessageKey(m_pane, row)));
}/* if */
}
else
{
if (row != -1)
{
m_outliner->makeVisible(row);
m_outliner->selectItemExclusive(row);
}
}
updateExpandoFlippyText(row);
}
char *
XFE_ThreadView::commandToString(CommandType cmd, void * calldata, XFE_CommandInfo* info)
{
#define IS_CMD(command) cmd == (command)
if (IS_CMD(xfeCmdToggleMessageExpansion))
{
if (m_msgview->isShown())
return stringFromResource("hideMsgAreaCmdString");
else
return stringFromResource("showMsgAreaCmdString");
}
else if (IS_CMD(xfeCmdDeleteAny) || IS_CMD(xfeCmdDeleteMessage) || IS_CMD(xfeCmdCancelMessages)) {
if (isDisplayingNews())
return XP_GetString(MK_MSG_CANCEL_MESSAGE);
else
return XP_GetString(MK_MSG_DELETE_SEL_MSGS);
}
else if ( calldata &&
(IS_CMD(xfeCmdReplyToSender)
|| IS_CMD(xfeCmdReplyToAll)
|| IS_CMD(xfeCmdReplyToNewsgroup)
|| IS_CMD(xfeCmdReplyToSenderAndNewsgroup) ) )
{
// if calldata is non-null for a Reply button,
// that's a signal not to change the
// widget name in the resources file:
return 0;
}
else
return XFE_MNListView::commandToString(cmd, calldata, info);
#undef IS_CMD
}
Boolean
XFE_ThreadView::isCommandSelected(CommandType cmd, void *calldata, XFE_CommandInfo*)
{
#define IS_CMD(command) cmd == (command)
if (IS_CMD(xfeCmdShowAllHeaders)
|| IS_CMD(xfeCmdShowNormalHeaders)
|| IS_CMD(xfeCmdShowBriefHeaders)
|| IS_CMD(xfeCmdWrapLongLines)
|| IS_CMD(xfeCmdViewAttachmentsInline)
|| IS_CMD(xfeCmdEditMessage)
|| IS_CMD(xfeCmdOpenSelected)
|| IS_CMD(xfeCmdUpdateMessageCount)
|| IS_CMD(xfeCmdViewAttachmentsAsLinks))
{
return m_msgExpanded && m_msgview->isCommandSelected(cmd);
}
else if (IS_CMD(xfeCmdPrintSetup)
|| IS_CMD(xfeCmdPrintPreview))
return True;
else if (IS_CMD(xfeCmdSortAscending))
{
return ( MSG_GetToggleStatus( m_pane, MSG_SortBackward, NULL, 0 )
!= MSG_Checked );
}
else if (IS_CMD(xfeCmdSortDescending))
{
return ( MSG_GetToggleStatus( m_pane, MSG_SortBackward, NULL, 0 )
== MSG_Checked );
}
else
return XFE_MNListView::isCommandSelected(cmd, calldata);
#undef IS_CMD
}
Boolean
XFE_ThreadView::isCommandEnabled(CommandType cmd, void *calldata, XFE_CommandInfo* info)
{
#define IS_CMD(command) cmd == (command)
if (IS_CMD(xfeCmdDeleteAny)|| IS_CMD(xfeCmdDeleteMessage)) {
/* 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).
*/
int32 resultsize = MSG_GetFoldersWithFlag(XFE_MNView::getMaster(),
MSG_FOLDER_FLAG_TRASH,
NULL,
0);
if (resultsize == 0)
return False;
}/* IS_CMD(xfeCmdDeleteMessage */
const int *selected;
int count;
m_outliner->getSelection(&selected, &count);
#if defined(USE_ABCOM)
if ((IS_CMD(xfeCmdAddSenderToAddressBook)||
IS_CMD(xfeCmdAddAllToAddressBook)) &&
count > 0) {
XP_List *abList = AB_AcquireAddressBookContainers(m_contextData);
XP_ASSERT(abList);
int nDirs = XP_ListCount(abList);
XP_Bool selectable = False;
if (!nDirs)
return selectable;
/* XFE always returns the first one
*/
AB_ContainerInfo *destAB =
(AB_ContainerInfo *) XP_ListGetObjectNum(abList,1);
XP_ASSERT(destAB);
int error = MSG_AddToAddressBookStatus(m_pane,
commandToMsgCmd(cmd),
(MSG_ViewIndex*)selected,
count,
&selectable, NULL, NULL, NULL,
destAB);
error = AB_ReleaseContainersList(abList);
return selectable;
}/* if */
#endif /* USE_ABCOM */
// DeleteMessage stands for CancelMessage in the ThreadView,
// so intercept it early:
if ( (IS_CMD(xfeCmdDeleteAny) ||
IS_CMD(xfeCmdDeleteMessage) || IS_CMD(xfeCmdCancelMessages))
&& isDisplayingNews() )
{
XP_Bool selectable = False;
MSG_CommandStatus(m_pane, MSG_CancelMessage,
/* just need some integer pointer here...*/
(MSG_ViewIndex*)selected, count,
&selectable, NULL, NULL, NULL);
return selectable;
}
// Check if selectThread should be enabled or not...
if ( IS_CMD(xfeCmdSelectThread))
{
Boolean status =
MSG_GetToggleStatus(m_pane, MSG_SortByThread, NULL, 0)==MSG_Checked;
return ((count > 0) && status);
}
if ( !m_displayingNewsgroup && IS_CMD(xfeCmdEditConfiguration) )
{
// Manage Mail Account
return True;
}
if ( m_displayingNewsgroup && IS_CMD(xfeCmdModerateDiscussion) )
{
// Moderate Newsgroup Discussion
return True;
}
if (IS_CMD(xfeCmdUndo)
|| IS_CMD(xfeCmdRedo)) {
XP_Bool selectable = False;
MSG_CommandType msg_cmd = commandToMsgCmd(cmd);
MSG_CommandStatus(m_pane, msg_cmd,
/* just need some integer pointer here...*/
(MSG_ViewIndex*)selected, count,
&selectable, NULL, NULL, NULL);
#if defined(DEBUG_tao_)
if (IS_CMD(xfeCmdUndo))
printf("\n XFE_ThreadView, MSG_CommandStatus:: m_pane=%x, xfeCmdUndo=%d", m_pane, selectable);
else if (IS_CMD(xfeCmdRedo))
printf("\n XFE_ThreadView, MSG_CommandStatus:: m_pane=%x, xfeCmdRedo=%d", m_pane, selectable);
#endif
return selectable;
}
MSG_MotionType nav_cmd;
nav_cmd = commandToMsgNav(cmd);
if ((nav_cmd != (MSG_MotionType)~0)&&
(!(IS_CMD(xfeCmdBack)||IS_CMD(xfeCmdForward))))
{
XP_Bool selectable = FALSE;
if (count == 1)
MSG_NavigateStatus(m_pane, nav_cmd, selected[0],
&selectable, NULL);
return selectable;
}
else if (IS_CMD(xfeCmdToggleMessageExpansion))
{
return True;
}
else if (IS_CMD(xfeCmdGetNextNNewMsgs))
{
return m_displayingNewsgroup;
}
else if (IS_CMD(xfeCmdEditPreferences))
{
return True;
}
// Always available even if nothing is selected:
else if (IS_CMD(xfeCmdComposeArticle)
|| IS_CMD(xfeCmdComposeArticleHTML)
|| IS_CMD(xfeCmdComposeArticlePlain)
|| IS_CMD(xfeCmdPrintSetup)
|| IS_CMD(xfeCmdPrintPreview)
|| IS_CMD(xfeCmdUpdateMessageCount))
{
return True;
}
// the move and copy commands are available if there are messages selected.
else if (IS_CMD(xfeCmdMoveMessage)
|| IS_CMD(xfeCmdCopyMessage)
|| IS_CMD(xfeCmdSetPriorityHighest)
|| IS_CMD(xfeCmdSetPriorityHigh)
|| IS_CMD(xfeCmdSetPriorityNormal)
|| IS_CMD(xfeCmdSetPriorityLow)
|| IS_CMD(xfeCmdSetPriorityLowest)
|| IS_CMD(xfeCmdSetPriorityNone)
|| IS_CMD(xfeCmdEditMessage)
|| IS_CMD(xfeCmdOpenSelected))
{
return (count > 0);
}
// the sort commands are always available, if there are messages
else if (IS_CMD(xfeCmdSortBySender)
|| IS_CMD(xfeCmdSortByDate)
|| IS_CMD(xfeCmdSortBySubject)
|| IS_CMD(xfeCmdSortByPriority)
|| IS_CMD(xfeCmdSortByThread)
|| IS_CMD(xfeCmdSortByMessageNumber)
|| IS_CMD(xfeCmdSortBySize)
|| IS_CMD(xfeCmdSortByFlag)
|| IS_CMD(xfeCmdSortByStatus)
|| IS_CMD(xfeCmdSortByUnread)
|| IS_CMD(xfeCmdSortAscending)
|| IS_CMD(xfeCmdSortDescending)
|| IS_CMD(xfeCmdMarkMessageByDate))
{
return MSG_GetNumLines(m_pane) > 0;
}
// commands that work on the msgview.
else if (IS_CMD(xfeCmdShowAllHeaders)
|| IS_CMD(xfeCmdPrint)
|| IS_CMD(xfeCmdShowNormalHeaders)
|| IS_CMD(xfeCmdShowBriefHeaders)
|| IS_CMD(xfeCmdWrapLongLines)
|| IS_CMD(xfeCmdViewAttachmentsInline)
|| IS_CMD(xfeCmdViewAttachmentsAsLinks)
|| IS_CMD(xfeCmdViewPageSource)
|| IS_CMD(xfeCmdFindInObject)
|| IS_CMD(xfeCmdFindAgain))
{
return m_msgExpanded && m_msgview->isCommandEnabled(cmd);
}
else if (IS_CMD(xfeCmdSearch))
{
return !XP_IsContextBusy(m_contextData);
}
else if (IS_CMD(xfeCmdExpand)
|| IS_CMD(xfeCmdExpandAll)
|| IS_CMD(xfeCmdCollapse)
|| IS_CMD(xfeCmdCollapseAll))
return True;
else
{
return XFE_MNListView::isCommandEnabled(cmd, calldata, info);
}
#undef IS_CMD
}
Boolean
XFE_ThreadView::handlesCommand(CommandType cmd, void *calldata, XFE_CommandInfo*)
{
#define IS_CMD(command) cmd == (command)
if (IS_CMD(xfeCmdToggleMessageExpansion)
|| IS_CMD(xfeCmdGetNewMessages)
|| IS_CMD(xfeCmdGetNextNNewMsgs)
|| IS_CMD(xfeCmdAddSenderToAddressBook)
|| IS_CMD(xfeCmdAddAllToAddressBook)
|| IS_CMD(xfeCmdEditMessage)
|| IS_CMD(xfeCmdSendMessagesInOutbox)
|| IS_CMD(xfeCmdPrint)
|| IS_CMD(xfeCmdSaveAs)
|| IS_CMD(xfeCmdReplyToSender)
|| IS_CMD(xfeCmdReplyToSenderAndNewsgroup)
|| IS_CMD(xfeCmdReplyToAll)
|| IS_CMD(xfeCmdForwardMessage)
|| IS_CMD(xfeCmdForwardMessageQuoted)
|| IS_CMD(xfeCmdForwardMessageInLine)
|| IS_CMD(xfeCmdNextMessage)
|| IS_CMD(xfeCmdNextUnreadMessage)
|| IS_CMD(xfeCmdPreviousMessage)
|| IS_CMD(xfeCmdPreviousUnreadMessage)
|| IS_CMD(xfeCmdDeleteAny)
|| IS_CMD(xfeCmdDeleteMessage)
|| IS_CMD(xfeCmdSortBySender)
|| IS_CMD(xfeCmdSortByDate)
|| IS_CMD(xfeCmdSortBySubject)
|| IS_CMD(xfeCmdSortByPriority)
|| IS_CMD(xfeCmdSortByThread)
|| IS_CMD(xfeCmdSortByMessageNumber)
|| IS_CMD(xfeCmdSortBySize)
|| IS_CMD(xfeCmdSortByFlag)
|| IS_CMD(xfeCmdSortByStatus)
|| IS_CMD(xfeCmdSortByUnread)
|| IS_CMD(xfeCmdSortAscending)
|| IS_CMD(xfeCmdSortDescending)
|| IS_CMD(xfeCmdViewNew)
|| IS_CMD(xfeCmdViewAllThreads)
|| IS_CMD(xfeCmdViewThreadsWithNew)
|| IS_CMD(xfeCmdViewWatchedThreadsWithNew)
|| IS_CMD(xfeCmdShowAllHeaders)
|| IS_CMD(xfeCmdShowNormalHeaders)
|| IS_CMD(xfeCmdShowBriefHeaders)
|| IS_CMD(xfeCmdViewAttachmentsInline)
|| IS_CMD(xfeCmdViewAttachmentsAsLinks)
|| IS_CMD(xfeCmdRot13Message)
|| IS_CMD(xfeCmdMarkMessageRead)
|| IS_CMD(xfeCmdMarkMessageUnread)
|| IS_CMD(xfeCmdMarkMessageByDate)
|| IS_CMD(xfeCmdMarkThreadRead)
|| IS_CMD(xfeCmdMarkAllMessagesRead)
|| IS_CMD(xfeCmdMarkMessage)
|| IS_CMD(xfeCmdUnmarkMessage)
|| IS_CMD(xfeCmdToggleThreadKilled)
|| IS_CMD(xfeCmdToggleThreadWatched)
|| IS_CMD(xfeCmdRenameFolder)
|| IS_CMD(xfeCmdSearch)
|| IS_CMD(xfeCmdSearchAddress)
|| IS_CMD(xfeCmdEditPreferences)
|| IS_CMD(xfeCmdWrapLongLines)
/* priorities. */
|| IS_CMD(xfeCmdSetPriorityHighest)
|| IS_CMD(xfeCmdSetPriorityHigh)
|| IS_CMD(xfeCmdSetPriorityNormal)
|| IS_CMD(xfeCmdSetPriorityLow)
|| IS_CMD(xfeCmdSetPriorityLowest)
|| IS_CMD(xfeCmdSetPriorityNone)
/* we handle these command to place more constraints on it being sensitive. */
|| IS_CMD(xfeCmdViewPageSource)
|| IS_CMD(xfeCmdFindInObject)
|| IS_CMD(xfeCmdFindAgain)
|| IS_CMD(xfeCmdShowPopup)
|| IS_CMD(xfeCmdModerateDiscussion)
|| IS_CMD(xfeCmdEditMessage)
|| IS_CMD(xfeCmdOpenSelected)
|| IS_CMD(xfeCmdUpdateMessageCount)
|| IS_CMD(xfeCmdNewFolder)
|| IS_CMD(xfeCmdCompressAllFolders)
|| IS_CMD(xfeCmdCompressFolders)
|| IS_CMD(xfeCmdAddNewsgroup)
|| IS_CMD(xfeCmdPrintSetup)
|| IS_CMD(xfeCmdPrintPreview)
|| IS_CMD(xfeCmdExpand)
|| IS_CMD(xfeCmdExpandAll)
|| IS_CMD(xfeCmdCollapse)
|| IS_CMD(xfeCmdCollapseAll)
|| IS_CMD(xfeCmdToggleKilledThreads)
|| IS_CMD(xfeCmdSelectThread)
|| IS_CMD(xfeCmdEditConfiguration)
|| IS_CMD(xfeCmdModerateDiscussion)
|| IS_CMD(xfeCmdMommy))
{
return TRUE;
}
else
{
return XFE_MNListView::handlesCommand(cmd, calldata);
}
#undef IS_CMD
}
void
XFE_ThreadView::addCollapsed(int where)
{
if (m_collapsedCount && m_collapsed)
m_collapsed = (int *) XP_REALLOC(m_collapsed,
(m_collapsedCount+1)*sizeof(int));
else
m_collapsed = (int *) XP_CALLOC(1, sizeof(int));
m_collapsed[m_collapsedCount++] = where+1;
#if defined(DEBUG_tao)
printf("\n-->addCollapsed=%d, m_collapsedCount=%d\n",
where+1, m_collapsedCount);
#endif
}
XP_Bool
XFE_ThreadView::isCollapsed(int where)
{
if (!m_collapsedCount || !m_collapsed)
return False;
for (int i=0; i < m_collapsedCount; i++)
if (m_collapsed[i] == where) {
/* clear it
* thread children's pos > 0
*/
m_collapsed[i] = 0-where;
return True;
}/* for i */
return False;
}
void
XFE_ThreadView::doCommand(CommandType cmd,
void *calldata, XFE_CommandInfo* info)
{
#define IS_CMD(command) cmd == (command)
const int *selected;
int count;
m_outliner->getSelection(&selected, &count);
if (IS_CMD(xfeCmdToggleMessageExpansion))
{
toggleMsgExpansion();
getToplevel()->notifyInterested(XFE_View::chromeNeedsUpdating);
}
#if defined(USE_ABCOM)
else if ((IS_CMD(xfeCmdAddSenderToAddressBook)||
IS_CMD(xfeCmdAddAllToAddressBook)) &&
count > 0) {
XP_List *abList = AB_AcquireAddressBookContainers(m_contextData);
XP_ASSERT(abList);
int nDirs = XP_ListCount(abList);
if (nDirs) {
/* XFE always returns the first one
*/
AB_ContainerInfo *destAB =
(AB_ContainerInfo *) XP_ListGetObjectNum(abList,1);
XP_ASSERT(destAB);
int error = MSG_AddToAddressBook(m_pane,
commandToMsgCmd(cmd),
(MSG_ViewIndex*)selected,
count,
destAB);
error = AB_ReleaseContainersList(abList);
}/* if */
}/* if */
#endif /* USE_ABCOM */
else if (IS_CMD(xfeCmdMommy))
{
fe_showFoldersWithSelected(XtParent(getToplevel()->getBaseWidget()),
/* Tao: we might need to check if this returns a
* non-NULL frame
*/
ViewGlue_getFrame(m_contextData),
NULL,
m_folderInfo);
}
else if (IS_CMD(xfeCmdShowPopup))
{
XEvent *event = info->event;
int x, y, clickrow;
Widget w = XtWindowToWidget(event->xany.display, event->xany.window);
if (m_popup)
delete m_popup;
if (w == NULL) w = m_widget;
/* Need to make the view that has the pop up the current focus so that menu items
can be enabled on the context menu again */
getToplevel()->notifyInterested(XFE_MNListView::changeFocus, (void*) this);
m_popup = new XFE_PopupMenu("popup",(XFE_Frame*)m_toplevel, // XXXXXXX
XfeAncestorFindApplicationShell(w));
if (m_displayingNewsgroup)
m_popup->addMenuSpec(news_popup_spec);
else
m_popup->addMenuSpec(mail_popup_spec);
m_outliner->translateFromRootCoords(event->xbutton.x_root,
event->xbutton.y_root,
&x, &y);
clickrow = m_outliner->XYToRow(x, y);
if (clickrow != -1) /* if it was actually in the outliner's content rows. */
{
if (! m_outliner->isSelected(clickrow))
{
m_outliner->selectItemExclusive(clickrow);
showMessage(clickrow);
}
}
m_popup->position(event);
m_popup->show();
}
else if (IS_CMD(xfeCmdGetNewMessages))
{
getNewMail();
}
else if (IS_CMD(xfeCmdAddNewsgroup))
{
// Code pasted from FolderView.cpp
D( printf ("MSG_FolderPane::addNewsgroup()\n");)
/* We can use folder info in ThreadView to get to Host */
MSG_Host *host = NULL;
host = MSG_GetHostForFolder(m_folderInfo);
fe_showSubscribeDialog(getToplevel(), getToplevel()->getBaseWidget(), m_contextData, host);
}
else if (IS_CMD(xfeCmdGetNextNNewMsgs))
{
getNewNews();
}
else if (IS_CMD(xfeCmdMarkMessageByDate))
{
markReadByDate();
}
else if (IS_CMD(xfeCmdEditPreferences))
{
fe_showMailNewsPreferences(getToplevel(), m_contextData);
}
else if (IS_CMD(xfeCmdShowAllHeaders)
|| IS_CMD(xfeCmdPrint)
|| IS_CMD(xfeCmdShowNormalHeaders)
|| IS_CMD(xfeCmdShowBriefHeaders)
|| IS_CMD(xfeCmdWrapLongLines)
|| IS_CMD(xfeCmdViewAttachmentsInline)
|| IS_CMD(xfeCmdViewAttachmentsAsLinks)
/* pass to msgview
*/
|| IS_CMD(xfeCmdBack)
|| IS_CMD(xfeCmdForward))
{
m_msgview->doCommand(cmd);
}
else if (IS_CMD(xfeCmdSetPriorityHighest)
|| IS_CMD(xfeCmdSetPriorityHigh)
|| IS_CMD(xfeCmdSetPriorityNormal)
|| IS_CMD(xfeCmdSetPriorityLow)
|| IS_CMD(xfeCmdSetPriorityLowest)
|| IS_CMD(xfeCmdSetPriorityNone))
{
MSG_PRIORITY priority = commandToPriority(cmd);
MessageKey key;
int i;
for (i = 0; i < count; i ++)
{
key = MSG_GetMessageKey(m_pane, (MSG_ViewIndex)selected[i]);
MSG_SetPriority(m_pane, key, priority);
}
}
else if (IS_CMD(xfeCmdMoveMessage))
{
MSG_FolderInfo *info = (MSG_FolderInfo*)calldata;
if (info)
{
MSG_FolderLine folderLine;
MSG_GetFolderLineById(XFE_MNView::getMaster(), info, &folderLine);
if ( folderLine.flags & MSG_FOLDER_FLAG_NEWSGROUP)
{
MSG_CopyMessagesIntoFolder(m_pane, (MSG_ViewIndex*)selected, count, info);
}
else
{
MSG_MoveMessagesIntoFolder(m_pane, (MSG_ViewIndex*)selected, count, info);
}
}
}
else if (IS_CMD(xfeCmdCopyMessage))
{
MSG_FolderInfo *info = (MSG_FolderInfo*)calldata;
if (info)
MSG_CopyMessagesIntoFolder(m_pane, (MSG_ViewIndex*)selected, count, info);
}
else if (isDisplayingNews()
&& (IS_CMD(xfeCmdDeleteMessage) || IS_CMD(xfeCmdCancelMessages) ||
IS_CMD(xfeCmdDeleteAny) ))
{
// If this is a news article, then Delete Message
// is really Cancel Message:
MSG_Command(m_pane, MSG_CancelMessage,
(MSG_ViewIndex*)selected, count);
}
else if (IS_CMD(xfeCmdExpand))
{
MSG_MessageLine mline;
MSG_GetThreadLineByIndex(m_pane, (MSG_ViewIndex)selected[0], 1,
&mline);
if ((mline.numChildren > (uint16)0)
&& ((mline.flags & MSG_FLAG_ELIDED) != (uint32)0))
MSG_ToggleExpansion(m_pane, (MSG_ViewIndex)selected[0], NULL);
}
else if (IS_CMD(xfeCmdCollapse))
{
MSG_MessageLine mline;
MSG_GetThreadLineByIndex(m_pane, (MSG_ViewIndex)selected[0], 1,
&mline);
if ((mline.numChildren > (uint16)0)
&& ((mline.flags & MSG_FLAG_ELIDED) == (uint32)0)) {
if (mline.numChildren == 1)
addCollapsed(selected[0]);
MSG_ToggleExpansion(m_pane, (MSG_ViewIndex)selected[0], NULL);
}/* if */
}
else if (IS_CMD(xfeCmdExpandAll))
{
// Note that in the following loop, getTotalLines()
// may grow each time we expand, but that's okay.
int i;
for (i=0; i < getOutliner()->getTotalLines(); ++i)
{
MSG_MessageLine mline;
MSG_GetThreadLineByIndex(m_pane, i, 1, &mline);
if ((mline.numChildren != (uint16)0)
&& ((mline.flags & MSG_FLAG_ELIDED) != (uint32)0))
MSG_ToggleExpansion(m_pane, (MSG_ViewIndex)i, NULL);
}
}
else if (IS_CMD(xfeCmdCollapseAll))
{
// Note that in the following loop, getTotalLines()
// may shrink each time we collapse, but that's okay.
int i;
for (i=0; i < getOutliner()->getTotalLines(); ++i)
{
MSG_MessageLine mline;
MSG_GetThreadLineByIndex(m_pane, i, 1, &mline);
if (mline.numChildren != (uint16)0)
{
// Now collapse the parent:
if ((mline.flags & MSG_FLAG_ELIDED) == (uint32)0) {
if (mline.numChildren == 1)
addCollapsed(i);
MSG_ToggleExpansion(m_pane, (MSG_ViewIndex)i, NULL);
}/* if */
}
}
}
else if (IS_CMD(xfeCmdDeleteMessage) || IS_CMD(xfeCmdDeleteAny) )
{
if (count == 1)
/* stop loading since we are deleting this message:
* shall we check if it is stopable?
*/
XP_InterruptContext(m_contextData);
{
MSG_Command(m_pane, MSG_DeleteMessage, (MSG_ViewIndex*)selected, count);
}
XFE_MozillaApp::theApp()->
notifyInterested(XFE_MNView::folderChromeNeedsUpdating,
getFolderInfo());
}
else if (IS_CMD(xfeCmdEditMailFilterRules))
{
fe_showMailFilterDlg(getToplevel()->getBaseWidget(),
m_contextData,m_pane);
}
else if (IS_CMD(xfeCmdSearchAddress))
{
fe_showLdapSearch(XfeAncestorFindApplicationShell(getToplevel()->getBaseWidget()),
/* Tao: we might need to check if this returns a
* non-NULL frame
*/
ViewGlue_getFrame(m_contextData),
(Chrome*)NULL);
}
else if (IS_CMD(xfeCmdSelectThread))
{
// Call Select Thread
selectThread();
}
else if (IS_CMD(xfeCmdViewNew)
|| IS_CMD(xfeCmdViewThreadsWithNew)
|| IS_CMD(xfeCmdViewWatchedThreadsWithNew)
|| IS_CMD(xfeCmdViewAllThreads)
|| IS_CMD(xfeCmdToggleKilledThreads)
|| IS_CMD(xfeCmdSortBySender)
|| IS_CMD(xfeCmdSortByDate)
|| IS_CMD(xfeCmdSortBySubject)
|| IS_CMD(xfeCmdSortByPriority)
|| IS_CMD(xfeCmdSortByThread)
|| IS_CMD(xfeCmdSortByMessageNumber)
|| IS_CMD(xfeCmdSortBySize)
|| IS_CMD(xfeCmdSortByFlag)
|| IS_CMD(xfeCmdSortByStatus)
|| IS_CMD(xfeCmdSortByUnread))
{
D(printf ("Changing view.\n");)
MSG_CommandType msg_cmd = commandToMsgCmd(cmd);
if (msg_cmd != (MSG_CommandType)~0)
{
MSG_Command(m_pane, msg_cmd, (MSG_ViewIndex*)selected, count);
/* make sure one of the selected items is still visible. */
m_outliner->getSelection(&selected, &count);
if (count > 0)
m_outliner->makeVisible(selected[0]);
if (IS_CMD(xfeCmdSortByMessageNumber))
m_outliner->setSortColumn(-1, m_outliner->getSortDirection());
}
}
else if (IS_CMD(xfeCmdOpenSelected))
{
int i;
MessageKey key;
for (i = 0; i < count; i ++)
{
key = MSG_GetMessageKey(m_pane, (MSG_ViewIndex)selected[i]);
fe_showMsg(XtParent(getToplevel()->getBaseWidget()),
/* Tao: we might need to check if this returns a
* non-NULL frame
*/
ViewGlue_getFrame(m_contextData),
NULL, m_folderInfo, key, FALSE);
}
}
else if (IS_CMD(xfeCmdSearch))
{
// We don't need to call XtParent on the base widget because
// the base widget is the real toplevel widget already...dora 12/31/96
fe_showMNSearch(XfeAncestorFindApplicationShell(getToplevel()->getBaseWidget()),
/* Tao: we might need to check if this returns a
* non-NULL frame
*/
ViewGlue_getFrame(m_contextData),
NULL, this, m_folderInfo);
}
else if (IS_CMD(xfeCmdSortDescending))
{
if ( MSG_GetToggleStatus( m_pane, MSG_SortBackward, NULL, 0 )
!= MSG_Checked )
{
MSG_Command(m_pane, MSG_SortBackward, NULL, 0);
/* make sure one of the selected items is still visible. */
m_outliner->getSelection(&selected, &count);
if (count > 0)
m_outliner->makeVisible(selected[0]);
}
}
else if (IS_CMD(xfeCmdSortAscending))
{
if ( MSG_GetToggleStatus( m_pane, MSG_SortBackward, NULL, 0 )
== MSG_Checked )
{
MSG_Command(m_pane, MSG_SortBackward, NULL, 0);
/* make sure one of the selected items is still visible. */
m_outliner->getSelection(&selected, &count);
if (count > 0)
m_outliner->makeVisible(selected[0]);
}
}
else
{
MSG_CommandType msg_cmd = commandToMsgCmd(cmd);
MSG_MotionType nav_cmd = commandToMsgNav(cmd);
if (info) {
CONTEXT_DATA(m_contextData)->stealth_cmd =
((info->event->type == ButtonRelease) &&
(info->event->xkey.state & ShiftMask));
}
if (nav_cmd == (MSG_MotionType)~0)
{
if ((msg_cmd == (MSG_CommandType)~0) ||
(msg_cmd == MSG_MailNew) ||
(msg_cmd == MSG_PostNew) )
{
XFE_MNListView::doCommand(cmd, calldata, info);
}
else {
MSG_Command(m_pane, msg_cmd, (MSG_ViewIndex*)selected, count);
/* single pane; count ==1
*/
if (IS_CMD(xfeCmdUndo)
|| IS_CMD(xfeCmdRedo)) {
MessageKey key = MSG_MESSAGEKEYNONE;
MSG_FolderInfo *folder = NULL;
if (!m_pane || !m_outliner)
return;
UndoStatus undoStatus =
MSG_GetUndoStatus(m_pane);
if ( UndoComplete == undoStatus ) {
if (MSG_GetUndoMessageKey(m_pane,
&folder, &key)
&& folder) {
if (m_folderInfo == folder) {
/* same folder
* select the message right away!
*/
MSG_ViewIndex index =
MSG_GetMessageIndexForKey(m_pane,
key,
TRUE);
if (index != MSG_VIEWINDEXNONE) {
showMessage(index);
}
}/* if */
else {
#if HANDLE_CMD_QUEUE
/* need to load new folder
*/
/* XFE: let handlePendingCmd() deal with
* this part
*/
m_commandPending = selectByKey;
m_pendingSelectionKey = key;
loadFolder(folder);
#endif /* HANDLE_CMD_QUEUE */
}/* if */
}/* if */
}/* if UndoComplete == undoStatus */
}/* if */
}/* else */
}
else
{
MSG_ViewIndex index, threadIndex;
MessageKey resultId;
MSG_FolderInfo *new_finfo;
if (count == 1)
{
m_outliner->setBlockSel(True);
MSG_ViewNavigate(m_pane, nav_cmd, selected[0],
&resultId, &index, &threadIndex,
&new_finfo);
m_outliner->setBlockSel(False);
// ViewNavigate gives a NULL folderinfo if the folder
// info won't be changing.
if (new_finfo &&
new_finfo != m_folderInfo)
{
/* insert here any navigational commands that can span folders, and
add corresponding entry in pendingCommand */
switch (nav_cmd)
{
case MSG_NextUnreadMessage:
m_commandPending = selectFirstUnread;
break;
case MSG_PreviousUnreadMessage:
m_commandPending = selectLastUnread;
break;
default:
XP_ASSERT(0);
break;
}
loadFolder(new_finfo);
}
else
{
int numLines = MSG_GetNumLines(m_pane),
idx = (int) index;
if (idx >=0 && idx < numLines)
showMessage(idx);
}
}
}
XFE_MozillaApp::theApp()->notifyInterested(XFE_MNView::folderChromeNeedsUpdating,
getFolderInfo());
}
#undef IS_CMD
}
char *XFE_ThreadView::getColumnTextByMsgLine(MSG_MessageLine *msgLine, int column)
{
static char buf[1024]; /* ## Sigh... */
static char from_buf[1024]; /* ## Sigh... */
static char size_buf[100]; /* ## Sigh... */
char *tmp = NULL;
switch (column)
{
case OUTLINER_COLUMN_SUBJECT:
{
tmp = IntlDecodeMimePartIIStr(msgLine->subject, fe_LocaleCharSetID,
FALSE);
if (msgLine->flags & MSG_FLAG_HAS_RE)
{
XP_SAFE_SPRINTF(buf, sizeof(buf),
"%s", XP_GetString( XFE_RE ) );
XP_STRNCAT_SAFE(buf,
(tmp ? tmp : msgLine->subject),
sizeof(buf) - XP_STRLEN(buf));
if (tmp) XP_FREE(tmp);
return buf;
}
else
{
if (tmp)
{
XP_STRNCPY_SAFE(buf, tmp, sizeof(buf));
XP_FREE(tmp);
return buf;
}
else
{
XP_STRNCPY_SAFE(buf, msgLine->subject, sizeof(buf));
return buf;
}
}
}
case OUTLINER_COLUMN_SENDERRECIPIENT:
{
tmp = IntlDecodeMimePartIIStr(msgLine->author, fe_LocaleCharSetID, FALSE);
if (tmp)
{
XP_STRNCPY_SAFE(from_buf, tmp, sizeof(from_buf));
XP_FREE(tmp);
return from_buf;
}
else
{
XP_STRNCPY_SAFE(from_buf, msgLine->author, sizeof(from_buf));
return from_buf;
}
}
case OUTLINER_COLUMN_DATE:
{
if (msgLine->date == 0)
{
return "";
}
else
{
return (char*)MSG_FormatDate(m_pane, msgLine->date);
}
}
case OUTLINER_COLUMN_PRIORITY:
{
return priorityToString(msgLine->priority);
}
case OUTLINER_COLUMN_SIZE:
{
XP_SAFE_SPRINTF(size_buf, sizeof(size_buf),
"%ld", msgLine->messageLines);
return size_buf;
}
case OUTLINER_COLUMN_STATUS:
{
if (msgLine->flags & MSG_FLAG_NEW)
return XP_GetString(XP_STATUS_NEW);
else if ((msgLine->flags & MSG_FLAG_REPLIED)&&
(msgLine->flags & MSG_FLAG_FORWARDED))
return XP_GetString(XP_STATUS_REPLIED_AND_FORWARDED);
else if (msgLine->flags & MSG_FLAG_FORWARDED)
return XP_GetString(XP_STATUS_FORWARDED);
else if (msgLine->flags & MSG_FLAG_REPLIED)
return XP_GetString(XP_STATUS_REPLIED);
return NULL; /* ### */
}
case OUTLINER_COLUMN_UNREADMSG:
{
return NULL; // we don't have a string in this column -- only an icon.
}
case OUTLINER_COLUMN_FLAG:
{
return NULL; // we don't have a string in this column -- only an icon.
}
default:
XP_ASSERT(0);
return NULL;
}
}
/* Outlinable interface methods */
char *XFE_ThreadView::getCellTipString(int row, int column)
{
/* returned string will be duplicated by outliner
*/
char *tmp = 0;
if (row < 0) {
/* header
*/
tmp = getColumnHeaderText(column);
}/* if */
else {
/* content
*/
MSG_MessageLine* msgLine =
(MSG_MessageLine *) XP_CALLOC(1,
sizeof(MSG_MessageLine));
if (!MSG_GetThreadLineByIndex(m_pane, row, 1, msgLine))
return NULL;
/* static array; do not free
*/
tmp = getColumnTextByMsgLine(msgLine, column);
XP_FREEIF(msgLine);
}/* else */
if (tmp &&
(!m_outliner->isColTextFit(tmp, row, column)))
return tmp;
return NULL;
}
char *XFE_ThreadView::getCellDocString(int /* row */, int /* column */)
{
return NULL;
}
void *
XFE_ThreadView::ConvFromIndex(int index)
{
MessageKey id = MSG_GetMessageKey(m_pane, index);
return (void*)id;
}
int
XFE_ThreadView::ConvToIndex(void *item)
{
MessageKey id = (MessageKey)item;
MSG_ViewIndex index;
index = MSG_GetMessageIndexForKey(m_pane, id, False);
if (index == MSG_VIEWINDEXNONE)
{
MSG_MessageLine line;
if (!MSG_GetThreadLineById(m_pane, id, &line))
{
/* error while looking up line for this message.
punt */
return -1;
}
else
{
MSG_ViewIndex thread_index =
MSG_GetMessageIndexForKey(m_pane, line.threadId, False);
if (MSG_ExpansionDelta(m_pane, thread_index) > 0)
{
MSG_ToggleExpansion(m_pane, thread_index, NULL);
index = MSG_GetMessageIndexForKey(m_pane,
id, False);
}
return index;
}
}
else
{
return index;
}
}
void *
XFE_ThreadView::acquireLineData(int line)
{
m_ancestorInfo = NULL;
if (!MSG_GetThreadLineByIndex(m_pane, line, 1, &m_messageLine))
return NULL;
m_ancestorInfo = new OutlinerAncestorInfo[ m_messageLine.level + 1 ];
int i = m_messageLine.level;
int idx = line + 1;
while ( i > 0 ) {
if ( idx < m_outliner->getTotalLines()) {
int level = MSG_GetThreadLevelByIndex( m_pane, idx );
if ( level == i ) {
m_ancestorInfo[i].has_prev = TRUE;
m_ancestorInfo[i].has_next = TRUE;
i--;
idx++;
} else if ( level < i ) {
m_ancestorInfo[i].has_prev = FALSE;
m_ancestorInfo[i].has_next = FALSE;
i--;
} else {
idx++;
}
} else {
m_ancestorInfo[i].has_prev = FALSE;
m_ancestorInfo[i].has_next = FALSE;
i--;
}
}
m_ancestorInfo[0].has_prev = FALSE;
m_ancestorInfo[0].has_next = FALSE;
return &m_messageLine;
}
void
XFE_ThreadView::getTreeInfo(Boolean *expandable,
Boolean *is_expanded,
int *depth,
OutlinerAncestorInfo **ancestor)
{
XP_Bool is_line_expandable;
XP_Bool is_line_expanded;
is_line_expandable = (m_messageLine.numChildren > 0);
if (is_line_expandable)
{
is_line_expanded = (m_messageLine.flags & MSG_FLAG_ELIDED) == 0;
}
else
{
is_line_expanded = FALSE;
}
if ( ancestor )
*ancestor = m_ancestorInfo;
if (depth)
*depth = m_messageLine.level;
if (expandable)
*expandable = is_line_expandable;
if (is_expanded)
*is_expanded = is_line_expanded;
}
EOutlinerTextStyle
XFE_ThreadView::getColumnStyle(int /*column*/)
{
if (m_messageLine.flags & MSG_FLAG_EXPIRED)
return OUTLINER_Default ; /* Don't boldface dummy messages. */
else if ((m_messageLine.flags & MSG_FLAG_ELIDED) && m_messageLine.numNewChildren > 0)
return OUTLINER_Bold; /* boldface toplevel thread messages with unread children. */
else
return (m_messageLine.flags & MSG_FLAG_READ) ? OUTLINER_Default : OUTLINER_Bold;
}
char *
XFE_ThreadView::getColumnText(int column)
{
static char buf_a[1024]; /* ## Sigh... */
static char from_buf_a[1024]; /* ## Sigh... */
static char size_buf_a[100]; /* ## Sigh... */
char *tmp = NULL;
switch (column)
{
case OUTLINER_COLUMN_SUBJECT:
{
tmp = IntlDecodeMimePartIIStr(m_messageLine.subject, fe_LocaleCharSetID, FALSE);
if (m_messageLine.flags & MSG_FLAG_HAS_RE)
{
XP_STRNCPY_SAFE (buf_a, XP_GetString( XFE_RE ), sizeof(buf_a) );
XP_STRNCAT_SAFE (buf_a,
(tmp ? tmp : m_messageLine.subject),
sizeof(buf_a) - XP_STRLEN(buf_a));
if (tmp) XP_FREE(tmp);
return buf_a;
}
else
{
if (tmp)
{
XP_STRNCPY_SAFE(buf_a, tmp, sizeof(buf_a));
XP_FREE(tmp);
return buf_a;
}
else
{
return m_messageLine.subject;
}
}
}
case OUTLINER_COLUMN_SENDERRECIPIENT:
{
tmp = IntlDecodeMimePartIIStr(m_messageLine.author, fe_LocaleCharSetID, FALSE);
if (tmp)
{
XP_STRNCPY_SAFE(from_buf_a, tmp, sizeof(from_buf_a));
XP_FREE(tmp);
return from_buf_a;
}
else
{
return m_messageLine.author;
}
}
case OUTLINER_COLUMN_DATE:
{
if (m_messageLine.date == 0)
{
return "";
}
else
{
return (char*)MSG_FormatDate(m_pane, m_messageLine.date);
}
}
case OUTLINER_COLUMN_PRIORITY:
{
return priorityToString(m_messageLine.priority);
}
case OUTLINER_COLUMN_SIZE:
{
XP_SAFE_SPRINTF(size_buf_a, sizeof(size_buf_a),
"%ld", m_messageLine.messageLines);
return size_buf_a;
}
case OUTLINER_COLUMN_STATUS:
{
if (m_messageLine.flags & MSG_FLAG_NEW)
return XP_GetString(XP_STATUS_NEW);
else if ((m_messageLine.flags & MSG_FLAG_REPLIED)&&
(m_messageLine.flags & MSG_FLAG_FORWARDED))
return XP_GetString(XP_STATUS_REPLIED_AND_FORWARDED);
else if (m_messageLine.flags & MSG_FLAG_FORWARDED)
return XP_GetString(XP_STATUS_FORWARDED);
else if (m_messageLine.flags & MSG_FLAG_REPLIED)
return XP_GetString(XP_STATUS_REPLIED);
return NULL; /* ### */
}
case OUTLINER_COLUMN_UNREADMSG:
{
return NULL; // we don't have a string in this column -- only an icon.
}
case OUTLINER_COLUMN_FLAG:
{
return NULL; // we don't have a string in this column -- only an icon.
}
default:
XP_ASSERT(0);
return NULL;
}
}
fe_icon *
XFE_ThreadView::getColumnIcon(int column)
{
switch (column)
{
case OUTLINER_COLUMN_SUBJECT:
{
MSG_FolderLine folderLine;
MSG_GetFolderLineById(XFE_MNView::getMaster(), m_folderInfo, &folderLine);
return flagToIcon(folderLine.flags, m_messageLine.flags);
}
case OUTLINER_COLUMN_UNREADMSG:
return (m_messageLine.flags & MSG_FLAG_READ ? &msgReadIcon : &msgUnreadIcon);
case OUTLINER_COLUMN_FLAG:
return (m_messageLine.flags & MSG_FLAG_MARKED ? &msgFlagIcon : &msgReadIcon);
case -1: /* OUTLINER_DESCENDANT_SELECT_COLUMN */
{
if (m_messageLine.flags & MSG_FLAG_IGNORED)
{
return (m_messageLine.flags & MSG_FLAG_ELIDED ? &closedSpoolIgnoredIcon : &openSpoolIgnoredIcon);
}
else if (m_messageLine.flags & MSG_FLAG_WATCHED)
{
return (m_messageLine.flags & MSG_FLAG_ELIDED ? &closedSpoolWatchedIcon : &openSpoolWatchedIcon);
}
else if (m_messageLine.numChildren > 0)
{
if (m_messageLine.flags & MSG_FLAG_NEW
|| m_messageLine.numNewChildren > 0)
return (m_messageLine.flags & MSG_FLAG_ELIDED ? &closedSpoolNewIcon : &openSpoolNewIcon);
else
return (m_messageLine.flags & MSG_FLAG_ELIDED ? &closedSpoolIcon : &openSpoolIcon);
}
else
{
return NULL;
}
}
default:
return 0;
}
}
char *
XFE_ThreadView::getColumnName(int column)
{
switch (column)
{
case OUTLINER_COLUMN_SUBJECT:
return "Subject";
case OUTLINER_COLUMN_UNREADMSG:
return "Unread";
case OUTLINER_COLUMN_FLAG:
return "Flag";
case OUTLINER_COLUMN_DATE:
return "Date";
case OUTLINER_COLUMN_PRIORITY:
return "Priority";
case OUTLINER_COLUMN_SIZE:
return "Size";
case OUTLINER_COLUMN_STATUS:
return "Status";
case OUTLINER_COLUMN_SENDERRECIPIENT:
return "Sender";
default:
XP_ASSERT(0);
return 0;
}
}
char *
XFE_ThreadView::getColumnHeaderText(int column)
{
switch (column)
{
case OUTLINER_COLUMN_SUBJECT:
return XP_GetString(XFE_THREAD_OUTLINER_COLUMN_SUBJECT);
case OUTLINER_COLUMN_UNREADMSG:
return 0;
case OUTLINER_COLUMN_FLAG:
return 0;
case OUTLINER_COLUMN_DATE:
return XP_GetString(XFE_THREAD_OUTLINER_COLUMN_DATE);
case OUTLINER_COLUMN_PRIORITY:
return XP_GetString(XFE_THREAD_OUTLINER_COLUMN_PRIORITY);
case OUTLINER_COLUMN_SIZE:
{
if (m_displayingNewsgroup)
return XP_GetString(XFE_SIZE_IN_LINES);
else
return XP_GetString(XFE_SIZE_IN_BYTES);
}
case OUTLINER_COLUMN_STATUS:
return XP_GetString(XFE_THREAD_OUTLINER_COLUMN_STATUS);
case OUTLINER_COLUMN_SENDERRECIPIENT:
if (MSG_DisplayingRecipients(m_pane))
return XP_GetString(XFE_THREAD_OUTLINER_COLUMN_RECIPIENT);
else
return XP_GetString(XFE_THREAD_OUTLINER_COLUMN_SENDER);
default:
// XP_ASSERT(0);
return 0;
}
}
fe_icon *
XFE_ThreadView::getColumnHeaderIcon(int column)
{
switch (column)
{
case OUTLINER_COLUMN_UNREADMSG:
return &msgUnreadIcon;
case OUTLINER_COLUMN_FLAG:
return &msgFlagIcon;
case OUTLINER_COLUMN_SUBJECT:
if (MSG_GetToggleStatus(m_pane, MSG_SortByThread, NULL, 0) == MSG_Checked)
return &threadonIcon;
else
return &threadoffIcon;
default:
return 0;
}
}
EOutlinerTextStyle
XFE_ThreadView::getColumnHeaderStyle(int column)
{
MSG_CommandType sort_type = (MSG_CommandType)~0;
switch (column)
{
case OUTLINER_COLUMN_SENDERRECIPIENT:
sort_type = MSG_SortBySender;
break;
case OUTLINER_COLUMN_DATE:
sort_type = MSG_SortByDate;
break;
case OUTLINER_COLUMN_SUBJECT:
sort_type = MSG_SortBySubject;
break;
case OUTLINER_COLUMN_PRIORITY:
sort_type = MSG_SortByPriority;
break;
case OUTLINER_COLUMN_SIZE:
sort_type = MSG_SortBySize;
break;
case OUTLINER_COLUMN_STATUS:
sort_type = MSG_SortByStatus;
break;
case OUTLINER_COLUMN_UNREADMSG:
sort_type = MSG_SortByUnread;
break;
case OUTLINER_COLUMN_FLAG:
sort_type = MSG_SortByFlagged;
break;
}
if (sort_type == (MSG_CommandType)~0)
{
return OUTLINER_Default;
}
else
{
XP_Bool checked = MSG_GetToggleStatus(m_pane, sort_type, NULL, 0) == MSG_Checked;
XP_Bool backward = MSG_GetToggleStatus(m_pane, MSG_SortBackward, NULL, 0) == MSG_Checked;
if (checked)
{
m_outliner->setSortColumn(column,
backward ? OUTLINER_SortDescending : OUTLINER_SortAscending);
return OUTLINER_Bold;
}
else
{
return OUTLINER_Default;
}
}
}
void
XFE_ThreadView::releaseLineData()
{
delete [] m_ancestorInfo;
m_ancestorInfo = NULL;
}
XFE_CALLBACK_DEFN(XFE_ThreadView, allConnectionsComplete)(XFE_NotificationCenter *,
void *,
void *)
{
D(printf ("in all connections complete.\n");)
#if HANDLE_CMD_QUEUE
#if defined(DEBUG_tao)
printf("\n XFE_ThreadView::allConnectionsComplete\n");
#endif
if (m_deletedCount &&
m_deleted)
processCmdQueue();
#endif /* HANDLE_CMD_QUEUE */
handlePendingCommand();
}
void
XFE_ThreadView::setPendingCmdSelByKey(PendingCommand cmd, MessageKey key)
{
m_commandPending = cmd;
m_pendingSelectionKey = key;
}
void
XFE_ThreadView::handlePendingCommand()
{
switch (m_commandPending)
{
case invalidateThreadAndSelection:
/* for this case, we loop backward to the message with level 1 -- the toplevel
message in this thread, find it's num_children, and invalidate all those
lines. This fixes pipe updates and lots of other things. */
{
D(printf("handlePendingCommand(invalidateThreadAndSelection)\n");)
/* tao: Obselete deletion code; assert!
*/
XP_ASSERT(0);
break;
}
case getNewMessages:
{
D(printf("handlePendingCommand(getNewMessages)\n");)
m_commandPending = noPendingCommand;
doCommand(xfeCmdGetNewMessages);
break;
}
case selectByIndex:
{
D(printf("handlePendingCommand(selectByIndex)\n");)
D(printf(" pending selection index is %d\n", m_pendingSelectionIndex);)
m_commandPending = noPendingCommand;
if (m_pendingSelectionIndex != MSG_VIEWINDEXNONE)
showMessage(m_pendingSelectionIndex);
break;
}
case selectByKey:
{
D(printf("handlePendingCommand(selectByKey,%d)\n", m_pendingSelectionKey);)
m_commandPending = noPendingCommand;
if (m_pendingSelectionKey != MSG_MESSAGEKEYNONE)
{
/* 87274: Caldera: "Go to Message Folder" fails when
* messages are threaded.
*
* Fix: call MSG_xxxForKey() to expand the thread
* when needed.
*/
MSG_ViewIndex index =
MSG_GetMessageIndexForKey(m_pane,
m_pendingSelectionKey,
True);
D(printf (" pending selection index is %d\n", index);)
if (index != MSG_VIEWINDEXNONE)
showMessage(index);
}
break;
}
case selectFirstUnread:
{
D(printf("handlePendingCommand(selectFirstUnread)\n");)
MSG_ViewIndex index, threadIndex;
MessageKey resultId;
m_commandPending = noPendingCommand;
m_outliner->setBlockSel(True);
MSG_ViewNavigate(m_pane, MSG_FirstUnreadMessage, MSG_VIEWINDEXNONE/* ??? */,
&resultId, &index, &threadIndex, NULL);
m_outliner->setBlockSel(False);
showMessage(index);
break;
}
case selectLastUnread:
{
D(printf("handlePendingCommand(selectLastUnread)\n");)
MSG_ViewIndex index, threadIndex;
MessageKey resultId;
m_commandPending = noPendingCommand;
MSG_ViewNavigate(m_pane, MSG_LastUnreadMessage, MSG_VIEWINDEXNONE/* ??? */,
&resultId, &index, &threadIndex, NULL);
showMessage(index);
break;
}
case scrollToFirstNew:
{
D(printf("handlePendingCommand(scrollToFirstNew)\n");)
MessageKey resultId, resultingThread;
MSG_ViewIndex resultIndex = 0;
m_commandPending = noPendingCommand;
/* note: We don't expand threads here -- we scroll to the message that
starts the thread. */
/* after we do a get new mail, we end up here. We try to scroll to the
first new one. */
MSG_DataNavigate(m_pane, MSG_FirstNew, MSG_MESSAGEKEYNONE/*???*/,
&resultId, &resultingThread);
/* if there wasn't a new message, we scroll to the first unread message */
if (resultId == MSG_MESSAGEKEYNONE
|| resultingThread == MSG_MESSAGEKEYNONE)
MSG_DataNavigate(m_pane, MSG_FirstUnreadMessage, MSG_MESSAGEKEYNONE/*???*/,
&resultId, &resultingThread);
/* if there wasn't an unread message, we scroll to the last item. */
if (m_outliner->getTotalLines() > 0)
{
if (resultId == MSG_MESSAGEKEYNONE
|| resultingThread == MSG_MESSAGEKEYNONE)
{
resultIndex = (MSG_ViewIndex)m_outliner->getTotalLines() - 1;
}
else
{
resultIndex =
MSG_GetMessageIndexForKey(m_pane,
resultingThread,
False);
if (resultIndex == MSG_VIEWINDEXNONE)
resultIndex = m_outliner->getTotalLines() - 1;
}
m_outliner->makeVisible((int)resultIndex);
}
break;
}
case noPendingCommand: // we should be so lucky
D(printf ("no pending command to execute\n");)
break;
default:
XP_ASSERT(0);
break;
}
}
void
XFE_ThreadView::Buttonfunc(const OutlineButtonFuncData *data)
{
/*
** Broadcast the view is currently in focus because
** of the button clicking
*/
getToplevel()->notifyInterested(XFE_MNListView::changeFocus, (void*) this);
if (data->row == -1) // heading row.
{
const int *selected;
int count;
m_outliner->setDescendantSelectAllowed(False);
switch (data->column)
{
case OUTLINER_COLUMN_SUBJECT:
if (data->x < (threadonIcon.width + /* hack -- shadowthickness */ 4))
{
if (isCommandEnabled(xfeCmdSortByThread))
{
m_outliner->setSortColumn(-1,
OUTLINER_SortAscending);
m_outliner->setDescendantSelectAllowed(True);
doCommand(xfeCmdSortByThread);
}
}
else
{
if (isCommandEnabled(xfeCmdSortBySubject))
{
if (m_outliner->getSortColumn() == data->column)
m_outliner->toggleSortDirection();
doCommand(xfeCmdSortBySubject);
}
}
break;
case OUTLINER_COLUMN_SENDERRECIPIENT:
if (isCommandEnabled(xfeCmdSortBySender))
{
if (m_outliner->getSortColumn() == data->column)
m_outliner->toggleSortDirection();
doCommand(xfeCmdSortBySender);
}
break;
case OUTLINER_COLUMN_DATE:
if (isCommandEnabled(xfeCmdSortByDate))
{
if (m_outliner->getSortColumn() == data->column)
m_outliner->toggleSortDirection();
doCommand(xfeCmdSortByDate);
}
break;
case OUTLINER_COLUMN_PRIORITY:
if (isCommandEnabled(xfeCmdSortByPriority))
{
if (m_outliner->getSortColumn() == data->column)
m_outliner->toggleSortDirection();
doCommand(xfeCmdSortByPriority);
}
break;
case OUTLINER_COLUMN_STATUS:
if (isCommandEnabled(xfeCmdSortByStatus))
{
if (m_outliner->getSortColumn() == data->column)
m_outliner->toggleSortDirection();
doCommand(xfeCmdSortByStatus);
}
break;
case OUTLINER_COLUMN_SIZE:
if (isCommandEnabled(xfeCmdSortBySize))
{
if (m_outliner->getSortColumn() == data->column)
m_outliner->toggleSortDirection();
doCommand(xfeCmdSortBySize);
}
break;
case OUTLINER_COLUMN_UNREADMSG:
if (isCommandEnabled(xfeCmdSortByUnread))
{
if (m_outliner->getSortColumn() == data->column)
m_outliner->toggleSortDirection();
doCommand(xfeCmdSortByUnread);
}
break;
case OUTLINER_COLUMN_FLAG:
if (isCommandEnabled(xfeCmdSortByFlag))
{
if (m_outliner->getSortColumn() == data->column)
m_outliner->toggleSortDirection();
doCommand(xfeCmdSortByFlag);
}
break;
}
m_outliner->getSelection(&selected, &count);
if (count >= 1)
{
D(printf ("Making %d visible\n", selected[0]);)
m_outliner->makeVisible(selected[0]);
}
}
else // content row.
{
if (data->clicks == 2)
{
m_outliner->selectItemExclusive(data->row);
if ( m_displayingDraft )
{
MSG_OpenDraft(m_pane, m_folderInfo,
MSG_GetMessageKey(m_pane, data->row));
}
else
{
// ok. we're going to display a message in a message frame.
// what is left to determine is whether or not we will be
// popping up another window or reusing an existing one (if
// there is one.) This behavior is governed by two things:
// 1. fe_globalPrefs.reuse_msg_window and,
// 2. data->alt (whether the alt key was down or not...)
fe_showMsg(XtParent(getToplevel()->getBaseWidget()),
/* Tao: we might need to check if this returns a
* non-NULL frame
*/
ViewGlue_getFrame(m_contextData),
(Chrome*)NULL,
m_folderInfo,
MSG_GetMessageKey(m_pane, data->row),
(( fe_globalPrefs.reuse_msg_window
&& !data->shift)
|| (!fe_globalPrefs.reuse_msg_window
&& data->shift))
);
}
}
else if (data->clicks == 1)
{
const int *selected;
int count;
m_outliner->getSelection(&selected, &count);
#if defined(DEBUG_tao_)
printf("\n+++ data->clicks count=%d\n", count);
#endif
if (data->ctrl)
{
m_outliner->toggleSelected(data->row);
m_outliner->getSelection(&selected, &count);
#if defined(DEBUG_tao_)
printf("\n+++ data->clicks count=%d\n", count);
#endif
if (count == 1)
showMessage(selected[0]);
else if (count == 0 ||
count > 1)
showMessage(-1);
}
else if (data->shift)
{
// select the range.
if (count == 0) /* there wasn't anything selected yet. */
{
m_outliner->selectItemExclusive(data->row);
// clear the message area/label
showMessage(-1);
}
else if (count == 1) /* there was only one, so we select the range from
that item to the new one. */
{
m_outliner->selectRangeByIndices(selected[0], data->row);
// clear the message area/label
showMessage(-1);
}
else /* we had a range of items selected, so let's do something really
nice with them. */
{
m_outliner->trimOrExpandSelection(data->row);
// clear the message area/label
showMessage(-1);
}
}
else
{
// handle the columns that don't actually move the selection here
if (data->column == OUTLINER_COLUMN_UNREADMSG)
{
MSG_Command(m_pane, MSG_ToggleMessageRead, (MSG_ViewIndex*)&data->row, 1);
}
else if (data->column == OUTLINER_COLUMN_FLAG)
{
MSG_MessageLine line;
if (!MSG_GetThreadLineByIndex(m_pane, data->row, 1, &line))
return;
if (line.flags & MSG_FLAG_MARKED)
MSG_Command(m_pane, MSG_UnmarkMessages, (MSG_ViewIndex*)&data->row, 1);
else
MSG_Command(m_pane, MSG_MarkMessages, (MSG_ViewIndex*)&data->row, 1);
}
else
{
if ((int) m_targetIndex != data->row) {
//
m_targetIndex = MSG_VIEWINDEXNONE;
if (m_scrollTimer)
XtRemoveTimeOut(m_scrollTimer);
m_scrollTimer = 0;
}/* if */
// we've selected a message, update the label and load it into
// our message view.
showMessage(data->row);
}
}
XFE_MozillaApp::theApp()->notifyInterested(XFE_MNView::folderChromeNeedsUpdating,
getFolderInfo());
}
}
}
void
XFE_ThreadView::Flippyfunc(const OutlineFlippyFuncData *data)
{
int delta = MSG_ExpansionDelta(m_pane, data->row);
XP_Bool need_to_select_top = FALSE;
if (data->do_selection) // we do descendant selection
{
MSG_MessageLine line;
if (delta > 0)
MSG_ToggleExpansion(m_pane, data->row, NULL);
MSG_GetThreadLineByIndex(m_pane, data->row, 1, &line);
m_outliner->deselectAllItems();
m_outliner->selectRangeByIndices(data->row, data->row + line.numChildren);
showMessage(-1);
}
else if (delta != 0) // actually to flippy stuff.
{
if (delta < 0)
{
if (delta == -1)
addCollapsed(data->row);
int i;
delta = -delta;
for (i = data->row + 1; i < data->row + 1 + delta; i ++)
{
if (m_outliner->isSelected(i))
{
need_to_select_top = TRUE;
m_outliner->deselectItem(i);
}
}
}
MSG_ToggleExpansion(m_pane, data->row, NULL);
if (need_to_select_top)
m_outliner->selectItem(data->row);
}
}
XFE_CALLBACK_DEFN(XFE_ThreadView, spaceAtMsgEnd)(XFE_NotificationCenter*,
void *, void *)
{
if (isCommandEnabled(xfeCmdNextUnreadMessage))
doCommand(xfeCmdNextUnreadMessage);
else if (isCommandEnabled(xfeCmdNextUnreadCollection))
doCommand(xfeCmdNextUnreadCollection);
}
static void
click_timer_func(XtPointer closure, XtIntervalId *)
{
XFE_ThreadView *v = (XFE_ThreadView *) closure;
if (v)
v->selectTimer();
}
void
XFE_ThreadView::selectTimer()
{
if (m_targetIndex != MSG_VIEWINDEXNONE)
m_outliner->makeVisible(m_targetIndex);
//
m_targetIndex = MSG_VIEWINDEXNONE;
if (m_scrollTimer)
XtRemoveTimeOut(m_scrollTimer);
m_scrollTimer = 0;
}
XFE_CALLBACK_DEFN(XFE_ThreadView, newMessageLoading)(XFE_NotificationCenter*,
void *, void*)
{
if (m_commandPending == noPendingCommand)
{
MSG_FolderInfo *info = m_msgview->getFolderInfo();
MessageKey key = m_msgview->getMessageKey();
#if defined(DEBUG_tao)
printf("--newMessageLoading, m_pane=0x%x, m_lastLoadedKey=0x%x,key=0x%x", m_pane, m_lastLoadedKey, key);
#endif
if (info != m_folderInfo)
{
m_commandPending = selectByKey;
m_pendingSelectionKey = key;
loadFolder(info);
}
else
{
MSG_ViewIndex index = MSG_GetMessageIndexForKey(m_pane,
key,
False);
int numLines = MSG_GetNumLines(m_pane);
if (m_outliner->getTotalLines() != numLines)
m_outliner->change(0, numLines, numLines);
#if 1
m_targetIndex = index;
int intvl0 = XtGetMultiClickTime(XtDisplay(m_widget)),
intvl = intvl0 + intvl0/2;
#if defined(DEBUG_tao)
printf("--newMessageLoading, intvl0=%d, intvl=%d",
intvl0, intvl);
#endif
m_scrollTimer = XtAppAddTimeOut(fe_XtAppContext, intvl,
click_timer_func, this);
#else
/* 97010: selecting the last mail/news article
* show the wrong one.
*
* Take out to prevent improper auto-selection... -tao
*/
m_outliner->makeVisible(index);
#endif
m_outliner->selectItemExclusive(index);
updateExpandoFlippyText(index);
}
notifyInterested(XFE_View::chromeNeedsUpdating);
}
}
void
XFE_ThreadView::toggleMsgExpansion()
{
int32 folder_prefs = 0;
if (m_folderInfo)
{
folder_prefs = MSG_GetFolderPrefFlags(m_folderInfo);
folder_prefs |= MSG_FOLDER_PREF_FEVALID;
}
if (m_msgExpanded)
{
// we are currently expanded
Dimension message_pane_height;
XtVaGetValues(m_msgview->getBaseWidget(),
XmNheight, &message_pane_height,
NULL);
D(printf ("Saving message pane height as %d\n", message_pane_height);)
PREF_SetIntPref(MESSAGEPANE_HEIGHT_PREF, (int32)message_pane_height);
m_msgview->hide();
m_msgExpanded = FALSE;
// Set maximum heights so that the sash will go away:
Dimension height;
XtVaGetValues(m_arrowform,
XmNheight, &height,
NULL);
XtVaSetValues(m_arrowform,
XmNpaneMinimum, height,
XmNpaneMaximum, height,
NULL);
XtVaSetValues(m_arrowb,
XmNarrowDirection, XmARROW_UP,
NULL);
folder_prefs |= MSG_FOLDER_PREF_ONEPANE;
notifyInterested(XFE_View::chromeNeedsUpdating);
}
else
{
const int *selected;
int count;
int32 message_pane_desired_height;
Dimension message_pane_minimum_height;
Dimension message_pane_resulting_height;
Dimension panedw_spacing;
Dimension panedw_marginheight;
Dimension panedw_height;
Dimension arrow_form_height;
Dimension minimum_height_of_outliner;
int resulting_height_of_outliner;
XP_Bool need_to_resize_frame = False;
// we are currently unexpanded
XtVaSetValues(m_arrowb,
XmNarrowDirection, XmARROW_DOWN,
NULL);
XtVaGetValues(m_widget,
XmNspacing, &panedw_spacing,
XmNmarginHeight, &panedw_marginheight,
XmNheight, &panedw_height,
NULL);
XtVaGetValues(m_arrowform,
XmNheight, &arrow_form_height,
NULL);
XtVaGetValues(m_outliner->getBaseWidget(),
XmNpaneMinimum, &minimum_height_of_outliner,
NULL);
XtVaGetValues(m_msgview->getBaseWidget(),
XmNpaneMinimum, &message_pane_minimum_height,
NULL);
PREF_GetIntPref(MESSAGEPANE_HEIGHT_PREF, &message_pane_desired_height);
D(printf ("Message pane wants to be %d high.\n", message_pane_desired_height);)
resulting_height_of_outliner = (panedw_height
- (2 * panedw_spacing) /* space between the outliner and arrow
and between the arrow and message */
- (2 * panedw_marginheight)
- arrow_form_height
- message_pane_desired_height);
D(printf ("This will make the outliner %d high.\n", resulting_height_of_outliner);)
if (resulting_height_of_outliner < (int)minimum_height_of_outliner)
{
D(printf (" This is not ok.\n");)
resulting_height_of_outliner = minimum_height_of_outliner;
message_pane_resulting_height = (message_pane_desired_height
- (minimum_height_of_outliner
- resulting_height_of_outliner));
if (message_pane_resulting_height < message_pane_minimum_height)
{
message_pane_resulting_height = message_pane_minimum_height;
need_to_resize_frame = True;
}
D(printf (" The message pane will instead be sized to %d, and the window will%s be resized", message_pane_resulting_height, need_to_resize_frame ? "" : " not");)
}
if (need_to_resize_frame)
XtVaSetValues(getToplevel()->getBaseWidget(),
XmNallowShellResize, True,
NULL);
XtVaSetValues(m_msgview->getBaseWidget(),
XmNskipAdjust, TRUE,
NULL);
m_msgview->show();
XtVaSetValues(m_msgview->getBaseWidget(),
XmNskipAdjust, FALSE,
XmNpaneMinimum, PANE_MIN,
XmNpaneMaximum, PANE_MAX,
NULL);
if (need_to_resize_frame)
XtVaSetValues(getToplevel()->getBaseWidget(),
XmNallowShellResize, False,
NULL);
XtVaSetValues(m_outliner->getBaseWidget(),
XmNpaneMinimum, PANE_MIN,
XmNpaneMaximum, PANE_MAX,
NULL);
m_msgExpanded = TRUE;
folder_prefs &= ~MSG_FOLDER_PREF_ONEPANE;
m_outliner->getSelection(&selected, &count);
if (count == 1)
showMessage(selected[0]);
else
showMessage(-1);
XFE_MozillaApp::theApp()->notifyInterested(XFE_MNView::folderChromeNeedsUpdating, getFolderInfo());
}
if (m_folderInfo)
MSG_SetFolderPrefFlags(m_folderInfo, folder_prefs);
}
void
XFE_ThreadView::toggleMsgExpansionCallback(Widget, XtPointer clientData, XtPointer)
{
XFE_ThreadView *obj = (XFE_ThreadView*)clientData;
obj->toggleMsgExpansion();
}
#if !defined(USE_MOTIF_DND)
void
XFE_ThreadView::sourcedropfunc(fe_dnd_Source */*source*/, fe_dnd_Message msg, void *closure)
{
MSG_FolderInfo *info = (MSG_FolderInfo*)closure;
// messages can be copied or moved. The closure to this function will always
// be a MSG_FolderInfo*.
// XXX assume that nothing could have changed the selected between the time
// we started dragging and now... don't know how smart this is...
const char *name = MSG_GetFolderNameFromID(info);
const int *indices;
int count;
m_outliner->getSelection(&indices, &count);
/* New Code to take on the new Drag and Drop APIs with effect for both mail/news. However,
the effect checking on news articles are not completed in BE yet. Coredump will
be encountered when filing news articles. */
if (msg == FE_DND_MESSAGE_DELETE)
{
// delete the messages.
}
else
{
MSG_DragEffect requireEffect = MSG_Default_Drag;
MSG_DragEffect effect =
MSG_DragMessagesIntoFolderStatus(m_pane,
(MSG_ViewIndex*)indices, count,
info, requireEffect);
if (effect == MSG_Require_Move )
{
if (msg == FE_DND_MESSAGE_COPY )
{
DD(printf("### ThreadView::sourcedropfunc(req MOVE): FE_DND_MESSAGE_COPY To \n");)
MSG_CopyMessagesInto(m_pane, (MSG_ViewIndex*)indices, count, name);
}
else
{
DD(printf("### ThreadView::sourcedropfunc(req MOVE): FE_DND_MESSAGE_MOVE To \n");)
MSG_MoveMessagesInto(m_pane, (MSG_ViewIndex*)indices, count, name);
}
}
else if ( effect == MSG_Require_Copy )
{
DD(printf("### ThreadView::sourcedropfunc(req COPY): FE_DND_MESSAGE_COPY To \n");)
MSG_CopyMessagesInto(m_pane, (MSG_ViewIndex*)indices, count, name);
}
else if ( effect == MSG_Drag_Not_Allowed )
{
DD(printf("### ThreadView::sourcedropfunc: Not Allowed \n");)
char tmp[128];
XP_SAFE_SPRINTF(tmp, sizeof(tmp),
"%s",
XP_GetString(XFE_DND_MESSAGE_ERROR));
XFE_Progress (m_contextData, tmp);
}
else /* should not reach here. the effect status should be with in
the defined range. Please double check if you try to refer
to any enum outside the effect enum scope */
XP_ASSERT(0);
}
/* now we need to modify the chrome of windows viewing either folder */
XFE_MozillaApp::theApp()->notifyInterested(XFE_MNView::folderChromeNeedsUpdating, m_folderInfo);
XFE_MozillaApp::theApp()->notifyInterested(XFE_MNView::folderChromeNeedsUpdating, info);
}
void
XFE_ThreadView::source_drop_func(fe_dnd_Source *src, fe_dnd_Message msg, void *closure)
{
XFE_ThreadView *obj = (XFE_ThreadView*)src->closure;
obj->sourcedropfunc(src, msg, closure);
}
void
XFE_ThreadView::dropfunc(Widget /*dropw*/, fe_dnd_Event type,
fe_dnd_Source *source, XEvent *event)
{
m_outliner->handleDragEvent(event, type, source);
}
void
XFE_ThreadView::drop_func(Widget dropw, void *closure, fe_dnd_Event type,
fe_dnd_Source *source, XEvent* event)
{
XFE_ThreadView *obj = (XFE_ThreadView*)closure;
obj->dropfunc(dropw, type, source, event);
}
#endif /* USE_MOTIF_DND */
void
XFE_ThreadView::openWithKey(MessageKey key )
{
m_commandPending = selectByKey;
m_pendingSelectionKey = key;
}
#if defined(USE_MOTIF_DND)
fe_icon_data *
XFE_ThreadView::GetDragIconData(int row, int /*column*/)
{
D(printf("XFE_ThreadView::GetDragIconData()\n");)
if (row == -1) return &MN_MailRead;
else
{
MSG_FolderLine folderLine;
int flags = m_messageLine.flags;
MSG_GetFolderLineById(XFE_MNView::getMaster(), m_folderInfo, &folderLine);
acquireLineData(row);
flags = m_messageLine.flags;
releaseLineData();
return flagToIconData(folderLine.flags, flags);
}
}
fe_icon_data *
XFE_ThreadView::getDragIconData(void *this_ptr,
int row,
int column)
{
D(printf("XFE_ThreadView::getDragIconData()\n");)
XFE_ThreadView *thread_view = (XFE_ThreadView*)this_ptr;
return thread_view->GetDragIconData(row, column);
}
void
XFE_ThreadView::GetDragTargets(int row, int column,
Atom **targets,
int *num_targets)
{
D(printf("XFE_ThreadView::GetDragTargets()\n");)
int flags;
XP_ASSERT(row > -1);
if (row == -1)
{
*targets = NULL;
*num_targets = 0;
}
else
{
acquireLineData(row);
flags = m_messageLine.flags;
releaseLineData();
*num_targets = 5;
*targets = new Atom[ *num_targets ];
(*targets)[1] = XFE_DragBase::_XA_NETSCAPE_URL;
(*targets)[2] = XA_STRING;
if (isDisplayingNews())
(*targets)[0] = XFE_OutlinerDrop::_XA_NETSCAPE_NEWS_MESSAGE;
else
(*targets)[0] = XFE_OutlinerDrop::_XA_NETSCAPE_MAIL_MESSAGE;
}
}
void
XFE_ThreadView::getDragTargets(void *this_ptr,
int row,
int column,
Atom **targets,
int *num_targets)
{
D(printf("XFE_ThreadView::getDragTargets()\n");)
XFE_ThreadView *thread_view = (XFE_ThreadView*)this_ptr;
thread_view->GetDragTargets(row, column, targets, num_targets);
}
char *
XFE_ThreadView::DragConvert(Atom atom)
{
if (atom == XFE_DragBase::_XA_NETSCAPE_URL)
{
// translate drag data to NetscapeURL format
XFE_URLDesktopType urlData;
char *result;
const int *selection;
int count;
int i;
m_outliner->getSelection(&selection, &count);
urlData.createItemList(count);
for (i = 0; i < count; i ++)
{
MessageKey key = MSG_GetMessageKey(m_pane, selection[i]);
URL_Struct *url = MSG_ConstructUrlForMessage(m_pane,
key);
urlData.url(i,url->address);
NET_FreeURLStruct(url);
}
result = XtNewString(urlData.getString());
return result;
}
else if (atom == XFE_OutlinerDrop::_XA_NETSCAPE_MAIL_MESSAGE
|| atom == XFE_OutlinerDrop::_XA_NETSCAPE_NEWS_MESSAGE)
{
char result[100];
const int *selection;
int count;
m_outliner->getSelection(&selection, &count);
if (count < 1) return XtNewString("0"); /* XXX ? */
sprintf (result, "%d", selection[0]);
return (char*)XtNewString(result); /* XXX fixme */
}
else if (atom == XA_STRING)
{
#if notyet
char *result;
URL_Struct *url = MSG_ConstructUrlForMessage(m_pane,
m_dragmessage);
result = XtNewString(url->address);
NET_FreeURLStruct(url);
return result;
#endif
}
}
char *
XFE_ThreadView::dragConvert(void *this_ptr,
Atom atom)
{
XFE_ThreadView *thread_view = (XFE_ThreadView*)this_ptr;
return thread_view->DragConvert(atom);
}
#endif /* USE_MOTIF_DND */
void
XFE_ThreadView::selectThread()
{
const int *selected;
int i,count;
MessageKey *keys;
m_outliner->getSelection(&selected, &count);
if ( count <= 0 ) return;
keys = new MessageKey[count];
for ( i = 0; i < count ; i++ )
{
keys[i] = MSG_GetMessageKey(m_pane, selected[i]);
}
m_outliner->deselectAllItems();
for ( i = 0; i < count; i++ )
{
MSG_ViewIndex index = MSG_ThreadIndexOfMsg( m_pane, keys[ i ] );
int delta = MSG_ExpansionDelta(m_pane, index);
if ( delta > 0 )
MSG_ToggleExpansion(m_pane, index, NULL);
else
delta = -delta;
m_outliner->selectRangeByIndices(index, index+delta);
}
delete[] keys;
showMessage(-1);
}
Reference in New Issue View Git Blame Copy Permalink