unsigned char
save_config(char *filename) {
register FILE *fp;
char dt_stamp[50];
time_t cur_time = time(NULL);
struct tm *cur_tm;
const char format[] = "%s/notgame.cfg";
cur_tm = localtime(&cur_time);
if (!filename) {
filename = (char *) malloc(strlen(getenv("HOME")) + sizeof(format));
sprintf(filename, format, getenv("HOME"));
}
if ((fp = fopen(filename, "w")) == NULL) {
save_dialog("Unable to write configuration file. Save failed!");
return (0);
}
strftime(dt_stamp, 50, "%x at %X", cur_tm);
fprintf(fp, "<" PACKAGE "-" VERSION ">\n");
fprintf(fp, "# Not Game Configuration File\n");
fprintf(fp, "# Automatically generated by " PACKAGE "-" VERSION " on %s\n\n", dt_stamp);
g_list_foreach(player_groups, (GFunc) save_player_group, (gpointer) fp);
g_list_foreach(dest_groups, (GFunc) save_dest_group, (gpointer) fp);
fclose(fp);
save_dialog("Configuration saved.");
return (1);
}
void CursesAttachmentDisplay::download(Attachment *a)
{
std::string name;
std::string filename;
CursesMessage::getDescriptionOf(a->mime, a->env, name, filename,
false);
{
SaveDialog save_dialog(filename);
save_dialog.requestFocus();
myServer::eventloop();
filename=save_dialog;
mainScreen->erase();
}
mainScreen->draw();
a->requestFocus();
if (messageInfoPtr.isDestroyed() || filename.size() == 0)
return;
downloadTo(messageInfoPtr, a->mime, filename);
}
void SyntaxHighlightingList::reload(QString i){
if(!m_issaved){
QMessageBox save_dialog(QMessageBox::Warning,"Jeu de couleur modifié","Le jeu de couleur "+m_current_file+"a été modifé. Voulez-vous l'enregistrer?",QMessageBox::Save|QMessageBox::Abort,this);
if(save_dialog.exec()==QMessageBox::Save) save();
}
// _lex = HighlightingThemeRegistry::get()->filterByLanguage(_lex.language()).value(i);
//on remplit le QListWidget
clear();
/*
foreach (HighlightingFormat format, _lex) {
QListWidgetItem* item =new QListWidgetItem(format.formatName(), this);
QFont f = item->font();
f.setBold(format.currentFormat().font().bold());
f.setItalic(format.currentFormat().font().bold());
f.setUnderline(format.currentFormat().font().bold());
item->setFont(f);
item->setForeground(format.currentFormat().foreground());
item->setBackground(format.currentFormat().background());
addItem(item);
}
*/
setCurrentRow(0);
m_issaved=true;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GError *error = NULL;
INIT_I18N ();
gegl_init (NULL, NULL);
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
gimp_get_data (SAVE_PROC, >mvals);
if (save_dialog (param[1].data.d_int32))
{
GeglBuffer *buffer;
buffer = gimp_drawable_get_buffer (param[2].data.d_int32);
if (save_image (param[3].data.d_string, buffer, &error))
{
gimp_set_data (SAVE_PROC, >mvals, sizeof (GTMValues));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
g_object_unref (buffer);
}
else
{
status = GIMP_PDB_CANCEL;
}
if (status != GIMP_PDB_SUCCESS && error)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_STRING;
values[1].data.d_string = error->message;
}
values[0].data.d_status = status;
}
static void action_save_as_cb(GtkAction *action, EDITOR *e)
{
const gchar *filename;
gboolean as_html;
GError *error = NULL;
if (save_dialog(GTKHTML_EDITOR(e->window), e) ==
GTK_RESPONSE_CANCEL)
return;
filename = gtkhtml_editor_get_filename(GTKHTML_EDITOR(e->window));
as_html = gtkhtml_editor_get_html_mode(GTKHTML_EDITOR(e->window));
gtkhtml_editor_save(GTKHTML_EDITOR(e->window), filename, as_html,
&error);
handle_error(&error);
}
static void _save_file(EDITOR *e)
{
const gchar *filename;
gboolean as_html;
GError *error = NULL;
if (gtkhtml_editor_get_filename(GTKHTML_EDITOR(e->window)) == NULL)
if (save_dialog(GTKHTML_EDITOR(e->window), e) ==
GTK_RESPONSE_CANCEL)
return;
filename = gtkhtml_editor_get_filename(GTKHTML_EDITOR(e->window));
as_html = gtkhtml_editor_get_html_mode(GTKHTML_EDITOR(e->window));
XI_message(("\n_save_file filename: %s\n", filename));
gtkhtml_editor_save(GTKHTML_EDITOR(e->window), filename, as_html,
&error);
handle_error(&error);
gtkhtml_editor_drop_undo(GTKHTML_EDITOR(e->window));
gtkhtml_editor_set_changed(GTKHTML_EDITOR(e->window), FALSE);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_ID;
gint32 drawable_ID;
INIT_I18N ();
run_mode = param[0].data.d_int32;
image_ID = param[1].data.d_image;
drawable_ID = param[2].data.d_drawable;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, PLUG_IN_PROC) == 0)
{
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
gimp_get_data (PLUG_IN_PROC, &mail_info);
{
gchar *filename = gimp_image_get_filename (image_ID);
if (filename)
{
gchar *basename = g_filename_display_basename (filename);
g_strlcpy (mail_info.filename, basename, BUFFER_SIZE);
g_free (basename);
g_free (filename);
}
}
if (! save_dialog ())
status = GIMP_PDB_CANCEL;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams < 8)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
g_strlcpy (mail_info.filename,
param[3].data.d_string, BUFFER_SIZE);
g_strlcpy (mail_info.receipt,
param[4].data.d_string, BUFFER_SIZE);
g_strlcpy (mail_info.from,
param[5].data.d_string, BUFFER_SIZE);
g_strlcpy (mail_info.subject,
param[6].data.d_string, BUFFER_SIZE);
g_strlcpy (mail_info.comment,
param[7].data.d_string, BUFFER_SIZE);
}
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &mail_info);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
status = save_image (mail_info.filename,
image_ID,
drawable_ID,
run_mode);
if (status == GIMP_PDB_SUCCESS)
{
if (mesg_body)
g_strlcpy (mail_info.comment, mesg_body, BUFFER_SIZE);
gimp_set_data (PLUG_IN_PROC, &mail_info, sizeof (m_info));
}
}
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
values[0].data.d_status = status;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[5];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
gint32 pc;
gint32 image_ID;
gint32 drawable_ID;
gint32 orig_image_ID;
GimpExportReturn export = GIMP_EXPORT_CANCEL;
GError *error = NULL;
INIT_I18N ();
gegl_init (NULL, NULL);
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, LOAD_PROC) == 0)
{
switch (run_mode)
{
case GIMP_RUN_NONINTERACTIVE:
/*
* check for valid parameters:
* (Or can I trust GIMP ?)
*/
if ((nparams < G_N_ELEMENTS (load_args) - 2) ||
(G_N_ELEMENTS (load_args) < nparams))
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
for (pc = 0; pc < G_N_ELEMENTS (load_args) - 2; pc++)
{
if (load_args[pc].type != param[pc].type)
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
}
for (pc = G_N_ELEMENTS (load_args) - 2; pc < nparams; pc++)
{
if (load_args[pc].type != param[pc].type)
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
}
to_frame = ((nparams < G_N_ELEMENTS (load_args) - 1) ?
1 : param[3].data.d_int32);
from_frame = ((nparams < G_N_ELEMENTS (load_args)) ?
-1 : param[4].data.d_int32);
image_ID = load_image (param[1].data.d_string,
from_frame, to_frame, &error);
if (image_ID != -1)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
break;
case GIMP_RUN_INTERACTIVE:
if (load_dialog (param[1].data.d_string))
{
image_ID = load_image (param[1].data.d_string,
from_frame, to_frame, &error);
if (image_ID != -1)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
else
{
status = GIMP_PDB_CANCEL;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
status = GIMP_PDB_CALLING_ERROR;
break;
}
}
else if (strcmp (name, SAVE_PROC) == 0)
{
image_ID = orig_image_ID = param[1].data.d_int32;
drawable_ID = param[2].data.d_int32;
switch (run_mode)
{
case GIMP_RUN_NONINTERACTIVE:
if (nparams != G_N_ELEMENTS (save_args))
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
for (pc = 0; pc < G_N_ELEMENTS (save_args); pc++)
{
if (save_args[pc].type!=param[pc].type)
{
status = GIMP_PDB_CALLING_ERROR;
break;
}
}
if (! save_image (param[3].data.d_string, image_ID,
param[5].data.d_int32,
param[6].data.d_int32, &error))
{
status = GIMP_PDB_EXECUTION_ERROR;
}
break;
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init (PLUG_IN_BINARY, FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, NULL,
GIMP_EXPORT_CAN_HANDLE_INDEXED |
GIMP_EXPORT_CAN_HANDLE_GRAY |
GIMP_EXPORT_CAN_HANDLE_ALPHA |
GIMP_EXPORT_CAN_HANDLE_LAYERS);
if (export == GIMP_EXPORT_CANCEL)
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
if (save_dialog (param[1].data.d_image))
{
if (! save_image (param[3].data.d_string,
image_ID, from_frame, to_frame, &error))
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
else
{
status = GIMP_PDB_CANCEL;
}
break;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_ID;
gint32 drawable_ID;
GimpExportReturn export = GIMP_EXPORT_CANCEL;
GError *error = NULL;
run_mode = param[0].data.d_int32;
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, LOAD_PROC) == 0)
{
image_ID = load_image (param[1].data.d_string, &error);
if (image_ID != -1)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
else if (strcmp (name, SAVE_PROC) == 0)
{
gimp_ui_init (PLUG_IN_BINARY, FALSE);
image_ID = param[1].data.d_int32;
drawable_ID = param[2].data.d_int32;
/* eventually export the image */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
export = gimp_export_image (&image_ID, &drawable_ID, NULL,
(GIMP_EXPORT_CAN_HANDLE_RGB |
GIMP_EXPORT_CAN_HANDLE_GRAY |
GIMP_EXPORT_CAN_HANDLE_INDEXED |
GIMP_EXPORT_CAN_HANDLE_ALPHA ));
if (export == GIMP_EXPORT_CANCEL)
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
break;
default:
break;
}
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data ("file_xpm_save", &xpmvals);
/* First acquire information with a dialog */
if (gimp_drawable_has_alpha (drawable_ID))
if (! save_dialog ())
status = GIMP_PDB_CANCEL;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 6)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
xpmvals.threshold = param[5].data.d_int32;
if (xpmvals.threshold < 0 ||
xpmvals.threshold > 255)
status = GIMP_PDB_CALLING_ERROR;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data ("file_xpm_save", &xpmvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
if (save_image (param[3].data.d_string,
image_ID, drawable_ID, &error))
{
gimp_set_data ("file_xpm_save", &xpmvals, sizeof (XpmSaveVals));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
if (export == GIMP_EXPORT_EXPORT)
gimp_image_delete (image_ID);
}
bool CursesMessageDisplay::processKeyInFocus(const Curses::Key &key)
{
CursesMessage *messageInfo=messageInfoPtr;
if (!messageInfo)
return false;
if (key == key.ENTER)
{
size_t row;
size_t col;
std::string url;
if (!messageInfo->getCurrentLink(row, col, url))
return true;
if (url.substr(0, 7) == "mailto:")
{
if (myMessage::checkInterrupted(false) &&
(messageInfo=messageInfoPtr) != NULL)
myMessage::newMessage(messageInfo->myfolder
->getFolder(),
messageInfo->myfolder
->getServer(),
url.substr(7));
return true;
}
std::string handler;
size_t p=url.find(':');
if (p != std::string::npos)
{
handler=myServer::getConfigDir() + "/"
+ url.substr(0, p) + ".handler";
if (access(handler.c_str(), X_OK))
{
handler=FILTERDIR "/"
+ url.substr(0, p) + ".handler";
if (access(handler.c_str(), X_OK))
handler="";
}
}
if (handler.size() == 0)
{
statusBar->clearstatus();
statusBar->
status(Gettext(_("Cannot find handler for %1%"))
<< url);
statusBar->beepError();
return true;
}
pid_t pp=fork();
if (pp < 0)
{
statusBar->clearstatus();
statusBar->status(strerror(errno));
statusBar->beepError();
return true;
}
if (pp == 0)
{
close(1);
open("/dev/null", O_WRONLY);
dup2(1, 2);
dup2(1, 0);
execl(handler.c_str(), handler.c_str(), url.c_str(),
(char *)NULL);
exit(1);
}
pid_t p2;
int waitstat;
while ((p2=wait(&waitstat)) != pp)
{
if (p2 < 0 && errno != EINTR)
break;
}
if (p2 == pp && WIFEXITED(waitstat) &&
WEXITSTATUS(waitstat) == 0)
{
statusBar->status(_("Started external handler."));
return true;
}
statusBar->clearstatus();
statusBar->status(_("External handler terminated with a non-zero exit code."),
statusBar->SYSERROR);
return true;
}
if (key == key_TAKEADDR)
{
mail::envelope *e=messageInfo->getEnvelope();
std::vector<mail::address> addrList;
addrList.reserve(e->from.size() +
e->to.size() +
e->cc.size() +
e->bcc.size() +
e->sender.size() +
e->replyto.size());
addrList.insert(addrList.end(),
e->from.begin(),
e->from.end());
addrList.insert(addrList.end(),
e->to.begin(),
e->to.end());
addrList.insert(addrList.end(),
e->cc.begin(),
e->cc.end());
addrList.insert(addrList.end(),
e->bcc.begin(),
e->bcc.end());
addrList.insert(addrList.end(),
e->sender.begin(),
e->sender.end());
addrList.insert(addrList.end(),
e->replyto.begin(),
e->replyto.end());
AddressBook::take(addrList);
return true;
}
if (key == key_FOLDERINDEX ||
key == key_LESSTHAN)
{
keepgoing=false;
myServer::nextScreen=&folderIndexScreen;
myServer::nextScreenArg=messageInfo->myfolder;
return true;
}
if (key == key_DELETE)
messageInfo->myfolder->markDeleted( messageInfo->messagesortednum,
true, false);
if (key == key_UNDELETE)
messageInfo->myfolder->markDeleted( messageInfo->messagesortednum,
false, false);
if (key == key_NEXTMESSAGE ||
key == key_DELETE ||
key == key_UNDELETE)
{
size_t dummy;
if (messageInfo->myfolder->getNextMessage(dummy))
{
Curses::keepgoing=false;
myServer::nextScreen= &goNextMessage;
myServer::nextScreenArg=messageInfo->myfolder;
return true;
}
return true;
}
if (key == key_PREVMESSAGE)
{
size_t dummy;
if (messageInfo->myfolder->getPrevMessage(dummy))
{
Curses::keepgoing=false;
myServer::nextScreen= &goPrevMessage;
myServer::nextScreenArg=messageInfo->myfolder;
}
return true;
}
if (key == ' ' || key == Key::RIGHT ||
key == Key::PGDN || key == Key::DOWN)
{
if ((key == Key::DOWN || key == Key::RIGHT) &&
messageInfo->nextLink())
return true; // Went to next link instead
size_t nLines=messageInfo->nLines();
size_t h=getHeight();
size_t lastLine= nLines > h ? nLines-h:0;
size_t firstLineSaved=getFirstLineShown();
if (key == Key::DOWN || key == Key::RIGHT)
setFirstLineShown(getFirstLineShown()+1);
else
setFirstLineShown(getFirstLineShown()+h);
if (getFirstLineShown() > lastLine)
setFirstLineShown(lastLine);
if (firstLineSaved == getFirstLineShown() && key == ' ')
{
size_t dummy;
if (messageInfo->myfolder->
getNextUnreadMessage(dummy))
{
Curses::keepgoing=false;
myServer::nextScreen= &goNextUnreadMessage;
myServer::nextScreenArg=messageInfo->myfolder;
return true;
}
statusBar->clearstatus();
statusBar->status(Gettext(_("No more unread mail in %1%"))
<< messageInfo->myfolder
->getFolder()->getName());
return true;
}
folderUpdated();
draw2();
messageInfo->toLastLink();
return true;
}
if (key == Key::LEFT || key == Key::PGUP || key == Key::UP)
{
if (key != Key::PGUP && messageInfo->prevLink())
return true;
size_t h=key != Key::PGUP ? 1:getHeight();
setFirstLineShown(getFirstLineShown() < h ? 0:
getFirstLineShown()-h);
folderUpdated();
draw2();
return true;
}
if (key == key_VIEWATT)
{
Curses::keepgoing=false;
myServer::nextScreen=showAttachments;
myServer::nextScreenArg=messageInfo;
return true;
}
if (key == key_SAVE)
{
std::string filename;
{
SaveDialog save_dialog(filename);
save_dialog.requestFocus();
myServer::eventloop();
filename=save_dialog;
mainScreen->erase();
}
mainScreen->draw();
requestFocus();
if (messageInfoPtr.isDestroyed() || filename == "")
return true;
CursesAttachmentDisplay::downloadTo(messageInfoPtr,
messageInfoPtr->shownMimeId
!= ""
?
messageInfoPtr->structure
.find(messageInfoPtr->
shownMimeId)
:NULL,
filename);
return true;
}
if (key == key_BOUNCE)
{
if (messageInfo->shownMimeId.size())
{
statusBar->clearstatus();
statusBar->status(_("Cannot forward only an attachment, just the whole message."));
statusBar->beepError();
return true;
}
mail::smtpInfo sendInfo;
std::string from;
std::string replyto;
std::string fcc;
std::string customheaders;
if (!myMessage::getDefaultHeaders(messageInfo->myfolder
->getFolder(),
messageInfo->myfolder
->getServer(),
from, replyto, fcc,
customheaders))
{
return true;
}
{
std::vector<mail::address> addrList;
size_t errIndex;
if (mail::address::fromString(from, addrList,
errIndex)
&& addrList.size() > 0)
sendInfo.sender=addrList[0].getAddr();
}
mail::ptr<myFolder> folderPtr=messageInfo->myfolder;
if (!CursesMessage::getBounceTo(sendInfo)
|| !CursesMessage::getSendInfo(Gettext(_("Blind-forward message to %1% address(es)? (Y/N) "))
<< sendInfo.recipients
.size(), "",
sendInfo, NULL))
return true;
disconnectCallbackStub disconnectStub;
myServer::Callback sendCallback;
mail::account *smtpServer;
mail::folder *folder=
CursesMessage::getSendFolder(sendInfo, smtpServer,
NULL,
disconnectStub);
if (!folder)
return true;
if (folderPtr.isDestroyed() || messageInfoPtr.isDestroyed())
{
delete folder;
if (smtpServer)
delete smtpServer;
return true;
}
try {
messageInfo->copyContentsTo(folder, sendCallback);
bool rc=myServer::eventloop(sendCallback);
delete folder;
folder=NULL;
if (smtpServer)
{
if (rc)
{
myServer::Callback disconnectCallback;
disconnectCallback.noreport=true;
smtpServer->logout(disconnectCallback);
myServer::
eventloop(disconnectCallback);
}
delete smtpServer;
smtpServer=NULL;
}
} catch (...) {
if (folder)
delete folder;
if (smtpServer)
delete smtpServer;
LIBMAIL_THROW(LIBMAIL_THROW_EMPTY);
}
return true;
}
if (key == key_REPLY)
{
mail::ptr<myFolder> folder=messageInfo->myfolder;
if (myMessage::checkInterrupted() &&
!folder.isDestroyed() &&
!messageInfoPtr.isDestroyed())
messageInfo->reply();
return true;
}
if (key == key_FWD)
{
mail::ptr<myFolder> folder=messageInfo->myfolder;
if (myMessage::checkInterrupted() &&
!folder.isDestroyed() &&
!messageInfoPtr.isDestroyed())
messageInfo->forward();
return true;
}
if (key == key_HEADERS)
{
erase();
messageInfo->fullEnvelopeHeaders=
!messageInfo->fullEnvelopeHeaders;
setFirstLineShown(0);
messageInfo->beginReformat(getWidth());
folderUpdated();
return true;
}
if (key == key_PRINT)
{
mail::ptr<CursesMessage> ptr=messageInfo;
int pipefd[2];
pid_t pid1;
myServer::promptInfo
printPrompt(_("Print to: "));
if (printCommand.size() == 0)
printCommand="lpr";
printPrompt=myServer::prompt(printPrompt
.initialValue(printCommand));
if (printPrompt.abortflag || ptr.isDestroyed())
return true;
std::vector<const char *> args;
{
const char *p=getenv("SHELL");
if (!p || !*p)
p="/bin/sh";
args.push_back(p);
}
args.push_back("-c");
printCommand=printPrompt;
args.push_back(printCommand.c_str());
args.push_back(0);
//
// Fork a child process which writes the text image of the
// message to a pipe.
//
// The parent process runs the print command, piping the text
// into it.
signal(SIGCHLD, SIG_DFL);
if (pipe(pipefd) < 0)
{
statusBar->clearstatus();
statusBar->status(strerror(errno));
statusBar->beepError();
return true;
}
if ((pid1=fork()) == 0)
{
FILE *fp;
// First child exits, the second child generates the
// text.
if (fork())
exit(0);
signal(SIGPIPE, SIG_DFL);
close(pipefd[0]);
fp=fdopen(pipefd[1], "w");
if (fp)
{
size_t nLines=messageInfo->nLines();
size_t i;
std::vector<std::pair<textAttributes, std::string> > line;
std::vector<std::pair<textAttributes, std::string> >
::iterator b, e;
for (i=0; i<nLines; i++)
{
messageInfo->getLineImage(i, line);
for (b=line.begin(), e=line.end();
b != e; ++b)
{
fprintf(fp, "%s",
b->second.c_str());
}
fprintf(fp, "\n");
}
fflush(fp);
}
exit(0);
}
// Wait for the first child to exit.
if (pid1 < 0)
{
close(pipefd[0]);
close(pipefd[1]);
statusBar->clearstatus();
statusBar->status(strerror(errno));
statusBar->beepError();
return true;
}
close(pipefd[1]);
while (wait(NULL) != pid1)
;
Curses::runCommand(args, pipefd[0], "");
close(pipefd[0]);
return true;
}
if (key == key_ROT13)
{
erase();
messageInfo->rot13=!messageInfo->rot13;
setFirstLineShown(0);
messageInfo->beginReformat(getWidth());
folderUpdated();
return true;
}
if ((key == key_UNENCRYPT) &&
(messageInfo->isSigned() ||
messageInfo->isEncrypted()) &&
GPG::gpg.gpg_installed())
{
mail::ptr<CursesMessage> ptr=messageInfo;
std::string passphrase;
std::vector<std::string> options;
bool wasEncrypted=messageInfo->isEncrypted();
if (wasEncrypted)
{
if (!PasswordList::passwordList.check("decrypt:",
passphrase))
{
myServer::promptInfo
passPrompt(_("Passphrase (if"
" required): "));
passPrompt=myServer::prompt(passPrompt
.password());
if (passPrompt.abortflag || ptr.isDestroyed())
return true;
passphrase=passPrompt;
}
}
std::string::iterator b=GPG::gpg.extraDecryptVerifyOptions.begin();
while (b != GPG::gpg.extraDecryptVerifyOptions.end())
{
if (unicode_isspace((unsigned char)*b))
{
b++;
continue;
}
std::string::iterator s=b;
while (b != GPG::gpg.extraDecryptVerifyOptions.end())
{
if (unicode_isspace((unsigned char)*b))
break;
b++;
}
options.push_back(std::string(s, b));
}
bool decryptFailed;
if (messageInfo->decrypt(passphrase, options, decryptFailed))
{
if (wasEncrypted && !decryptFailed)
PasswordList::passwordList
.save("decrypt:", passphrase);
erase();
setFirstLineShown(0);
messageInfo->beginReformat(getWidth());
folderUpdated();
if (wasEncrypted && decryptFailed)
{
statusBar->clearstatus();
statusBar->status(_("ERROR: Decryption failed,"
" passphrase forgotten."));
statusBar->beepError();
}
}
return true;
}
if (key == key_MSGSEARCH)
{
mail::ptr<CursesMessage> ptr=messageInfo;
myServer::promptInfo searchPrompt(_("Search: "));
searchPrompt=myServer::prompt(searchPrompt
.initialValue(searchString));
if (searchPrompt.abortflag || ptr.isDestroyed())
return true;
searchString=searchPrompt;
if (searchString.size() == 0)
return true;
mail::Search searchEngine;
if (!searchEngine.setString(searchString,
unicode_default_chset()))
{
statusBar->clearstatus();
statusBar->status(strerror(errno));
statusBar->beepError();
return true;
}
searchEngine.reset();
statusBar->clearstatus();
statusBar->status(_("Searching..."));
statusBar->flush();
size_t n=messageInfo->nLines();
std::vector<std::pair<textAttributes, std::string> > line;
while (firstLineToSearch < n)
{
messageInfo->getLineImage(firstLineToSearch, line);
std::string s;
std::vector<std::pair<textAttributes, std::string> >
::iterator b, e;
for (b=line.begin(), e=line.end(); b != e; ++b)
s += Gettext::toutf8(b->second);
unicode_char *uc;
size_t ucsize;
if (unicode_convert_tou_tobuf(s.c_str(),
s.size(),
"utf-8",
&uc,
&ucsize,
NULL))
{
statusBar->clearstatus();
statusBar->status(strerror(errno));
statusBar->beepError();
return true;
}
if (ucsize == 0)
{
free(uc);
++firstLineToSearch;
continue;
}
size_t i;
for (i=0; i<ucsize; ++i)
{
searchEngine << uc[i];
}
free(uc);
searchEngine << (unicode_char)' '; // EOL
if (searchEngine)
{
size_t nLines=messageInfo->nLines();
size_t h=getHeight();
size_t lastLine= nLines > h ? nLines-h:0;
size_t foundAt=firstLineToSearch;
size_t n=foundAt > 0 ? foundAt-1:0;
if (n > lastLine)
n=lastLine;
setFirstLineShown(n);
firstLineToSearch=foundAt+1;
statusBar->clearstatus();
statusBar->status(Gettext(_("Text located,"
" displayed on"
" line #%1%"))
<< (firstLineToSearch-n));
draw();
return true;
}
++firstLineToSearch;
}
statusBar->clearstatus();
statusBar->status(_("Not found."));
return true;
}
if (key.fkey())
{
std::string local_cmd;
if (!CursesIndexDisplay::FilterMessageCallback
::getFilterCmd(key.fkeynum(), local_cmd))
return true;
CursesIndexDisplay::FilterMessageCallback cb(local_cmd);
std::vector<size_t> msgvec;
msgvec.push_back(messageInfo->myfolder->getServerIndex
(messageInfo->myfolder->getCurrentMessage()));
messageInfo->myfolder->getServer()
->server->readMessageContent(msgvec, true,
mail::readBoth, cb);
if (myServer::eventloop(cb))
{
cb.finish();
if (myServer::nextScreen)
return true;
if (cb.errmsg.size())
{
statusBar->clearstatus();
statusBar->status(cb.errmsg);
statusBar->beepError();
}
}
return true;
}
return false;
}
static void
run (char *name,
int nparams,
GParam *param,
int *nreturn_vals,
GParam **return_vals)
{
static GParam values[2];
GRunModeType run_mode;
GStatusType status = STATUS_SUCCESS;
gint32 image_ID;
INIT_I18N_UI();
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = PARAM_STATUS;
values[0].data.d_status = STATUS_CALLING_ERROR;
if (strcmp (name, "file_jpeg_load") == 0)
{
image_ID = load_image (param[1].data.d_string);
if (image_ID != -1)
{
*nreturn_vals = 2;
values[0].data.d_status = STATUS_SUCCESS;
values[1].type = PARAM_IMAGE;
values[1].data.d_image = image_ID;
}
else
{
values[0].data.d_status = STATUS_EXECUTION_ERROR;
}
}
else if (strcmp (name, "file_jpeg_save") == 0)
{
switch (run_mode)
{
case RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data ("file_jpeg_save", &jsvals);
image_ID = param[1].data.d_int32;
{
char *buffer = NULL;
int size = 0;
if (gimp_image_has_icc_profile (image_ID, ICC_IMAGE_PROFILE))
{
buffer = gimp_image_get_icc_profile_by_mem (image_ID, &size, ICC_IMAGE_PROFILE);
if (buffer)
{
cmsHPROFILE lp = cmsOpenProfileFromMem( buffer, size );
if(lp)
{
if(cmsGetColorSpace(lp) == icSigCmykData)
{
g_message ("%s:%d Cmyk data in JPEG is not recommended!\n",
__FILE__,__LINE__);
status = STATUS_EXECUTION_ERROR;
}
cmsCloseProfile( lp );
}
free(buffer);
}
}
}
if(status == STATUS_EXECUTION_ERROR)
{
values[0].data.d_status = STATUS_EXECUTION_ERROR;
return;
}
/* First acquire information with a dialog */
if (! save_dialog ())
return;
break;
case RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 7)
status = STATUS_CALLING_ERROR;
if (status == STATUS_SUCCESS)
{
jsvals.quality = param[5].data.d_float;
jsvals.smoothing = param[6].data.d_float;
jsvals.optimize = param[7].data.d_int32;
}
if (status == STATUS_SUCCESS &&
(jsvals.quality < 0.0 || jsvals.quality > 1.0))
status = STATUS_CALLING_ERROR;
if (status == STATUS_SUCCESS &&
(jsvals.smoothing < 0.0 || jsvals.smoothing > 1.0))
status = STATUS_CALLING_ERROR;
case RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data ("file_jpeg_save", &jsvals);
break;
default:
break;
}
*nreturn_vals = 1;
if (save_image (param[3].data.d_string, param[1].data.d_int32, param[2].data.d_int32))
{
/* Store mvals data */
gimp_set_data ("file_jpeg_save", &jsvals, sizeof (JpegSaveVals));
values[0].data.d_status = STATUS_SUCCESS;
}
else
values[0].data.d_status = STATUS_EXECUTION_ERROR;
}
}
