static void
formatUnknownContentLength(char* buf, PRUint32 len, PRUint32 bytesReceived, PRUint32 elapsed)
{
char rate[32];
*rate = 0;
// the transfer rate
double bytes_per_sec = 0;
if (elapsed > 0)
bytes_per_sec = ((double) bytesReceived) / ((double) elapsed);
formatRate(rate, sizeof(rate), bytes_per_sec);
// the number of bytes received
char bytes_received[32];
if (bytesReceived < KILOBYTE)
PR_snprintf(bytes_received, sizeof(bytes_received),
XP_GetString(XP_THERMO_UH),
bytesReceived, IS_PLURAL(bytesReceived));
else
PR_snprintf(bytes_received, sizeof(bytes_received),
XP_GetString(XP_THERMO_KBYTE_FORMAT),
bytesReceived / KILOBYTE);
if (*rate) {
/* "%s read (at %s)" */
PR_snprintf(buf, len, XP_GetString(XP_THERMO_PERCENT_RATE_FORM), bytes_received, rate);
}
else {
PR_snprintf(buf, len, XP_GetString(XP_THERMO_RAW_COUNT_FORM), bytes_received);
}
}
static void
fe_movemail_perror(const char *message)
{
int e = errno;
char *es = 0;
char *buf1 = 0;
char buf2[512];
char *suffix;
int L;
if ((unsigned)e < (unsigned)sys_nerr)
{
es = sys_errlist [e];
}
else
{
snprintf (buf2, sizeof (buf2), XP_GetString( XFE_UNKNOWN_ERROR_CODE ),
errno);
printf("XFE_UNKNOWN_ERROR_CODE\n");
es = buf2;
}
suffix = XP_GetString(XFE_MOVEMAIL_FAILURE_SUFFIX);
printf("XFE_MOVEMAIL_FAILURE_SUFFIX\n");
if(!suffix) suffix = "";
if(!message) message = "";
L = strlen(message) + strlen(es) + strlen(suffix) + 40;
buf1 = (char *) malloc(L);
if(!buf1) return;
snprintf (buf1, L-1, "%s\n%s\n\n%s", message, es, suffix);
#if 0
FE_Alert (buf1);
#endif
free(buf1);
}
PR_END_EXTERN_C
#endif // XP_MAC
#define KILOBYTE (1024L)
#define MINUTE (60L)
#define HOUR (MINUTE * MINUTE)
#define IS_PLURAL(x) (((x) == 1) ? "" : XP_GetString(XP_THERMO_PLURAL_FORMAT)) /* L10N? */
#define ENOUGH_TIME_TO_GUESS 10 /* in seconds */
#define TIME_UNTIL_DETAILS 5
////////////////////////////////////////////////////////////////////////
static void
formatRate(char* buf, PRUint32 len, double bytes_per_sec)
{
if (bytes_per_sec > 0) {
if (bytes_per_sec < KILOBYTE)
PR_snprintf(buf, len, XP_GetString(XP_THERMO_BYTE_RATE_FORMAT),
(PRUint32) bytes_per_sec);
else
PR_snprintf(buf, len, XP_GetString(XP_THERMO_K_RATE_FORMAT),
(bytes_per_sec / ((double) KILOBYTE)));
}
}
static void
fe_movemail_perror(MWContext *context, const char *message)
{
int e = errno;
char *es = 0;
char *buf1 = 0;
char buf2[512];
char *suffix;
int L;
XP_ASSERT(context);
if (!context) return;
if ((unsigned)e < (unsigned)sys_nerr)
{
es = sys_errlist [e];
}
else
{
PR_snprintf (buf2, sizeof (buf2), XP_GetString( XFE_UNKNOWN_ERROR_CODE ),
errno);
es = buf2;
}
suffix = XP_GetString(XFE_MOVEMAIL_FAILURE_SUFFIX);
if(!suffix) suffix = "";
if(!message) message = "";
L = XP_STRLEN(message) + XP_STRLEN(es) + XP_STRLEN(suffix) + 40;
buf1 = (char *) XP_ALLOC(L);
if(!buf1) return;
PR_snprintf (buf1, L-1, "%s\n%s\n\n%s", message, es, suffix);
FE_Alert (context, buf1);
XP_FREE(buf1);
}
XFE_HistoryFrame::XFE_HistoryFrame(Widget toplevel, XFE_Frame *parent_frame, Chrome *chromespec)
: XFE_Frame("history", toplevel, parent_frame,
FRAME_HISTORY, chromespec, False, True, False, True, False)
{
// create the History view
XFE_HistoryView *view = new XFE_HistoryView(this, getViewParent(), NULL, m_context);
setView(view);
XtVaSetValues(view->getBaseWidget(),
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
setMenubar(menu_bar_spec);
//
// Make the bookmark frame title more reasonable
//
char title[kMaxFullNameLength+64];
PR_snprintf(title,
sizeof(title),
XP_GetString(XFE_HISTORY_FRAME_TITLE),
FE_UsersFullName());
setTitle(title);
view->show();
m_dashboard->setShowStatusBar(True);
m_dashboard->setShowProgressBar(True);
}
/*
* NativePickDefaultDirectory
* Platform-specific implementation of GetDirectoryPath
*/
char* nsFolderSpec::NativePickDefaultDirectory(void)
{
su_PickDirTimer callback;
char * packageName;
char prompt[200];
callback.context = XP_FindSomeContext();
callback.fileName = NULL;
callback.done = FALSE;
/* Get the name of the package to prompt for */
packageName = userPackageName;
if (packageName)
{
/* In Java thread now, and need to call FE_PromptForFileName
* from the main thread
* post an event on a timer, and busy-wait until it completes.
*/
PR_snprintf(prompt, 200, XP_GetString(SU_INSTALL_ASK_FOR_DIRECTORY), packageName);
callback.prompt = prompt;
FE_SetTimeout( pickDirectoryCallback, &callback, 1 );
while (!callback.done) /* Busy loop for now */
PR_Sleep(PR_INTERVAL_NO_WAIT); /* java_lang_Thread_yield(WHAT?); */
}
return callback.fileName;
}
char * SU_GetErrorMsg1(int id, char* arg1)
{
char* errorMsg;
char* tag = XP_GetString(id);
PR_ASSERT(tag != NULL);
errorMsg = XP_Cat(tag, arg1);
return errorMsg;
}
NSAPI_PUBLIC
const char *
XP_GetStringFromDatabase(const char *strLibraryName,
const char *strLanguage,
int iToken)
{
return XP_GetString(strLibraryName, XP_LANGUAGE_AUDIENCE_DEFAULT, iToken);
}
void prefsProxiesViewCb_ok(Widget w,
XtPointer closure,
XtPointer callData)
{
XFE_PrefsProxiesViewDialog *theDialog = (XFE_PrefsProxiesViewDialog *)closure;
PrefsDataProxiesView *fep = theDialog->m_prefsDataProxiesView;
XP_ASSERT(fep);
if (! theDialog->verifyPage()) return;
char *s1;
char *s2;
PREFS_SET_GLOBALPREF_TEXT(no_proxy, no_proxy_text);
#define SNARFP(NAME,SUFFIX,empty_port_ok) \
{ \
s1 = fe_GetTextField(fep->NAME##_##SUFFIX##_text); \
s2 = fe_GetTextField(fep->NAME##_port_text); \
if (*s1 && (*s2 || empty_port_ok)) { \
fe_globalPrefs.NAME##_##SUFFIX = strdup(s1); \
fe_globalPrefs.NAME##_##SUFFIX##_port = *s2 ? atoi(s2) : 0; \
} else { \
fe_globalPrefs.NAME##_##SUFFIX = strdup(""); \
fe_globalPrefs.NAME##_##SUFFIX##_port = 0; \
} \
if (s1) XtFree(s1); \
if (s2) XtFree(s2); \
}
SNARFP (ftp, proxy, False);
SNARFP (gopher, proxy, False);
SNARFP (http, proxy, False);
#ifndef NO_SECURITY
SNARFP (https, proxy, False);
#endif
SNARFP (wais, proxy, False);
SNARFP (socks, host, True);
#undef SNARFP
// Install changes
theDialog->installChanges();
// Simulate a cancel
prefsProxiesViewCb_cancel(w, closure, callData);
// Save the preferences at the end, so that if we've found some setting that
// crashes, it won't get saved...
if (!fe_CheckVersionAndSavePrefs((char *) fe_globalData.user_prefs_file, &fe_globalPrefs))
fe_perror (theDialog->getContext(), XP_GetString( XFE_ERROR_SAVING_OPTIONS));
}
void
XFE_MailDownloadView::startNewsDownload()
{
XmString xmstr = XmStringCreate(XP_GetString(XFE_DOWNLOADING_NEW_MESSAGES), XmFONTLIST_DEFAULT_TAG);
XtVaSetValues(m_label, XmNlabelString, xmstr, 0);
XmStringFree(xmstr);
XFE_MozillaApp::theApp()->notifyInterested(XFE_MNView::MNChromeNeedsUpdating);
MSG_Command (m_pane, MSG_GetNextChunkMessages, NULL, 0);
}
char *XFE_ABDirListView::getColumnHeaderText(int column)
{
char *tmp = 0;
switch (column) {
case OUTLINER_COLUMN_NAME:
tmp = XP_GetString(XFE_AB2PANE_DIR_HEADER);
break;
}/* switch () */
return tmp;
}
char * SU_GetErrorMsg4(int id, int reason)
{
char* msg;
char* ptr;
char* tag = XP_GetString(id);
PR_ASSERT(tag != NULL);
ptr = PR_sprintf_append(msg, "%s %d", tag, reason);
msg = XP_STRDUP(ptr);
delete ptr;
return msg;
}
char * SU_GetString2(int id, nsString* arg1)
{
char* msg=NULL;
char* tag = XP_GetString(id);
PR_ASSERT(tag != NULL);
char* argMsg = "";
if (arg1)
argMsg = arg1->ToNewCString();
msg = XP_Cat(msg, tag, argMsg);
delete argMsg;
return msg;
}
char * SU_GetString1(int id, char* arg1)
{
char* msg=NULL;
char* tag = XP_GetString(id);
PR_ASSERT(tag != NULL);
if (arg1) {
msg = XP_Cat(msg, tag, arg1);
} else {
msg = XP_Cat(msg, tag);
}
return msg;
}
void
XFE_MailDownloadView::cleanUpNews()
{
// Change the label string, since we're not actually downloading:
XmString xmstr = XmStringCreate(XP_GetString(XFE_PURGING_NEWS_MESSAGES),
XmFONTLIST_DEFAULT_TAG);
XtVaSetValues(m_label, XmNlabelString, xmstr, 0);
XmStringFree(xmstr);
XFE_MozillaApp::theApp()->notifyInterested(XFE_MNView::MNChromeNeedsUpdating);
MSG_CleanupFolders(m_pane);
}
char * SU_GetErrorMsg2(int id, nsString* arg1, int reason)
{
char* errorMsg;
char* ptr;
char* tag = XP_GetString(id);
PR_ASSERT(tag != NULL);
char* argMsg = "";
if (argMsg)
argMsg = arg1->ToNewCString();
ptr = PR_sprintf_append(errorMsg, "%s %s %d", tag, argMsg, reason);
delete argMsg;
errorMsg = XP_STRDUP(ptr);
delete ptr;
return errorMsg;
}
int XFE_ComposeAttachFolderView::verifySafeToAttach()
{
#if 0
// this check is no longer needed - back end can handle
// multiple simultaneous attachment operations
if (MSG_DeliveryInProgress(getPane())) {
char *msg=PR_smprintf(XP_GetString(XFE_MN_DELIVERY_IN_PROGRESS));
if (msg) {
fe_Alert_2(getBaseWidget(),msg);
XP_FREE(msg);
}
return FALSE;
}
#endif
return TRUE;
}
XFE_PropertyTabView::XFE_PropertyTabView(XFE_Component *top,
XFE_View *view, /* the parent view */
int tab_string_id): XFE_View(top, view)
{
m_labelWidth = 0;
/* Create tab
*/
XmString xmstr;
xmstr = XmStringCreate(XP_GetString(tab_string_id ),
XmFONTLIST_DEFAULT_TAG);
Widget form = XmLFolderAddTabForm(view->getBaseWidget(), xmstr);
XmStringFree(xmstr);
setBaseWidget(form);
}
Boolean XFE_PrefsProxiesViewDialog::verifyPage()
{
char buf[10000];
char *buf2;
char *warning;
int size;
buf2 = buf;
strcpy (buf, XP_GetString(XFE_WARNING));
buf2 = buf + strlen (buf);
warning = buf2;
size = buf + sizeof (buf) - warning;
XP_ASSERT(m_prefsDataProxiesView);
PrefsDataProxiesView *fep = m_prefsDataProxiesView;
PREFS_CHECK_PROXY (fep->ftp_proxy_text, fep->ftp_port_text,
XP_GetString(XFE_FTP_PROXY_HOST),
True, warning, size);
PREFS_CHECK_PROXY (fep->gopher_proxy_text,fep->gopher_port_text,
XP_GetString(XFE_GOPHER_PROXY_HOST),
True, warning, size);
PREFS_CHECK_PROXY (fep->http_proxy_text, fep->http_port_text,
XP_GetString(XFE_HTTP_PROXY_HOST),
True, warning, size);
PREFS_CHECK_PROXY (fep->https_proxy_text, fep->https_port_text,
XP_GetString(XFE_HTTPS_PROXY_HOST),
True, warning, size);
PREFS_CHECK_PROXY (fep->wais_proxy_text, fep->wais_port_text,
XP_GetString(XFE_WAIS_PROXY_HOST),
True, warning, size);
PREFS_CHECK_PROXY (fep->socks_host_text, fep->socks_port_text,
XP_GetString(XFE_SOCKS_HOST),
False, warning, size);
if (*buf2) {
FE_Alert (m_prefsDialog->getContext(), fe_StringTrim (buf));
return FALSE;
}
else {
return TRUE;
}
}
void XFE_PrefsDiskMoreDialog::prefsDiskMoreCb_ok(Widget w,
XtPointer closure,
XtPointer callData)
{
XFE_PrefsDiskMoreDialog *theDialog = (XFE_PrefsDiskMoreDialog *)closure;
PrefsDataDiskMore *fep = theDialog->m_prefsDataDiskMore;
XP_ASSERT(fep);
if (! theDialog->verifyPage()) return;
Boolean b;
char c;
char *s = 0;
int n;
XtVaGetValues(fep->rm_msg_body_toggle, XmNset, &b, 0);
fe_globalPrefs.news_remove_bodies_by_age = b;
XtVaGetValues(fep->num_days_text, XmNvalue, &s, 0);
fe_globalPrefs.news_remove_bodies_days = 0;
if (1 == sscanf (s, " %d %c", &n, &c))
fe_globalPrefs.news_remove_bodies_days = n;
// Simulate a cancel
prefsDiskMoreCb_cancel(w, closure, callData);
// Install preferences
theDialog->installChanges();
// Save the preferences at the end, so that if we've found some
// setting that crashes, it won't get saved...
if (! fe_CheckVersionAndSavePrefs((char *) fe_globalData.user_prefs_file, &fe_globalPrefs))
fe_perror (theDialog->getContext(), XP_GetString( XFE_ERROR_SAVING_OPTIONS));
}
BOOL CChooseFolderDialog::OnInitDialog()
{
BOOL ret = CDialog::OnInitDialog();
if (m_nTypeID == TYPE_SENTNEWS)
SetDlgItemText(IDC_STATIC_TITLE, szLoadString(IDS_COPY_NEWS_MSG));
else if (m_nTypeID == TYPE_DRAFT)
SetDlgItemText(IDC_STATIC_TITLE, szLoadString(IDS_COPY_DRAFTS));
else if (m_nTypeID == TYPE_TEMPLATE)
SetDlgItemText(IDC_STATIC_TITLE, szLoadString(IDS_COPY_TEMPLATES));
CString formatString, defaultTitle;
formatString.LoadString(IDS_SPECIAL_FOLDER);
defaultTitle.Format(LPCTSTR(formatString), XP_GetString(m_nDefaultID));
SetDlgItemText(IDC_RADIO_SENT, LPCTSTR(defaultTitle));
if ( ret ) {
// Subclass Server combo
m_ServerCombo.SubclassDlgItem( IDC_COMBO_SERVERS, this );
m_ServerCombo.NoPrettyName();
m_ServerCombo.PopulateMailServer( WFE_MSGGetMaster() );
if (SetServerComboCurSel(m_ServerCombo.GetSafeHwnd(),
m_pFolderPath, m_nDefaultID))
CheckDlgButton(IDC_RADIO_SENT, TRUE);
else
CheckDlgButton(IDC_RADIO_OTHER, TRUE);
// Subclass folder combo
m_FolderCombo.SubclassDlgItem( IDC_COMBO_FOLDERS, this );
m_FolderCombo.PopulateMail( WFE_MSGGetMaster() );
SetFolderComboCurSel(m_FolderCombo.GetSafeHwnd(),
m_pFolderPath, m_nDefaultID);
}
return ret;
}
//-----------------------------------------------------------------------------
// NetStream
//-----------------------------------------------------------------------------
CStreamOutNet::CStreamOutNet( MWContext* pContext )
{
URL_Struct * URL_s;
Chrome chrome;
XP_BZERO( &chrome, sizeof( Chrome ) );
chrome.allow_close = TRUE;
chrome.allow_resize = TRUE;
chrome.show_scrollbar = TRUE;
#ifndef XP_WIN
// NOTE: need to verify this change on XP_WIN and remove the
// ifndef... [ works on XP_UNIX & XP_MAC ]
//
chrome.type = MWContextDialog;
#endif
//
// LTNOTE: Ownership of the 'chrome' struct isn't documented in the interface.
// The windows implementation doesn't appear to keep pointers to the struct.
//
MWContext *pNewContext = FE_MakeNewWindow(pContext, NULL, "view-source",
&chrome );
pNewContext->edit_view_source_hack = TRUE;
URL_s = NET_CreateURLStruct(XP_GetString(EDT_VIEW_SOURCE_WINDOW_TITLE), NET_DONT_RELOAD);
URL_s->content_type = XP_STRDUP(TEXT_PLAIN);
m_pStream = NET_StreamBuilder(FO_PRESENT, URL_s, pNewContext);
if(!m_pStream){
XP_ASSERT( FALSE );
m_status = EOS_FileError;
}
m_status = EOS_NoError;
}
char*
XFE_AddrBookView::getColumnName(int column)
{
switch (column) {
case OUTLINER_COLUMN_TYPE:
return XP_GetString(XFE_AB_HEADER_NAME);
case OUTLINER_COLUMN_NAME:
return XP_GetString(XFE_AB_HEADER_NAME);
case OUTLINER_COLUMN_EMAIL:
return XP_GetString(XFE_AB_HEADER_EMAIL);
case OUTLINER_COLUMN_PHONE:
return XP_GetString(XFE_AB_HEADER_PHONE);
case OUTLINER_COLUMN_NICKNAME:
return XP_GetString(XFE_AB_HEADER_NICKNAME);
case OUTLINER_COLUMN_COMPANY:
return XP_GetString(XFE_AB_HEADER_COMPANY);
case OUTLINER_COLUMN_LOCALITY:
return XP_GetString(XFE_AB_HEADER_LOCALITY);
default:
XP_ASSERT(0);
return 0;
}
}
/* Returns the text and/or icon to display at the top of the column.
*/
char*
XFE_AddrBookView::getColumnHeaderText(int column)
{
char *tmp = 0;
switch (column) {
case OUTLINER_COLUMN_TYPE:
tmp = XP_STRDUP(" ");
break;
case OUTLINER_COLUMN_NAME:
tmp = XP_GetString(XFE_AB_HEADER_NAME);
break;
case OUTLINER_COLUMN_NICKNAME:
tmp = XP_GetString(XFE_AB_HEADER_NICKNAME);
break;
case OUTLINER_COLUMN_EMAIL:
tmp = XP_GetString(XFE_AB_HEADER_EMAIL);
break;
case OUTLINER_COLUMN_PHONE:
tmp = XP_GetString(XFE_AB_HEADER_PHONE);
break;
case OUTLINER_COLUMN_COMPANY:
tmp = XP_GetString(XFE_AB_HEADER_COMPANY);
break;
case OUTLINER_COLUMN_LOCALITY:
tmp = XP_GetString(XFE_AB_HEADER_LOCALITY);
break;
}/* switch () */
return tmp;
}
/*
* This function takes an error code and associated error data
* and creates a string containing a textual description of
* what the error is and why it happened.
*
* The returned string is allocated and thus should be freed
* once it has been used.
*/
PUBLIC char *
NET_ExplainErrorDetails (int code, ...)
{
va_list args;
char *msg = 0;
int sub_error;
va_start (args, code);
if (IS_SSL_ERROR(code) || IS_SEC_ERROR(code)) {
const char *s = XP_GetString(code);
msg = (s ? XP_STRDUP(s) : 0);
}
if (!msg)
switch(code) {
case MK_INTERRUPTED:
case MK_USE_FTP_INSTEAD:
case MK_USE_COPY_FROM_CACHE:
case MK_MAILTO_NOT_READY:
case MK_UNABLE_TO_LOGIN:
case MK_UNABLE_TO_CONVERT:
case MK_IMAGE_LOSSAGE: /* image library generic error */
case MK_ERROR_SENDING_DATA_COMMAND:
case MK_OFFLINE:
msg = NULL;
break;
case MK_REDIRECT_ATTEMPT_NOT_ALLOWED:
case MK_SERVER_TIMEOUT:
case MK_CONNECTION_TIMED_OUT:
case MK_OUT_OF_MEMORY:
case MK_TIMEBOMB_URL_PROHIBIT:
case MK_TIMEBOMB_MESSAGE:
case MK_RELATIVE_TIMEBOMB_MESSAGE:
case MK_NO_WAIS_PROXY:
case MK_CREATING_NEWSRC_FILE:
case MK_NNTP_SERVER_NOT_CONFIGURED:
case MK_NNTP_NEWSGROUP_SCAN_ERROR:
case MK_ZERO_LENGTH_FILE:
case MK_BAD_CONNECT:
case MK_UNABLE_TO_USE_PASV_FTP:
case MK_UNABLE_TO_CHANGE_FTP_MODE:
case MK_UNABLE_TO_FTP_CWD:
case MK_UNABLE_TO_SEND_PORT_COMMAND:
case MK_UNABLE_TO_ACCEPT_SOCKET:
case MK_UNABLE_TO_CONNECT2:
case MK_BAD_NNTP_CONNECTION:
case MK_NNTP_SERVER_ERROR:
case MK_SERVER_DISCONNECTED:
case MK_NEWS_ITEM_UNAVAILABLE:
case MK_UNABLE_TO_OPEN_NEWSRC:
case MK_COULD_NOT_LOGIN_TO_SMTP_SERVER:
case MK_MSG_NO_SMTP_HOST:
case MK_COULD_NOT_GET_USERS_MAIL_ADDRESS:
case MK_UNABLE_TO_CONNECT_TO_PROXY:
case MK_UNABLE_TO_LOCATE_PROXY:
case MK_DISK_FULL:
case MK_PRINT_LOSSAGE:
case MK_SECURE_NEWS_PROXY_ERROR:
case MK_SIGNATURE_TOO_LONG:
case MK_SIGNATURE_TOO_WIDE:
case MK_POP3_SERVER_ERROR:
case MK_POP3_USERNAME_UNDEFINED:
case MK_POP3_PASSWORD_UNDEFINED:
case MK_POP3_USERNAME_FAILURE:
case MK_POP3_PASSWORD_FAILURE:
case MK_POP3_NO_MESSAGES:
case MK_POP3_LIST_FAILURE:
case MK_POP3_LAST_FAILURE:
case MK_POP3_RETR_FAILURE:
case MK_POP3_DELE_FAILURE:
case MK_POP3_OUT_OF_DISK_SPACE:
case MK_POP3_MESSAGE_WRITE_ERROR:
case MK_MIME_NO_SENDER:
case MK_MIME_NO_RECIPIENTS:
case MK_MIME_NO_SUBJECT:
case MK_MIME_ERROR_WRITING_FILE:
case MK_MIME_MULTIPART_BLURB:
case MK_MSG_CANT_COPY_TO_SAME_FOLDER:
case MK_MSG_CANT_COPY_TO_QUEUE_FOLDER:
case MK_MSG_CANT_COPY_TO_QUEUE_FOLDER_OLD:
case MK_MSG_CANT_COPY_TO_DRAFTS_FOLDER:
case MK_MSG_CANT_CREATE_FOLDER:
case MK_MSG_FOLDER_ALREADY_EXISTS:
case MK_MSG_FOLDER_NOT_EMPTY:
case MK_MSG_CANT_DELETE_FOLDER:
case MK_MSG_CANT_CREATE_INBOX:
case MK_MSG_CANT_CREATE_MAIL_DIR:
case MK_MSG_NO_POP_HOST:
case MK_MSG_MESSAGE_CANCELLED:
case MK_MSG_FOLDER_UNREADABLE:
case MK_MSG_FOLDER_SUMMARY_UNREADABLE:
case MK_MSG_TMP_FOLDER_UNWRITABLE:
case MK_MSG_ID_NOT_IN_FOLDER:
case MK_MSG_NEWSRC_UNPARSABLE:
case MK_MSG_NO_RETURN_ADDRESS:
case MK_MSG_ERROR_WRITING_NEWSRC:
case MK_MSG_ERROR_WRITING_MAIL_FOLDER:
case MK_MSG_SEARCH_FAILED:
case MK_MSG_FOLDER_BUSY:
msg = XP_STRDUP(XP_GetString(code));
break;
case MK_TCP_READ_ERROR:
case MK_TCP_WRITE_ERROR:
case MK_UNABLE_TO_CREATE_SOCKET:
case MK_UNABLE_TO_CONNECT:
case MK_HTTP_TYPE_CONFLICT:
case MK_TCP_ERROR:
sub_error = va_arg(args, int);
if (IS_SSL_ERROR(sub_error) || IS_SEC_ERROR(sub_error)) {
/*
* For SSL/SEC errors, use the message without a wrapper.
*/
msg = XP_STRDUP(XP_GetString(sub_error));
} else if (code == MK_UNABLE_TO_CONNECT &&
(sub_error == XP_ERRNO_EINVAL
|| sub_error == XP_ERRNO_EADDRINUSE)) {
/*
* With unable-to-connect errors, some errno values/strings
* are not more helpful, so just use a plain message for these.
*/
msg = XP_STRDUP(XP_GetString(MK_UNABLE_TO_CONNECT2));
} else {
msg = PR_smprintf(XP_GetString(code), XP_GetString(sub_error));
}
break;
case MK_MALFORMED_URL_ERROR:
case MK_COULD_NOT_PUT_FILE:
case MK_UNABLE_TO_LOCATE_FILE:
case MK_NNTP_AUTH_FAILED:
case MK_UNABLE_TO_LOCATE_HOST:
case MK_UNABLE_TO_LOCATE_SOCKS_HOST:
case MK_UNABLE_TO_OPEN_FILE:
case MK_UNABLE_TO_OPEN_TMP_FILE:
case MK_CONNECTION_REFUSED:
case MK_NNTP_ERROR_MESSAGE:
case MK_MSG_COULDNT_OPEN_FCC_FILE:
case MK_TIMEBOMB_WARNING_MESSAGE:
case MK_RELATIVE_TIMEBOMB_WARNING_MESSAGE:
case MK_ERROR_SENDING_FROM_COMMAND:
case MK_ERROR_SENDING_RCPT_COMMAND:
case MK_ERROR_SENDING_MESSAGE:
case MK_SMTP_SERVER_ERROR:
msg = PR_vsmprintf(XP_GetString(code), args);
break;
case -1:
default:
msg = PR_smprintf(XP_GetString(MK_COMMUNICATIONS_ERROR), code);
break;
}
va_end (args);
TRACEMSG(("NET_ExplainErrorDetails generated: %s", msg ? msg : "(none)"));
return(msg);
}
char *XFE_ABDirListView::getColumnName(int /* column */)
{
return XP_GetString(XFE_AB_HEADER_NAME);
}
XFE_MailDownloadView::XFE_MailDownloadView(XFE_Component *toplevel_component,
Widget parent,
XFE_View *parent_view,
MWContext *context,
MSG_Pane *parent_pane,
MSG_Pane *p)
: XFE_MNView(toplevel_component, parent_view, context, p)
{
Widget form;
XmString xmstr = XmStringCreate(XP_GetString(XFE_DOWNLOADING_NEW_MESSAGES), XmFONTLIST_DEFAULT_TAG);
XmFontList fontList;
form = XtCreateWidget("topArea",
xmFormWidgetClass,
parent,
NULL, 0);
m_label = XtVaCreateManagedWidget("label",
xmLabelWidgetClass,
form,
XmNlabelString, xmstr,
NULL);
m_logo = new XFE_Logo((XFE_Frame*)toplevel_component, form, "logo");
XtVaGetValues(m_label,
XmNfontList, &fontList,
NULL);
// we need more space, or else the window is *tiny*
XtVaSetValues(m_label,
XmNwidth, XmStringWidth(fontList, xmstr) * 2,
NULL);
XmStringFree(xmstr);
/* now do the attachments. */
XtVaSetValues(m_label,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, m_logo->getBaseWidget(),
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, m_logo->getBaseWidget(),
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, m_logo->getBaseWidget(),
NULL);
XtVaSetValues(m_logo->getBaseWidget(),
XmNleftAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
XmNtopAttachment, XmATTACH_FORM,
NULL);
m_logo->show();
if (!p)
setPane(MSG_CreateProgressPane(m_contextData, XFE_MNView::getMaster(), parent_pane));
setBaseWidget(form);
}
void XFE_AddrBookView::abCall()
{
int count = 0;
const int *indices = 0;
m_outliner->getSelection(&indices, &count);
if (count > 0 && indices) {
#if defined(USE_ABCOM)
#else
/* Take the first one
*/
ABID type;
ABID entry;
entry = AB_GetEntryIDAt((AddressPane *) m_abPane, (uint32) indices[0]);
if (entry == MSG_VIEWINDEXNONE)
return;
AB_GetType(m_dir, m_AddrBook, entry, &type);
/* Select
*/
if (type != ABTypePerson)
return;
char a_line[AB_MAX_STRLEN];
a_line[0] = '\0';
char cmdstr[AB_MAX_STRLEN];
cmdstr[0] = '\0';
char *email= NULL;
if ((AB_GetEmailAddress(m_dir, m_AddrBook, entry, a_line) != MSG_VIEWINDEXNONE)&&
XP_STRLEN(a_line))
email = XP_STRDUP(a_line);
else {
/* Can not call w/o email
*/
// Prompt the user to enter the email address
char tmp[128];
XP_SAFE_SPRINTF(tmp, sizeof(tmp),
"%s",
XP_GetString(MK_MSG_CALL_NEEDS_EMAILADDRESS));
fe_Message(m_contextData, tmp);
return;
}/* else */
char *coolAddr = NULL;
if (AB_GetCoolAddress(m_dir, m_AddrBook, entry, a_line) != MSG_VIEWINDEXNONE)
coolAddr = XP_STRDUP(a_line);
short use;
if (AB_GetUseServer(m_dir, m_AddrBook, entry, &use) == MSG_VIEWINDEXNONE)
/* Can't determine which mode; use default
*/
use = kDefaultDLS;
if (email && XP_STRLEN(email))
fe_showConference(getBaseWidget(), email, use, coolAddr);
else {
/* prompt user to enter email address for this person
*/
char tmp[128];
XP_SAFE_SPRINTF(tmp, sizeof(tmp),
"%s",
XP_GetString(MK_MSG_CALL_NEEDS_EMAILADDRESS));
fe_Message(m_contextData, tmp);
}/* else */
if (email)
XP_FREE((char *) email);
if (coolAddr)
XP_FREE((char *) coolAddr);
#endif /* USE_ABCOM */
}/* if */
}
// tooltips and doc string
char *XFE_AddrBookView::getDocString(CommandType cmd)
{
uint32 count = 0;
const int *indices = 0;
m_outliner->getSelection(&indices, (int *) &count);
if (count > 0) {
char *names = 0;
char a_line[512];
a_line[0] = '\0';
int len = 0;
for (int i=0; i < count && len < 512; i++) {
/* Take the first one
*/
#if defined(USE_ABCOM)
AB_AttributeValue *value = NULL;
int error =
AB_GetEntryAttributeForPane(m_pane,
(MSG_ViewIndex) indices[i],
AB_attribFullName,
&value);
XP_ASSERT(value && value->attrib == AB_attribFullName);
XP_SAFE_SPRINTF(a_line, sizeof(a_line),
"%s",
value->u.string?value->u.string:"");
AB_FreeEntryAttributeValue(value);
#else
ABID entry;
entry = AB_GetEntryIDAt((AddressPane *) m_abPane,
(uint32) indices[i]);
AB_GetFullName(m_dir, m_AddrBook, entry, a_line);
#endif /* USE_ABCOM */
if (a_line) {
len += XP_STRLEN(a_line);
if (i)
len += 2;
names = names?
((char *) XP_REALLOC(names, (len+1)*sizeof(char))):
((char *) XP_CALLOC(1+len, sizeof(char)));
if (i)
names = XP_STRCAT(names, ", ");
names = XP_STRCAT(names, a_line);
}/* if */
}/* for i */
char *cstr = 0;
if (cmd == xfeCmdComposeMessage ||
cmd == xfeCmdComposeMessageHTML ||
cmd == xfeCmdComposeMessagePlain) {
cstr = XP_STRDUP(XP_GetString(XFE_SEND_MSG_TO));
} else if (cmd == xfeCmdABCall) {
cstr = XP_STRDUP(XP_GetString(XFE_PLACE_CONFERENCE_CALL_TO));
}
len += XP_STRLEN(cstr);
cstr = (char *) XP_REALLOC(cstr, (1+len)*sizeof(char));
cstr = (char *) XP_STRCAT(cstr, names);
return cstr;
}/* if */
return NULL;
}
char * SU_GetString(int id)
{
char *str = XP_GetString(id);
PR_ASSERT(str != NULL);
return XP_STRDUP(str);
}
