/* Copyright (c) 2002,2003,2004,2009 James M. Kretchmar
*
* This file is part of Owl.
*
* Owl is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Owl is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Owl. If not, see .
*
* ---------------------------------------------------------------
*
* As of Owl version 2.1.12 there are patches contributed by
* developers of the the branched BarnOwl project, Copyright (c)
* 2006-2008 The BarnOwl Developers. All rights reserved.
*/
#include "owl.h"
#include
#include
#include
#include
#include
static const char fileIdent[] = "$Id$";
void sepbar(char *in)
{
char buff[1024];
WINDOW *sepwin;
owl_messagelist *ml;
owl_view *v;
int x, y, i;
char *foo, *appendtosepbar;
sepwin=owl_global_get_curs_sepwin(&g);
ml=owl_global_get_msglist(&g);
v=owl_global_get_current_view(&g);
werase(sepwin);
wattron(sepwin, A_REVERSE);
if (owl_global_is_fancylines(&g)) {
whline(sepwin, ACS_HLINE, owl_global_get_cols(&g));
} else {
whline(sepwin, '-', owl_global_get_cols(&g));
}
if (owl_global_is_sepbar_disable(&g)) {
getyx(sepwin, y, x);
wmove(sepwin, y, owl_global_get_cols(&g)-1);
return;
}
wmove(sepwin, 0, 2);
if (owl_messagelist_get_size(ml)==0) {
strcpy(buff, " (-/-) ");
} else {
snprintf(buff, 1024, " (%i/%i/%i) ", owl_global_get_curmsg(&g)+1,
owl_view_get_size(v),
owl_messagelist_get_size(ml));
}
waddstr(sepwin, buff);
foo=owl_view_get_filtname(v);
if (strcmp(foo, owl_global_get_view_home(&g))) wattroff(sepwin, A_REVERSE);
waddstr(sepwin, " ");
waddstr(sepwin, owl_view_get_filtname(v));
waddstr(sepwin, " ");
if (strcmp(foo, owl_global_get_view_home(&g))) wattron(sepwin, A_REVERSE);
if (owl_mainwin_is_curmsg_truncated(owl_global_get_mainwin(&g))) {
getyx(sepwin, y, x);
wmove(sepwin, y, x+2);
wattron(sepwin, A_BOLD);
waddstr(sepwin, " ");
wattroff(sepwin, A_BOLD);
}
i=owl_mainwin_get_last_msg(owl_global_get_mainwin(&g));
if ((i != -1) &&
(i < owl_view_get_size(v)-1)) {
getyx(sepwin, y, x);
wmove(sepwin, y, x+2);
wattron(sepwin, A_BOLD);
waddstr(sepwin, " ");
wattroff(sepwin, A_BOLD);
}
if (owl_global_get_rightshift(&g)>0) {
getyx(sepwin, y, x);
wmove(sepwin, y, x+2);
snprintf(buff, 1024, " right: %i ", owl_global_get_rightshift(&g));
waddstr(sepwin, buff);
}
if (owl_global_is_zaway(&g) || owl_global_is_aaway(&g)) {
getyx(sepwin, y, x);
wmove(sepwin, y, x+2);
wattron(sepwin, A_BOLD);
wattroff(sepwin, A_REVERSE);
if (owl_global_is_zaway(&g) && owl_global_is_aaway(&g)) {
waddstr(sepwin, " AWAY ");
} else if (owl_global_is_zaway(&g)) {
waddstr(sepwin, " Z-AWAY ");
} else if (owl_global_is_aaway(&g)) {
waddstr(sepwin, " A-AWAY ");
}
wattron(sepwin, A_REVERSE);
wattroff(sepwin, A_BOLD);
}
if (owl_global_get_curmsg_vert_offset(&g)) {
getyx(sepwin, y, x);
wmove(sepwin, y, x+2);
wattron(sepwin, A_BOLD);
wattroff(sepwin, A_REVERSE);
waddstr(sepwin, " SCROLL ");
wattron(sepwin, A_REVERSE);
wattroff(sepwin, A_BOLD);
}
if (in) {
getyx(sepwin, y, x);
wmove(sepwin, y, x+2);
waddstr(sepwin, in);
}
appendtosepbar = owl_global_get_appendtosepbar(&g);
if (appendtosepbar && *appendtosepbar) {
getyx(sepwin, y, x);
wmove(sepwin, y, x+2);
waddstr(sepwin, " ");
waddstr(sepwin, owl_global_get_appendtosepbar(&g));
waddstr(sepwin, " ");
}
getyx(sepwin, y, x);
wmove(sepwin, y, owl_global_get_cols(&g)-1);
wattroff(sepwin, A_BOLD);
wattroff(sepwin, A_REVERSE);
wnoutrefresh(sepwin);
}
void pophandler_quit(int ch)
{
if (ch=='q') {
owl_popwin_close(owl_global_get_popwin(&g));
}
}
char **atokenize(char *buffer, char *sep, int *i)
{
/* each element of return must be freed by user */
char **args;
char *workbuff, *foo;
int done=0, first=1, count=0;
workbuff=owl_malloc(strlen(buffer)+1);
memcpy(workbuff, buffer, strlen(buffer)+1);
args=NULL;
while (!done) {
if (first) {
first=0;
foo=(char *)strtok(workbuff, sep);
} else {
foo=(char *)strtok(NULL, sep);
}
if (foo==NULL) {
done=1;
} else {
args=(char **)owl_realloc(args, sizeof(char *) * (count+1));
args[count]=owl_malloc(strlen(foo)+1);
strcpy(args[count], foo);
count++;
}
}
*i=count;
owl_free(workbuff);
return(args);
}
char *skiptokens(char *buff, int n) {
/* skips n tokens and returns where that would be.
* TODO: handle quotes more sanely. */
int inquotes=0;
while (*buff && n>0) {
while (*buff == ' ') buff++;
while (*buff && (inquotes || *buff != ' ')) {
if (*buff == '"' || *buff == '\'') inquotes=!inquotes;
buff++;
}
while (*buff == ' ') buff++;
n--;
}
return buff;
}
/* Return a "nice" version of the path. Tilde expansion is done, and
* duplicate slashes are removed. Caller must free the return.
*/
char *owl_util_makepath(char *in)
{
int i, j, x;
char *out, user[MAXPATHLEN];
struct passwd *pw;
out=owl_malloc(MAXPATHLEN+1);
out[0]='\0';
j=strlen(in);
x=0;
for (i=0; ipw_dir);
x+=strlen(pw->pw_dir);
}
} else {
/* another user homedir */
int a, b;
b=0;
for (a=i+1; ipw_dir);
x+=strlen(pw->pw_dir);
}
}
} else if (in[i]=='/') {
/* check for a double / */
if (i<(j-1) && (in[i+1]=='/')) {
/* do nothing */
} else {
out[x]=in[i];
x++;
}
} else {
out[x]=in[i];
x++;
}
}
out[x]='\0';
return(out);
}
void atokenize_free(char **tok, int nels)
{
int i;
for (i=0; i0) {
out=owl_sprintf("%i d %2.2i:%2.2i", days, hours, run);
} else {
out=owl_sprintf(" %2.2i:%2.2i", hours, run);
}
return(out);
}
/* return the index of the last char before a change from the first one */
int owl_util_find_trans(char *in, int len)
{
int i;
for (i=1; i -1 && n < size)
return p;
/* Else try again with more space. */
if (n > -1) /* glibc 2.1 */
size = n+1; /* precisely what is needed */
else /* glibc 2.0 */
size *= 2; /* twice the old size */
if ((p = owl_realloc (p, size)) == NULL)
return NULL;
}
}
/* Return the owl color associated with the named color. Return -1
* if the named color is not available
*/
int owl_util_string_to_color(char *color)
{
if (!strcasecmp(color, "black")) {
return(OWL_COLOR_BLACK);
} else if (!strcasecmp(color, "red")) {
return(OWL_COLOR_RED);
} else if (!strcasecmp(color, "green")) {
return(OWL_COLOR_GREEN);
} else if (!strcasecmp(color, "yellow")) {
return(OWL_COLOR_YELLOW);
} else if (!strcasecmp(color, "blue")) {
return(OWL_COLOR_BLUE);
} else if (!strcasecmp(color, "magenta")) {
return(OWL_COLOR_MAGENTA);
} else if (!strcasecmp(color, "cyan")) {
return(OWL_COLOR_CYAN);
} else if (!strcasecmp(color, "white")) {
return(OWL_COLOR_WHITE);
} else if (!strcasecmp(color, "default")) {
return(OWL_COLOR_DEFAULT);
}
return(-1);
}
/* Return a string name of the given owl color */
char *owl_util_color_to_string(int color)
{
if (color==OWL_COLOR_BLACK) return("black");
if (color==OWL_COLOR_RED) return("red");
if (color==OWL_COLOR_GREEN) return("green");
if (color==OWL_COLOR_YELLOW) return("yellow");
if (color==OWL_COLOR_BLUE) return("blue");
if (color==OWL_COLOR_MAGENTA) return("magenta");
if (color==OWL_COLOR_CYAN) return("cyan");
if (color==OWL_COLOR_WHITE) return("white");
if (color==OWL_COLOR_DEFAULT) return("default");
return("Unknown color");
}
/* Get the default tty name. Caller must free the return */
char *owl_util_get_default_tty()
{
char *out, *tmp;
if (getenv("DISPLAY")) {
out=owl_strdup(getenv("DISPLAY"));
} else if ((tmp=ttyname(fileno(stdout)))!=NULL) {
out=owl_strdup(tmp);
if (!strncmp(out, "/dev/", 5)) {
owl_free(out);
out=owl_strdup(tmp+5);
}
} else {
out=owl_strdup("unknown");
}
return(out);
}
/* Animation hack */
void owl_hack_animate()
{
owl_messagelist *ml;
owl_message *m;
owl_fmtext *fm;
char *text, *ptr;
int place;
/* grab the first message and make sure its id is 0 */
ml=owl_global_get_msglist(&g);
m=owl_messagelist_get_element(ml, 0);
if (!m) return;
if (owl_message_get_id(m)!=0) return;
fm=owl_message_get_fmtext(m);
text=owl_fmtext_get_text(fm);
ptr=strstr(text, "OvO");
if (ptr) {
place=ptr-text;
owl_fmtext_set_char(fm, place, '-');
owl_fmtext_set_char(fm, place+2, '-');
owl_mainwin_redisplay(owl_global_get_mainwin(&g));
if (owl_popwin_is_active(owl_global_get_popwin(&g))) {
owl_popwin_refresh(owl_global_get_popwin(&g));
/* TODO: this is a broken kludge */
if (owl_global_get_viewwin(&g)) {
owl_viewwin_redisplay(owl_global_get_viewwin(&g), 0);
}
}
owl_global_set_needrefresh(&g);
return;
}
ptr=strstr(text, "-v-");
if (ptr) {
place=ptr-text;
owl_fmtext_set_char(fm, place, 'O');
owl_fmtext_set_char(fm, place+2, 'O');
owl_mainwin_redisplay(owl_global_get_mainwin(&g));
if (owl_popwin_is_active(owl_global_get_popwin(&g))) {
owl_popwin_refresh(owl_global_get_popwin(&g));
/* TODO: this is a broken kludge */
if (owl_global_get_viewwin(&g)) {
owl_viewwin_redisplay(owl_global_get_viewwin(&g), 0);
}
}
owl_global_set_needrefresh(&g);
return;
}
}
/* strip leading and trailing new lines. Caller must free the
* return.
*/
char *owl_util_stripnewlines(char *in)
{
char *tmp, *ptr1, *ptr2, *out;
ptr1=tmp=owl_strdup(in);
while (ptr1[0]=='\n') {
ptr1++;
}
ptr2=ptr1+strlen(ptr1)-1;
while (ptr2>ptr1 && ptr2[0]=='\n') {
ptr2[0]='\0';
ptr2--;
}
out=owl_strdup(ptr1);
owl_free(tmp);
return(out);
}
/* Delete the line matching "line" from the named file. If no such
* line is found the file is left intact. If backup==1 then create a
* backupfile containing the original contents. This is an
* inefficient impelementation which reads the entire file into
* memory.
*/
void owl_util_file_deleteline(char *filename, char *line, int backup)
{
char buff[LINE], *text;
char *backupfilename="";
FILE *file, *backupfile=NULL;
int size, newline;
/* open the file for reading */
file=fopen(filename, "r");
if (!file) {
owl_function_error("Error opening file %s", filename);
return;
}
/* open the backup file for writing */
if (backup) {
backupfilename=owl_sprintf("%s.backup", filename);
backupfile=fopen(backupfilename, "w");
if (!backupfile) {
owl_function_error("Error opening file %s for writing", backupfilename);
owl_free(backupfilename);
fclose(file);
return;
}
}
/* we'll read the entire file into memory, minus the line we don't want and
* and at the same time create the backup file if necessary
*/
text=owl_malloc(LINE);
strcpy(text, "");
size=LINE;
while (fgets(buff, LINE, file)!=NULL) {
/* strip the newline */
newline=0;
if (buff[strlen(buff)-1]=='\n') {
buff[strlen(buff)-1]='\0';
newline=1;
}
/* if we don't match the line, add to saved text in memory */
if (strcasecmp(buff, line)) {
size+=LINE;
text=owl_realloc(text, size);
strcat(text, buff);
if (newline) strcat(text, "\n");
}
/* write to backupfile if necessary */
if (backup) {
fputs(buff, backupfile);
if (newline) fputs("\n", backupfile);
}
}
if (backup) fclose(backupfile);
fclose(file);
/* now rewrite the original file from memory */
file=fopen(filename, "w");
if (!file) {
owl_function_error("WARNING: Error opening %s for writing. Use %s to restore.", filename, backupfilename);
owl_function_beep();
} else {
fputs(text, file);
fclose(file);
}
if (backup)
owl_free(backupfilename);
owl_free(text);
}
/* add the string 'str' to the list 'list' of strings, only if it
* is not already present
*/
void owl_util_list_add_unique_string(owl_list *list, char *str)
{
int i, j;
j=owl_list_get_size(list);
for (i=0; ib) return(a);
return(b);
}
int owl_util_min(int a, int b)
{
if (a