fyb/calcurse-edge
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Switch to Linux kernel coding style

Browse Source 
Convert our code base to adhere to Linux kernel coding style using
Lindent, with the following exceptions:

* Use spaces, instead of tabs, for indentation.
* Use 2-character indentations (instead of 8 characters).

Rationale: We currently have too much levels of indentation. Using
8-character tabs would make huge code parts unreadable. These need to be
cleaned up before we can switch to 8 characters.

Signed-off-by: Lukas Fleischer <calcurse@cryptocrack.de>
This commit is contained in:
Lukas Fleischer 2012-05-21 10:13:05 +02:00
parent 47c52ae7bb
commit cfd8ede2b3
33 changed files with 9138 additions and 10647 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

610
src/apoint.c
View File

@ -41,46 +41,41 @@
#include "calcurse.h" #include "calcurse.h"
llist_ts_t alist_p; llist_ts_t alist_p;
static struct apoint bkp_cut_apoint; static struct apoint bkp_cut_apoint;
static int hilt; static int hilt;
void void apoint_free_bkp(void)
apoint_free_bkp (void)
{ {
if (bkp_cut_apoint.mesg) if (bkp_cut_apoint.mesg) {
{ mem_free(bkp_cut_apoint.mesg);
mem_free (bkp_cut_apoint.mesg); bkp_cut_apoint.mesg = 0;
bkp_cut_apoint.mesg = 0; }
} erase_note(&bkp_cut_apoint.note);
erase_note (&bkp_cut_apoint.note);
} }
static void static void apoint_free(struct apoint *apt)
apoint_free (struct apoint *apt)
{ {
mem_free (apt->mesg); mem_free(apt->mesg);
erase_note (&apt->note); erase_note(&apt->note);
mem_free (apt); mem_free(apt);
} }
static void static void apoint_dup(struct apoint *in, struct apoint *bkp)
apoint_dup (struct apoint *in, struct apoint *bkp)
{ {
EXIT_IF (!in || !bkp, _("null pointer")); EXIT_IF(!in || !bkp, _("null pointer"));
bkp->start = in->start; bkp->start = in->start;
bkp->dur = in->dur; bkp->dur = in->dur;
bkp->state = in->state; bkp->state = in->state;
bkp->mesg = mem_strdup (in->mesg); bkp->mesg = mem_strdup(in->mesg);
if (in->note) if (in->note)
bkp->note = mem_strdup (in->note); bkp->note = mem_strdup(in->note);
} }
void void apoint_llist_init(void)
apoint_llist_init (void)
{ {
LLIST_TS_INIT (&alist_p); LLIST_TS_INIT(&alist_p);
} }
/* /*
@ -88,60 +83,54 @@ apoint_llist_init (void)
* list. No need to be thread safe, as only the main process remains when * list. No need to be thread safe, as only the main process remains when
* calling this function. * calling this function.
*/ */
void void apoint_llist_free(void)
apoint_llist_free (void)
{ {
LLIST_TS_FREE_INNER (&alist_p, apoint_free); LLIST_TS_FREE_INNER(&alist_p, apoint_free);
LLIST_TS_FREE (&alist_p); LLIST_TS_FREE(&alist_p);
} }
/* Sets which appointment is highlighted. */ /* Sets which appointment is highlighted. */
void void apoint_hilt_set(int highlighted)
apoint_hilt_set (int highlighted)
{ {
hilt = highlighted; hilt = highlighted;
} }
void void apoint_hilt_decrease(int n)
apoint_hilt_decrease (int n)
{ {
hilt -= n; hilt -= n;
} }
void void apoint_hilt_increase(int n)
apoint_hilt_increase (int n)
{ {
hilt += n; hilt += n;
} }
/* Return which appointment is highlighted. */ /* Return which appointment is highlighted. */
int int apoint_hilt(void)
apoint_hilt (void)
{ {
return hilt; return hilt;
} }
static int static int apoint_cmp_start(struct apoint *a, struct apoint *b)
apoint_cmp_start (struct apoint *a, struct apoint *b)
{ {
return a->start < b->start ? -1 : (a->start == b->start ? 0 : 1); return a->start < b->start ? -1 : (a->start == b->start ? 0 : 1);
} }
struct apoint * struct apoint *apoint_new(char *mesg, char *note, long start, long dur,
apoint_new (char *mesg, char *note, long start, long dur, char state) char state)
{ {
struct apoint *apt; struct apoint *apt;
apt = mem_malloc (sizeof (struct apoint)); apt = mem_malloc(sizeof(struct apoint));
apt->mesg = mem_strdup (mesg); apt->mesg = mem_strdup(mesg);
apt->note = (note != NULL) ? mem_strdup (note) : NULL; apt->note = (note != NULL) ? mem_strdup(note) : NULL;
apt->state = state; apt->state = state;
apt->start = start; apt->start = start;
apt->dur = dur; apt->dur = dur;
LLIST_TS_LOCK (&alist_p); LLIST_TS_LOCK(&alist_p);
LLIST_TS_ADD_SORTED (&alist_p, apt, apoint_cmp_start); LLIST_TS_ADD_SORTED(&alist_p, apt, apoint_cmp_start);
LLIST_TS_UNLOCK (&alist_p); LLIST_TS_UNLOCK(&alist_p);
return apt; return apt;
} }
@ -150,20 +139,21 @@ apoint_new (char *mesg, char *note, long start, long dur, char state)
* Add an item in either the appointment or the event list, * Add an item in either the appointment or the event list,
* depending if the start time is entered or not. * depending if the start time is entered or not.
*/ */
void void apoint_add(void)
apoint_add (void)
{ {
#define LTIME 6 #define LTIME 6
#define LDUR 12 #define LDUR 12
const char *mesg_1 = const char *mesg_1 =
_("Enter start time ([hh:mm]), leave blank for an all-day event : "); _("Enter start time ([hh:mm]), leave blank for an all-day event : ");
const char *mesg_2 = const char *mesg_2 =
_("Enter end time ([hh:mm]) or duration ([+hh:mm], [+xxxdxxhxxm] or [+mm]) : "); _
("Enter end time ([hh:mm]) or duration ([+hh:mm], [+xxxdxxhxxm] or [+mm]) : ");
const char *mesg_3 = _("Enter description :"); const char *mesg_3 = _("Enter description :");
const char *format_message_1 = const char *format_message_1 =
_("You entered an invalid start time, should be [hh:mm]"); _("You entered an invalid start time, should be [hh:mm]");
const char *format_message_2 = const char *format_message_2 =
_("Invalid end time/duration, should be [hh:mm], [+hh:mm], [+xxxdxxhxxm] or [+mm]"); _
("Invalid end time/duration, should be [hh:mm], [+hh:mm], [+xxxdxxhxxm] or [+mm]");
const char *enter_str = _("Press [Enter] to continue"); const char *enter_str = _("Press [Enter] to continue");
int Id = 1; int Id = 1;
char item_time[LDUR] = ""; char item_time[LDUR] = "";
@ -175,147 +165,122 @@ apoint_add (void)
int is_appointment = 1; int is_appointment = 1;
/* Get the starting time */ /* Get the starting time */
for (;;) for (;;) {
{ status_mesg(mesg_1, "");
status_mesg (mesg_1, ""); if (getstring(win[STA].p, item_time, LTIME, 0, 1) != GETSTRING_ESC) {
if (getstring (win[STA].p, item_time, LTIME, 0, 1) != GETSTRING_ESC) if (strlen(item_time) == 0) {
{ is_appointment = 0;
if (strlen (item_time) == 0) break;
{ }
is_appointment = 0;
break;
}
if (parse_time (item_time, &heures, &minutes) == 1) if (parse_time(item_time, &heures, &minutes) == 1)
break; break;
else else {
{ status_mesg(format_message_1, enter_str);
status_mesg (format_message_1, enter_str); wgetch(win[STA].p);
wgetch (win[STA].p); }
} } else
} return;
else }
return;
}
/* /*
* Check if an event or appointment is entered, * Check if an event or appointment is entered,
* depending on the starting time, and record the * depending on the starting time, and record the
* corresponding item. * corresponding item.
*/ */
if (is_appointment) if (is_appointment) { /* Get the appointment duration */
{ /* Get the appointment duration */ item_time[0] = '\0';
item_time[0] = '\0'; for (;;) {
for (;;) status_mesg(mesg_2, "");
{ if (getstring(win[STA].p, item_time, LDUR, 0, 1) != GETSTRING_ESC) {
status_mesg (mesg_2, ""); if (*item_time == '+' && parse_duration(item_time + 1,
if (getstring (win[STA].p, item_time, LDUR, 0, 1) != GETSTRING_ESC) &apoint_duration) == 1)
{ break;
if (*item_time == '+' && parse_duration (item_time + 1, else if (parse_time(item_time, &end_h, &end_m) == 1) {
&apoint_duration) == 1) if (end_h < heures || ((end_h == heures) && (end_m < minutes))) {
break; apoint_duration = MININSEC - minutes + end_m
else if (parse_time (item_time, &end_h, &end_m) == 1) + (24 + end_h - (heures + 1)) * MININSEC;
{ } else {
if (end_h < heures || ((end_h == heures) && (end_m < minutes))) apoint_duration = MININSEC - minutes
{ + end_m + (end_h - (heures + 1)) * MININSEC;
apoint_duration = MININSEC - minutes + end_m }
+ (24 + end_h - (heures + 1)) * MININSEC; break;
} } else {
else status_mesg(format_message_2, enter_str);
{ wgetch(win[STA].p);
apoint_duration = MININSEC - minutes
+ end_m + (end_h - (heures + 1)) * MININSEC;
}
break;
}
else
{
status_mesg (format_message_2, enter_str);
wgetch (win[STA].p);
}
}
else
return;
} }
} else
return;
} }
else /* Insert the event Id */ } else /* Insert the event Id */
Id = 1; Id = 1;
status_mesg (mesg_3, ""); status_mesg(mesg_3, "");
if (getstring (win[STA].p, item_mesg, BUFSIZ, 0, 1) == GETSTRING_VALID) if (getstring(win[STA].p, item_mesg, BUFSIZ, 0, 1) == GETSTRING_VALID) {
{ if (is_appointment) {
if (is_appointment) apoint_start = date2sec(*calendar_get_slctd_day(), heures, minutes);
{ apoint_new(item_mesg, 0L, apoint_start, min2sec(apoint_duration), 0L);
apoint_start = date2sec (*calendar_get_slctd_day (), heures, minutes); if (notify_bar())
apoint_new (item_mesg, 0L, apoint_start, min2sec (apoint_duration), 0L); notify_check_added(item_mesg, apoint_start, 0L);
if (notify_bar ()) } else
notify_check_added (item_mesg, apoint_start, 0L); event_new(item_mesg, 0L, date2sec(*calendar_get_slctd_day(), 0, 0), Id);
}
else
event_new (item_mesg, 0L, date2sec (*calendar_get_slctd_day (), 0, 0), Id);
if (hilt == 0) if (hilt == 0)
hilt++; hilt++;
} }
wins_erase_status_bar (); wins_erase_status_bar();
} }
/* Delete an item from the appointment list. */ /* Delete an item from the appointment list. */
void void apoint_delete(unsigned *nb_events, unsigned *nb_apoints)
apoint_delete (unsigned *nb_events, unsigned *nb_apoints)
{ {
const char *del_app_str = _("Do you really want to delete this item ?"); const char *del_app_str = _("Do you really want to delete this item ?");
long date; long date;
int nb_items = *nb_apoints + *nb_events; int nb_items = *nb_apoints + *nb_events;
int to_be_removed = 0; int to_be_removed = 0;
date = calendar_get_slctd_day_sec (); date = calendar_get_slctd_day_sec();
if (nb_items == 0) if (nb_items == 0)
return; return;
if (conf.confirm_delete) if (conf.confirm_delete) {
{ if (status_ask_bool(del_app_str) != 1) {
if (status_ask_bool (del_app_str) != 1) wins_erase_status_bar();
{ return;
wins_erase_status_bar (); }
return; }
}
if (nb_items != 0) {
switch (day_erase_item(date, hilt, ERASE_DONT_FORCE)) {
case EVNT:
case RECUR_EVNT:
(*nb_events)--;
to_be_removed = 1;
break;
case APPT:
case RECUR_APPT:
(*nb_apoints)--;
to_be_removed = 3;
break;
case 0:
return;
default:
EXIT(_("no such type"));
/* NOTREACHED */
} }
if (nb_items != 0) if (hilt > 1)
{ hilt--;
switch (day_erase_item (date, hilt, ERASE_DONT_FORCE)) if (apad.first_onscreen >= to_be_removed)
{ apad.first_onscreen = apad.first_onscreen - to_be_removed;
case EVNT: if (nb_items == 1)
case RECUR_EVNT: hilt = 0;
(*nb_events)--; }
to_be_removed = 1;
break;
case APPT:
case RECUR_APPT:
(*nb_apoints)--;
to_be_removed = 3;
break;
case 0:
return;
default:
EXIT (_("no such type"));
/* NOTREACHED */
}
if (hilt > 1)
hilt--;
if (apad.first_onscreen >= to_be_removed)
apad.first_onscreen = apad.first_onscreen - to_be_removed;
if (nb_items == 1)
hilt = 0;
}
} }
/* Cut an item, so that it can be pasted somewhere else later. */ /* Cut an item, so that it can be pasted somewhere else later. */
int int apoint_cut(unsigned *nb_events, unsigned *nb_apoints)
apoint_cut (unsigned *nb_events, unsigned *nb_apoints)
{ {
const int NBITEMS = *nb_apoints + *nb_events; const int NBITEMS = *nb_apoints + *nb_events;
int item_type, to_be_removed; int item_type, to_be_removed;
@ -324,20 +289,16 @@ apoint_cut (unsigned *nb_events, unsigned *nb_apoints)
if (NBITEMS == 0) if (NBITEMS == 0)
return 0; return 0;
date = calendar_get_slctd_day_sec (); date = calendar_get_slctd_day_sec();
item_type = day_cut_item (date, hilt); item_type = day_cut_item(date, hilt);
if (item_type == EVNT || item_type == RECUR_EVNT) if (item_type == EVNT || item_type == RECUR_EVNT) {
{ (*nb_events)--;
(*nb_events)--; to_be_removed = 1;
to_be_removed = 1; } else if (item_type == APPT || item_type == RECUR_APPT) {
} (*nb_apoints)--;
else if (item_type == APPT || item_type == RECUR_APPT) to_be_removed = 3;
{ } else
(*nb_apoints)--; EXIT(_("no such type"));
to_be_removed = 3;
}
else
EXIT (_("no such type"));
/* NOTREACHED */ /* NOTREACHED */
if (hilt > 1) if (hilt > 1)
@ -351,14 +312,13 @@ apoint_cut (unsigned *nb_events, unsigned *nb_apoints)
} }
/* Paste a previously cut item. */ /* Paste a previously cut item. */
void void apoint_paste(unsigned *nb_events, unsigned *nb_apoints, int cut_item_type)
apoint_paste (unsigned *nb_events, unsigned *nb_apoints, int cut_item_type)
{ {
int item_type; int item_type;
long date; long date;
date = calendar_get_slctd_day_sec (); date = calendar_get_slctd_day_sec();
item_type = day_paste_item (date, cut_item_type); item_type = day_paste_item(date, cut_item_type);
if (item_type == EVNT || item_type == RECUR_EVNT) if (item_type == EVNT || item_type == RECUR_EVNT)
(*nb_events)++; (*nb_events)++;
else if (item_type == APPT || item_type == RECUR_APPT) else if (item_type == APPT || item_type == RECUR_APPT)
@ -370,77 +330,72 @@ apoint_paste (unsigned *nb_events, unsigned *nb_apoints, int cut_item_type)
hilt++; hilt++;
} }
unsigned unsigned apoint_inday(struct apoint *i, long start)
apoint_inday (struct apoint *i, long start)
{ {
return (i->start <= start + DAYINSEC && i->start + i->dur > start); return (i->start <= start + DAYINSEC && i->start + i->dur > start);
} }
void void apoint_sec2str(struct apoint *o, long day, char *start, char *end)
apoint_sec2str (struct apoint *o, long day, char *start, char *end)
{ {
struct tm *lt; struct tm *lt;
time_t t; time_t t;
if (o->start < day) if (o->start < day)
strncpy (start, "..:..", 6); strncpy(start, "..:..", 6);
else else {
{ t = o->start;
t = o->start; lt = localtime(&t);
lt = localtime (&t); snprintf(start, HRMIN_SIZE, "%02u:%02u", lt->tm_hour, lt->tm_min);
snprintf (start, HRMIN_SIZE, "%02u:%02u", lt->tm_hour, lt->tm_min); }
}
if (o->start + o->dur > day + DAYINSEC) if (o->start + o->dur > day + DAYINSEC)
strncpy (end, "..:..", 6); strncpy(end, "..:..", 6);
else else {
{ t = o->start + o->dur;
t = o->start + o->dur; lt = localtime(&t);
lt = localtime (&t); snprintf(end, HRMIN_SIZE, "%02u:%02u", lt->tm_hour, lt->tm_min);
snprintf (end, HRMIN_SIZE, "%02u:%02u", lt->tm_hour, lt->tm_min); }
}
} }
void void apoint_write(struct apoint *o, FILE * f)
apoint_write (struct apoint *o, FILE *f)
{ {
struct tm *lt; struct tm *lt;
time_t t; time_t t;
t = o->start; t = o->start;
lt = localtime (&t); lt = localtime(&t);
fprintf (f, "%02u/%02u/%04u @ %02u:%02u", lt->tm_mon + 1, lt->tm_mday, fprintf(f, "%02u/%02u/%04u @ %02u:%02u", lt->tm_mon + 1, lt->tm_mday,
1900 + lt->tm_year, lt->tm_hour, lt->tm_min); 1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
t = o->start + o->dur; t = o->start + o->dur;
lt = localtime (&t); lt = localtime(&t);
fprintf (f, " -> %02u/%02u/%04u @ %02u:%02u ", lt->tm_mon + 1, lt->tm_mday, fprintf(f, " -> %02u/%02u/%04u @ %02u:%02u ", lt->tm_mon + 1, lt->tm_mday,
1900 + lt->tm_year, lt->tm_hour, lt->tm_min); 1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
if (o->note != NULL) if (o->note != NULL)
fprintf (f, ">%s ", o->note); fprintf(f, ">%s ", o->note);
if (o->state & APOINT_NOTIFY) if (o->state & APOINT_NOTIFY)
fputc ('!', f); fputc('!', f);
else else
fputc ('|', f); fputc('|', f);
fprintf (f, "%s\n", o->mesg); fprintf(f, "%s\n", o->mesg);
} }
struct apoint * struct apoint *apoint_scan(FILE * f, struct tm start, struct tm end, char state,
apoint_scan (FILE *f, struct tm start, struct tm end, char state, char *note) char *note)
{ {
char buf[BUFSIZ], *newline; char buf[BUFSIZ], *newline;
time_t tstart, tend, t; time_t tstart, tend, t;
t = time (NULL); t = time(NULL);
localtime (&t); localtime(&t);
/* Read the appointment description */ /* Read the appointment description */
if (!fgets (buf, sizeof buf, f)) if (!fgets(buf, sizeof buf, f))
return NULL; return NULL;
newline = strchr (buf, '\n'); newline = strchr(buf, '\n');
if (newline) if (newline)
*newline = '\0'; *newline = '\0';
@ -451,61 +406,58 @@ apoint_scan (FILE *f, struct tm start, struct tm end, char state, char *note)
end.tm_year -= 1900; end.tm_year -= 1900;
end.tm_mon--; end.tm_mon--;
tstart = mktime (&start); tstart = mktime(&start);
tend = mktime (&end); tend = mktime(&end);
EXIT_IF (tstart == -1 || tend == -1 || tstart > tend, EXIT_IF(tstart == -1 || tend == -1 || tstart > tend,
_("date error in appointment")); _("date error in appointment"));
return apoint_new (buf, note, tstart, tend - tstart, state); return apoint_new(buf, note, tstart, tend - tstart, state);
} }
/* Retrieve an appointment from the list, given the day and item position. */ /* Retrieve an appointment from the list, given the day and item position. */
struct apoint * struct apoint *apoint_get(long day, int pos)
apoint_get (long day, int pos)
{ {
llist_item_t *i = LLIST_TS_FIND_NTH (&alist_p, pos, day, apoint_inday); llist_item_t *i = LLIST_TS_FIND_NTH(&alist_p, pos, day, apoint_inday);
if (i) if (i)
return LLIST_TS_GET_DATA (i); return LLIST_TS_GET_DATA(i);
EXIT (_("item not found")); EXIT(_("item not found"));
/* NOTREACHED */ /* NOTREACHED */
} }
void void apoint_delete_bynum(long start, unsigned num, enum eraseflg flag)
apoint_delete_bynum (long start, unsigned num, enum eraseflg flag)
{ {
llist_item_t *i; llist_item_t *i;
int need_check_notify = 0; int need_check_notify = 0;
LLIST_TS_LOCK (&alist_p); LLIST_TS_LOCK(&alist_p);
i = LLIST_TS_FIND_NTH (&alist_p, num, start, apoint_inday); i = LLIST_TS_FIND_NTH(&alist_p, num, start, apoint_inday);
if (!i) if (!i)
EXIT (_("no such appointment")); EXIT(_("no such appointment"));
struct apoint *apt = LLIST_TS_GET_DATA (i); struct apoint *apt = LLIST_TS_GET_DATA(i);
switch (flag) switch (flag) {
{ case ERASE_FORCE_ONLY_NOTE:
case ERASE_FORCE_ONLY_NOTE: erase_note(&apt->note);
erase_note (&apt->note); break;
break; case ERASE_CUT:
case ERASE_CUT: apoint_free_bkp();
apoint_free_bkp (); apoint_dup(apt, &bkp_cut_apoint);
apoint_dup (apt, &bkp_cut_apoint); erase_note(&apt->note);
erase_note (&apt->note); /* FALLTHROUGH */
/* FALLTHROUGH */ default:
default: if (notify_bar())
if (notify_bar ()) need_check_notify = notify_same_item(apt->start);
need_check_notify = notify_same_item (apt->start); LLIST_TS_REMOVE(&alist_p, i);
LLIST_TS_REMOVE (&alist_p, i); mem_free(apt->mesg);
mem_free (apt->mesg); mem_free(apt);
mem_free (apt); if (need_check_notify)
if (need_check_notify) notify_check_next_app(0);
notify_check_next_app (0); break;
break; }
}
LLIST_TS_UNLOCK (&alist_p); LLIST_TS_UNLOCK(&alist_p);
} }
/* /*
@ -513,8 +465,7 @@ apoint_delete_bynum (long start, unsigned num, enum eraseflg flag)
* the appointment panel. This is to help the appointment scroll function * the appointment panel. This is to help the appointment scroll function
* to place beggining of the pad correctly. * to place beggining of the pad correctly.
*/ */
static int static int get_item_line(int item_nb, int nb_events_inday)
get_item_line (int item_nb, int nb_events_inday)
{ {
int separator = 2; int separator = 2;
int line = 0; int line = 0;
@ -523,7 +474,7 @@ get_item_line (int item_nb, int nb_events_inday)
line = item_nb - 1; line = item_nb - 1;
else else
line = nb_events_inday + separator line = nb_events_inday + separator
+ (item_nb - (nb_events_inday + 1)) * 3 - 1; + (item_nb - (nb_events_inday + 1)) * 3 - 1;
return line; return line;
} }
@ -531,15 +482,14 @@ get_item_line (int item_nb, int nb_events_inday)
* Update (if necessary) the first displayed pad line to make the * Update (if necessary) the first displayed pad line to make the
* appointment panel scroll down next time pnoutrefresh is called. * appointment panel scroll down next time pnoutrefresh is called.
*/ */
void void apoint_scroll_pad_down(int nb_events_inday, int win_length)
apoint_scroll_pad_down (int nb_events_inday, int win_length)
{ {
int pad_last_line = 0; int pad_last_line = 0;
int item_first_line = 0, item_last_line = 0; int item_first_line = 0, item_last_line = 0;
int borders = 6; int borders = 6;
int awin_length = win_length - borders; int awin_length = win_length - borders;
item_first_line = get_item_line (hilt, nb_events_inday); item_first_line = get_item_line(hilt, nb_events_inday);
if (hilt < nb_events_inday) if (hilt < nb_events_inday)
item_last_line = item_first_line; item_last_line = item_first_line;
else else
@ -553,18 +503,16 @@ apoint_scroll_pad_down (int nb_events_inday, int win_length)
* Update (if necessary) the first displayed pad line to make the * Update (if necessary) the first displayed pad line to make the
* appointment panel scroll up next time pnoutrefresh is called. * appointment panel scroll up next time pnoutrefresh is called.
*/ */
void void apoint_scroll_pad_up(int nb_events_inday)
apoint_scroll_pad_up (int nb_events_inday)
{ {
int item_first_line = 0; int item_first_line = 0;
item_first_line = get_item_line (hilt, nb_events_inday); item_first_line = get_item_line(hilt, nb_events_inday);
if (item_first_line < apad.first_onscreen) if (item_first_line < apad.first_onscreen)
apad.first_onscreen = item_first_line; apad.first_onscreen = item_first_line;
} }
static int static int apoint_starts_after(struct apoint *apt, long time)
apoint_starts_after (struct apoint *apt, long time)
{ {
return apt->start > time; return apt->start > time;
} }
@ -573,28 +521,25 @@ apoint_starts_after (struct apoint *apt, long time)
* Look in the appointment list if we have an item which starts before the item * Look in the appointment list if we have an item which starts before the item
* stored in the notify_app structure (which is the next item to be notified). * stored in the notify_app structure (which is the next item to be notified).
*/ */
struct notify_app * struct notify_app *apoint_check_next(struct notify_app *app, long start)
apoint_check_next (struct notify_app *app, long start)
{ {
llist_item_t *i; llist_item_t *i;
LLIST_TS_LOCK (&alist_p); LLIST_TS_LOCK(&alist_p);
i = LLIST_TS_FIND_FIRST (&alist_p, start, apoint_starts_after); i = LLIST_TS_FIND_FIRST(&alist_p, start, apoint_starts_after);
if (i) if (i) {
{ struct apoint *apt = LLIST_TS_GET_DATA(i);
struct apoint *apt = LLIST_TS_GET_DATA (i);
if (apt->start <= app->time) if (apt->start <= app->time) {
{ app->time = apt->start;
app->time = apt->start; app->txt = mem_strdup(apt->mesg);
app->txt = mem_strdup (apt->mesg); app->state = apt->state;
app->state = apt->state; app->got_app = 1;
app->got_app = 1;
}
} }
}
LLIST_TS_UNLOCK (&alist_p); LLIST_TS_UNLOCK(&alist_p);
return app; return app;
} }
@ -602,44 +547,40 @@ apoint_check_next (struct notify_app *app, long start)
/* /*
* Switch notification state. * Switch notification state.
*/ */
void void apoint_switch_notify(void)
apoint_switch_notify (void)
{ {
struct day_item *p; struct day_item *p;
long date; long date;
int apoint_nb = 0, need_chk_notify; int apoint_nb = 0, need_chk_notify;
p = day_get_item (hilt); p = day_get_item(hilt);
if (p->type != APPT && p->type != RECUR_APPT) if (p->type != APPT && p->type != RECUR_APPT)
return; return;
date = calendar_get_slctd_day_sec (); date = calendar_get_slctd_day_sec();
if (p->type == RECUR_APPT) if (p->type == RECUR_APPT) {
{ recur_apoint_switch_notify(date, p->appt_pos);
recur_apoint_switch_notify (date, p->appt_pos); return;
return; } else if (p->type == APPT)
} apoint_nb = day_item_nb(date, hilt, APPT);
else if (p->type == APPT)
apoint_nb = day_item_nb (date, hilt, APPT);
need_chk_notify = 0; need_chk_notify = 0;
LLIST_TS_LOCK (&alist_p); LLIST_TS_LOCK(&alist_p);
struct apoint *apt = apoint_get (date, apoint_nb); struct apoint *apt = apoint_get(date, apoint_nb);
apt->state ^= APOINT_NOTIFY; apt->state ^= APOINT_NOTIFY;
if (notify_bar ()) if (notify_bar())
notify_check_added (apt->mesg, apt->start, apt->state); notify_check_added(apt->mesg, apt->start, apt->state);
if (need_chk_notify) if (need_chk_notify)
notify_check_next_app (0); notify_check_next_app(0);
LLIST_TS_UNLOCK (&alist_p); LLIST_TS_UNLOCK(&alist_p);
} }
/* Updates the Appointment panel */ /* Updates the Appointment panel */
void void apoint_update_panel(int which_pan)
apoint_update_panel (int which_pan)
{ {
int title_xpos; int title_xpos;
int bordr = 1; int bordr = 1;
@ -650,56 +591,53 @@ apoint_update_panel (int which_pan)
struct date slctd_date; struct date slctd_date;
/* variable inits */ /* variable inits */
slctd_date = *calendar_get_slctd_day (); slctd_date = *calendar_get_slctd_day();
title_xpos = win[APP].w - (strlen (_(monthnames[slctd_date.mm - 1])) + 16); title_xpos = win[APP].w - (strlen(_(monthnames[slctd_date.mm - 1])) + 16);
if (slctd_date.dd < 10) if (slctd_date.dd < 10)
title_xpos++; title_xpos++;
date = date2sec (slctd_date, 0, 0); date = date2sec(slctd_date, 0, 0);
day_write_pad (date, app_width, app_length, (which_pan == APP) ? hilt : 0); day_write_pad(date, app_width, app_length, (which_pan == APP) ? hilt : 0);
/* Print current date in the top right window corner. */ /* Print current date in the top right window corner. */
erase_window_part (win[APP].p, 1, title_lines, win[APP].w - 2, erase_window_part(win[APP].p, 1, title_lines, win[APP].w - 2, win[APP].h - 2);
win[APP].h - 2); custom_apply_attr(win[APP].p, ATTR_HIGHEST);
custom_apply_attr (win[APP].p, ATTR_HIGHEST); mvwprintw(win[APP].p, title_lines, title_xpos, "%s %s %d, %d",
mvwprintw (win[APP].p, title_lines, title_xpos, "%s %s %d, %d", calendar_get_pom(date), _(monthnames[slctd_date.mm - 1]),
calendar_get_pom (date), _(monthnames[slctd_date.mm - 1]), slctd_date.dd, slctd_date.yyyy);
slctd_date.dd, slctd_date.yyyy); custom_remove_attr(win[APP].p, ATTR_HIGHEST);
custom_remove_attr (win[APP].p, ATTR_HIGHEST);
/* Draw the scrollbar if necessary. */ /* Draw the scrollbar if necessary. */
if ((apad.length >= app_length) || (apad.first_onscreen > 0)) if ((apad.length >= app_length) || (apad.first_onscreen > 0)) {
{ float ratio = ((float)app_length) / ((float)apad.length);
float ratio = ((float) app_length) / ((float) apad.length); int sbar_length = (int)(ratio * app_length);
int sbar_length = (int) (ratio * app_length); int highend = (int)(ratio * apad.first_onscreen);
int highend = (int) (ratio * apad.first_onscreen); unsigned hilt_bar = (which_pan == APP) ? 1 : 0;
unsigned hilt_bar = (which_pan == APP) ? 1 : 0; int sbar_top = highend + title_lines + 1;
int sbar_top = highend + title_lines + 1;
if ((sbar_top + sbar_length) > win[APP].h - 1) if ((sbar_top + sbar_length) > win[APP].h - 1)
sbar_length = win[APP].h - 1 - sbar_top; sbar_length = win[APP].h - 1 - sbar_top;
draw_scrollbar (win[APP].p, sbar_top, win[APP].w - 2, sbar_length, draw_scrollbar(win[APP].p, sbar_top, win[APP].w - 2, sbar_length,
title_lines + 1, win[APP].h - 1, hilt_bar); title_lines + 1, win[APP].h - 1, hilt_bar);
} }
wnoutrefresh (win[APP].p); wnoutrefresh(win[APP].p);
pnoutrefresh (apad.ptrwin, apad.first_onscreen, 0, pnoutrefresh(apad.ptrwin, apad.first_onscreen, 0,
win[APP].y + title_lines + 1, win[APP].x + bordr, win[APP].y + title_lines + 1, win[APP].x + bordr,
win[APP].y + win[APP].h - 2 * bordr, win[APP].y + win[APP].h - 2 * bordr,
win[APP].x + win[APP].w - 3 * bordr); win[APP].x + win[APP].w - 3 * bordr);
} }
void void apoint_paste_item(void)
apoint_paste_item (void)
{ {
long bkp_time, bkp_start; long bkp_time, bkp_start;
bkp_time = get_item_time (bkp_cut_apoint.start); bkp_time = get_item_time(bkp_cut_apoint.start);
bkp_start = calendar_get_slctd_day_sec () + bkp_time; bkp_start = calendar_get_slctd_day_sec() + bkp_time;
apoint_new (bkp_cut_apoint.mesg, bkp_cut_apoint.note, bkp_start, apoint_new(bkp_cut_apoint.mesg, bkp_cut_apoint.note, bkp_start,
bkp_cut_apoint.dur, bkp_cut_apoint.state); bkp_cut_apoint.dur, bkp_cut_apoint.state);
if (notify_bar ()) if (notify_bar())
notify_check_added (bkp_cut_apoint.mesg, bkp_start, bkp_cut_apoint.state); notify_check_added(bkp_cut_apoint.mesg, bkp_start, bkp_cut_apoint.state);
apoint_free_bkp (); apoint_free_bkp();
} }

1171
src/args.c
View File

File diff suppressed because it is too large Load Diff

899
src/calcurse.c
View File

@ -42,14 +42,13 @@
* Store the events and appointments for the selected day and reset the * Store the events and appointments for the selected day and reset the
* appointment highlight pointer if a new day was selected. * appointment highlight pointer if a new day was selected.
*/ */
static struct day_items_nb static struct day_items_nb do_storage(int day_changed)
do_storage (int day_changed)
{ {
struct day_items_nb inday = *day_process_storage (calendar_get_slctd_day (), struct day_items_nb inday = *day_process_storage(calendar_get_slctd_day(),
day_changed, &inday); day_changed, &inday);
if (day_changed) if (day_changed)
apoint_hilt_set (1); apoint_hilt_set(1);
return inday; return inday;
} }
@ -61,8 +60,7 @@ do_storage (int day_changed)
* and one can choose between different color schemes and layouts. * and one can choose between different color schemes and layouts.
* All of the commands are documented within an online help system. * All of the commands are documented within an online help system.
*/ */
int int main(int argc, char **argv)
main (int argc, char **argv)
{ {
struct day_items_nb inday; struct day_items_nb inday;
int no_data_file = 1; int no_data_file = 1;
@ -70,504 +68,455 @@ main (int argc, char **argv)
int count; int count;
#if ENABLE_NLS #if ENABLE_NLS
setlocale (LC_ALL, ""); setlocale(LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR); bindtextdomain(PACKAGE, LOCALEDIR);
textdomain (PACKAGE); textdomain(PACKAGE);
#endif /* ENABLE_NLS */ #endif /* ENABLE_NLS */
/* Thread-safe data structure init */ /* Thread-safe data structure init */
apoint_llist_init (); apoint_llist_init();
recur_apoint_llist_init (); recur_apoint_llist_init();
/* Initialize non-thread-safe data structures. */ /* Initialize non-thread-safe data structures. */
event_llist_init (); event_llist_init();
todo_init_list (); todo_init_list();
/* /*
* Begin by parsing and handling command line arguments. * Begin by parsing and handling command line arguments.
* The data path is also initialized here. * The data path is also initialized here.
*/ */
if (parse_args (argc, argv)) if (parse_args(argc, argv)) {
{ /* Non-interactive mode. */
/* Non-interactive mode. */ exit_calcurse(EXIT_SUCCESS);
exit_calcurse (EXIT_SUCCESS); } else {
} no_data_file = io_check_data_files();
else dmon_stop();
{ io_set_lock();
no_data_file = io_check_data_files (); }
dmon_stop ();
io_set_lock ();
}
/* Begin of interactive mode with ncurses interface. */ /* Begin of interactive mode with ncurses interface. */
sigs_init (); /* signal handling init */ sigs_init(); /* signal handling init */
initscr (); /* start the curses mode */ initscr(); /* start the curses mode */
cbreak (); /* control chars generate a signal */ cbreak(); /* control chars generate a signal */
noecho (); /* controls echoing of typed chars */ noecho(); /* controls echoing of typed chars */
curs_set (0); /* make cursor invisible */ curs_set(0); /* make cursor invisible */
calendar_set_current_date (); calendar_set_current_date();
notify_init_vars (); notify_init_vars();
wins_get_config (); wins_get_config();
/* Check if terminal supports color. */ /* Check if terminal supports color. */
if (has_colors ()) if (has_colors()) {
{ colorize = 1;
colorize = 1; background = COLOR_BLACK;
background = COLOR_BLACK; foreground = COLOR_WHITE;
foreground = COLOR_WHITE; start_color();
start_color ();
#ifdef NCURSES_VERSION #ifdef NCURSES_VERSION
if (use_default_colors () != ERR) if (use_default_colors() != ERR) {
{ background = -1;
background = -1; foreground = -1;
foreground = -1; }
}
#endif /* NCURSES_VERSION */ #endif /* NCURSES_VERSION */
/* Color assignment */ /* Color assignment */
init_pair (COLR_RED, COLOR_RED, background); init_pair(COLR_RED, COLOR_RED, background);
init_pair (COLR_GREEN, COLOR_GREEN, background); init_pair(COLR_GREEN, COLOR_GREEN, background);
init_pair (COLR_YELLOW, COLOR_YELLOW, background); init_pair(COLR_YELLOW, COLOR_YELLOW, background);
init_pair (COLR_BLUE, COLOR_BLUE, background); init_pair(COLR_BLUE, COLOR_BLUE, background);
init_pair (COLR_MAGENTA, COLOR_MAGENTA, background); init_pair(COLR_MAGENTA, COLOR_MAGENTA, background);
init_pair (COLR_CYAN, COLOR_CYAN, background); init_pair(COLR_CYAN, COLOR_CYAN, background);
init_pair (COLR_DEFAULT, foreground, background); init_pair(COLR_DEFAULT, foreground, background);
init_pair (COLR_HIGH, COLOR_BLACK, COLOR_GREEN); init_pair(COLR_HIGH, COLOR_BLACK, COLOR_GREEN);
init_pair (COLR_CUSTOM, COLOR_RED, background); init_pair(COLR_CUSTOM, COLOR_RED, background);
} } else {
else colorize = 0;
{ background = COLOR_BLACK;
colorize = 0; }
background = COLOR_BLACK;
}
vars_init (); vars_init();
wins_init (); wins_init();
wins_slctd_init (); wins_slctd_init();
notify_init_bar (); notify_init_bar();
wins_reset_status_page (); wins_reset_status_page();
/* /*
* Read the data from files : first the user * Read the data from files : first the user
* configuration (the display is then updated), and then * configuration (the display is then updated), and then
* the todo list, appointments and events. * the todo list, appointments and events.
*/ */
config_load (); config_load();
wins_erase_status_bar (); wins_erase_status_bar();
io_load_keys (conf.pager); io_load_keys(conf.pager);
io_load_todo (); io_load_todo();
io_load_app (); io_load_app();
wins_reinit (); wins_reinit();
if (conf.system_dialogs) if (conf.system_dialogs) {
{ wins_update(FLAG_ALL);
wins_update (FLAG_ALL); io_startup_screen(no_data_file);
io_startup_screen (no_data_file); }
} inday = *day_process_storage(0, 0, &inday);
inday = *day_process_storage (0, 0, &inday); wins_slctd_set(CAL);
wins_slctd_set (CAL); wins_update(FLAG_ALL);
wins_update (FLAG_ALL);
/* Start miscellaneous threads. */ /* Start miscellaneous threads. */
if (notify_bar ()) if (notify_bar())
notify_start_main_thread (); notify_start_main_thread();
calendar_start_date_thread (); calendar_start_date_thread();
if (conf.periodic_save > 0) if (conf.periodic_save > 0)
io_start_psave_thread (); io_start_psave_thread();
/* User input */ /* User input */
for (;;) for (;;) {
{ int key;
int key;
if (resize) if (resize) {
{ resize = 0;
resize = 0; wins_reset();
wins_reset ();
}
key = keys_getch (win[STA].p, &count);
switch (key)
{
case KEY_GENERIC_REDRAW:
resize = 1;
break;
case KEY_GENERIC_CHANGE_VIEW:
wins_reset_status_page ();
wins_slctd_next ();
/* Select the event to highlight. */
switch (wins_slctd ())
{
case TOD:
if ((todo_hilt () == 0) && (todo_nb () > 0))
todo_hilt_set (1);
break;
case APP:
if ((apoint_hilt () == 0) &&
((inday.nb_events + inday.nb_apoints) > 0))
apoint_hilt_set (1);
break;
default:
break;
}
wins_update (FLAG_ALL);
break;
case KEY_GENERIC_OTHER_CMD:
wins_other_status_page (wins_slctd ());
wins_update (FLAG_STA);
break;
case KEY_GENERIC_GOTO:
case KEY_GENERIC_GOTO_TODAY:
wins_erase_status_bar ();
calendar_set_current_date ();
if (key == KEY_GENERIC_GOTO_TODAY)
calendar_goto_today ();
else
calendar_change_day (conf.input_datefmt);
inday = do_storage (1);
wins_update (FLAG_CAL | FLAG_APP | FLAG_STA);
break;
case KEY_VIEW_ITEM:
if ((wins_slctd () == APP) && (apoint_hilt () != 0))
day_popup_item ();
else if ((wins_slctd () == TOD) && (todo_hilt () != 0))
item_in_popup (NULL, NULL, todo_saved_mesg (), _("To do :"));
wins_update (FLAG_ALL);
break;
case KEY_GENERIC_CONFIG_MENU:
wins_erase_status_bar ();
custom_config_main ();
inday = do_storage (0);
wins_update (FLAG_ALL);
break;
case KEY_GENERIC_ADD_APPT:
apoint_add ();
inday = do_storage (1);
wins_update (FLAG_CAL | FLAG_APP | FLAG_STA);
break;
case KEY_GENERIC_ADD_TODO:
todo_new_item ();
if (todo_hilt () == 0 && todo_nb () == 1)
todo_hilt_increase (1);
wins_update (FLAG_TOD | FLAG_STA);
break;
case KEY_ADD_ITEM:
switch (wins_slctd ())
{
case APP:
apoint_add ();
inday = do_storage (0);
wins_update (FLAG_CAL | FLAG_APP | FLAG_STA);
break;
case TOD:
todo_new_item ();
if (todo_hilt () == 0 && todo_nb () == 1)
todo_hilt_increase (1);
wins_update (FLAG_TOD | FLAG_STA);
break;
default:
break;
}
break;
case KEY_EDIT_ITEM:
if (wins_slctd () == APP && apoint_hilt () != 0)
{
day_edit_item ();
inday = do_storage (0);
wins_update (FLAG_CAL | FLAG_APP | FLAG_STA);
}
else if (wins_slctd () == TOD && todo_hilt () != 0)
{
todo_edit_item ();
wins_update (FLAG_TOD | FLAG_STA);
}
break;
case KEY_DEL_ITEM:
if (wins_slctd () == APP && apoint_hilt () != 0)
{
apoint_delete (&inday.nb_events, &inday.nb_apoints);
inday = do_storage (0);
wins_update (FLAG_CAL | FLAG_APP | FLAG_STA);
}
else if (wins_slctd () == TOD && todo_hilt () != 0)
{
todo_delete ();
wins_update (FLAG_TOD | FLAG_STA);
}
break;
case KEY_GENERIC_CUT:
if (wins_slctd () == APP && apoint_hilt () != 0)
{
cut_item = apoint_cut (&inday.nb_events, &inday.nb_apoints);
inday = do_storage (0);
wins_update (FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_PASTE:
if (wins_slctd () == APP)
{
apoint_paste (&inday.nb_events, &inday.nb_apoints, cut_item);
cut_item = 0;
inday = do_storage (0);
wins_update (FLAG_CAL | FLAG_APP);
}
break;
case KEY_REPEAT_ITEM:
if (wins_slctd () == APP && apoint_hilt () != 0)
recur_repeat_item ();
inday = do_storage (0);
wins_update (FLAG_CAL | FLAG_APP | FLAG_STA);
break;
case KEY_FLAG_ITEM:
if (wins_slctd () == APP && apoint_hilt () != 0)
{
apoint_switch_notify ();
inday = do_storage (0);
wins_update (FLAG_APP);
}
else if (wins_slctd () == TOD && todo_hilt () != 0)
{
todo_flag ();
wins_update (FLAG_TOD);
}
break;
case KEY_PIPE_ITEM:
if (wins_slctd () == APP && apoint_hilt () != 0)
day_pipe_item ();
else if (wins_slctd () == TOD && todo_hilt () != 0)
todo_pipe_item ();
wins_update (FLAG_ALL);
break;
case KEY_RAISE_PRIORITY:
case KEY_LOWER_PRIORITY:
if (wins_slctd () == TOD && todo_hilt () != 0)
{
todo_chg_priority (key);
if (todo_hilt_pos () < 0)
todo_set_first (todo_hilt ());
else if (todo_hilt_pos () >= win[TOD].h - 4)
todo_set_first (todo_hilt () - win[TOD].h + 5);
wins_update (FLAG_TOD);
}
break;
case KEY_EDIT_NOTE:
if (wins_slctd () == APP && apoint_hilt () != 0)
{
day_edit_note (conf.editor);
inday = do_storage (0);
}
else if (wins_slctd () == TOD && todo_hilt () != 0)
todo_edit_note (conf.editor);
wins_update (FLAG_ALL);
break;
case KEY_VIEW_NOTE:
if (wins_slctd () == APP && apoint_hilt () != 0)
day_view_note (conf.pager);
else if (wins_slctd () == TOD && todo_hilt () != 0)
todo_view_note (conf.pager);
wins_update (FLAG_ALL);
break;
case KEY_GENERIC_HELP:
wins_status_bar ();
help_screen ();
wins_update (FLAG_ALL);
break;
case KEY_GENERIC_SAVE:
io_save_cal (IO_SAVE_DISPLAY_BAR);
wins_update (FLAG_STA);
break;
case KEY_GENERIC_IMPORT:
wins_erase_status_bar ();
io_import_data (IO_IMPORT_ICAL, NULL);
inday = do_storage (0);
wins_update (FLAG_ALL);
break;
case KEY_GENERIC_EXPORT:
wins_erase_status_bar ();
io_export_bar ();
while ((key = wgetch (win[STA].p)) != 'q')
{
switch (key)
{
case 'I':
case 'i':
io_export_data (IO_EXPORT_ICAL);
break;
case 'P':
case 'p':
io_export_data (IO_EXPORT_PCAL);
break;
}
wins_reset ();
wins_update (FLAG_ALL);
wins_erase_status_bar ();
io_export_bar ();
}
inday = do_storage (0);
wins_update (FLAG_ALL);
break;
case KEY_GENERIC_NEXT_DAY:
case KEY_MOVE_RIGHT:
if (wins_slctd () == CAL || key == KEY_GENERIC_NEXT_DAY)
{
calendar_move (RIGHT, count);
inday = do_storage (1);
wins_update (FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_PREV_DAY:
case KEY_MOVE_LEFT:
if (wins_slctd () == CAL || key == KEY_GENERIC_PREV_DAY)
{
calendar_move (LEFT, count);
inday = do_storage (1);
wins_update (FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_PREV_WEEK:
case KEY_MOVE_UP:
if (wins_slctd () == CAL || key == KEY_GENERIC_PREV_WEEK)
{
calendar_move (UP, count);
inday = do_storage (1);
wins_update (FLAG_CAL | FLAG_APP);
}
else if (wins_slctd () == APP)
{
if (count >= apoint_hilt ())
count = apoint_hilt () - 1;
apoint_hilt_decrease (count);
apoint_scroll_pad_up (inday.nb_events);
wins_update (FLAG_APP);
}
else if (wins_slctd () == TOD)
{
if (count >= todo_hilt ())
count = todo_hilt () - 1;
todo_hilt_decrease (count);
if (todo_hilt_pos () < 0)
todo_first_increase (todo_hilt_pos ());
wins_update (FLAG_TOD);
}
break;
case KEY_GENERIC_NEXT_WEEK:
case KEY_MOVE_DOWN:
if (wins_slctd () == CAL || key == KEY_GENERIC_NEXT_WEEK)
{
calendar_move (DOWN, count);
inday = do_storage (1);
wins_update (FLAG_CAL | FLAG_APP);
}
else if (wins_slctd () == APP)
{
if (count > inday.nb_events + inday.nb_apoints - apoint_hilt ())
count = inday.nb_events + inday.nb_apoints - apoint_hilt ();
apoint_hilt_increase (count);
apoint_scroll_pad_down (inday.nb_events, win[APP].h);
wins_update (FLAG_APP);
}
else if (wins_slctd () == TOD)
{
if (count > todo_nb () - todo_hilt ())
count = todo_nb () - todo_hilt ();
todo_hilt_increase (count);
if (todo_hilt_pos () >= win[TOD].h - 4)
todo_first_increase (todo_hilt_pos () - win[TOD].h + 5);
wins_update (FLAG_TOD);
}
break;
case KEY_START_OF_WEEK:
if (wins_slctd () == CAL)
{
calendar_move (WEEK_START, count);
inday = do_storage (1);
wins_update (FLAG_CAL | FLAG_APP);
}
break;
case KEY_END_OF_WEEK:
if (wins_slctd () == CAL)
{
calendar_move (WEEK_END, count);
inday = do_storage (1);
wins_update (FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_SCROLL_UP:
if (wins_slctd () == CAL)
{
calendar_view_prev ();
wins_update (FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_SCROLL_DOWN:
if (wins_slctd () == CAL)
{
calendar_view_next ();
wins_update (FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_QUIT:
if (conf.auto_save)
io_save_cal (IO_SAVE_DISPLAY_BAR);
if (conf.auto_gc)
note_gc ();
if (conf.confirm_quit)
{
if (status_ask_bool (_("Do you really want to quit ?")) == 1)
exit_calcurse (EXIT_SUCCESS);
else
{
wins_erase_status_bar ();
wins_update (FLAG_STA);
break;
}
}
else
exit_calcurse (EXIT_SUCCESS);
break;
case KEY_RESIZE:
case ERR:
/* Do not reset the count parameter on resize or error. */
continue;
default:
break;
}
count = 0;
} }
key = keys_getch(win[STA].p, &count);
switch (key) {
case KEY_GENERIC_REDRAW:
resize = 1;
break;
case KEY_GENERIC_CHANGE_VIEW:
wins_reset_status_page();
wins_slctd_next();
/* Select the event to highlight. */
switch (wins_slctd()) {
case TOD:
if ((todo_hilt() == 0) && (todo_nb() > 0))
todo_hilt_set(1);
break;
case APP:
if ((apoint_hilt() == 0) && ((inday.nb_events + inday.nb_apoints) > 0))
apoint_hilt_set(1);
break;
default:
break;
}
wins_update(FLAG_ALL);
break;
case KEY_GENERIC_OTHER_CMD:
wins_other_status_page(wins_slctd());
wins_update(FLAG_STA);
break;
case KEY_GENERIC_GOTO:
case KEY_GENERIC_GOTO_TODAY:
wins_erase_status_bar();
calendar_set_current_date();
if (key == KEY_GENERIC_GOTO_TODAY)
calendar_goto_today();
else
calendar_change_day(conf.input_datefmt);
inday = do_storage(1);
wins_update(FLAG_CAL | FLAG_APP | FLAG_STA);
break;
case KEY_VIEW_ITEM:
if ((wins_slctd() == APP) && (apoint_hilt() != 0))
day_popup_item();
else if ((wins_slctd() == TOD) && (todo_hilt() != 0))
item_in_popup(NULL, NULL, todo_saved_mesg(), _("To do :"));
wins_update(FLAG_ALL);
break;
case KEY_GENERIC_CONFIG_MENU:
wins_erase_status_bar();
custom_config_main();
inday = do_storage(0);
wins_update(FLAG_ALL);
break;
case KEY_GENERIC_ADD_APPT:
apoint_add();
inday = do_storage(1);
wins_update(FLAG_CAL | FLAG_APP | FLAG_STA);
break;
case KEY_GENERIC_ADD_TODO:
todo_new_item();
if (todo_hilt() == 0 && todo_nb() == 1)
todo_hilt_increase(1);
wins_update(FLAG_TOD | FLAG_STA);
break;
case KEY_ADD_ITEM:
switch (wins_slctd()) {
case APP:
apoint_add();
inday = do_storage(0);
wins_update(FLAG_CAL | FLAG_APP | FLAG_STA);
break;
case TOD:
todo_new_item();
if (todo_hilt() == 0 && todo_nb() == 1)
todo_hilt_increase(1);
wins_update(FLAG_TOD | FLAG_STA);
break;
default:
break;
}
break;
case KEY_EDIT_ITEM:
if (wins_slctd() == APP && apoint_hilt() != 0) {
day_edit_item();
inday = do_storage(0);
wins_update(FLAG_CAL | FLAG_APP | FLAG_STA);
} else if (wins_slctd() == TOD && todo_hilt() != 0) {
todo_edit_item();
wins_update(FLAG_TOD | FLAG_STA);
}
break;
case KEY_DEL_ITEM:
if (wins_slctd() == APP && apoint_hilt() != 0) {
apoint_delete(&inday.nb_events, &inday.nb_apoints);
inday = do_storage(0);
wins_update(FLAG_CAL | FLAG_APP | FLAG_STA);
} else if (wins_slctd() == TOD && todo_hilt() != 0) {
todo_delete();
wins_update(FLAG_TOD | FLAG_STA);
}
break;
case KEY_GENERIC_CUT:
if (wins_slctd() == APP && apoint_hilt() != 0) {
cut_item = apoint_cut(&inday.nb_events, &inday.nb_apoints);
inday = do_storage(0);
wins_update(FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_PASTE:
if (wins_slctd() == APP) {
apoint_paste(&inday.nb_events, &inday.nb_apoints, cut_item);
cut_item = 0;
inday = do_storage(0);
wins_update(FLAG_CAL | FLAG_APP);
}
break;
case KEY_REPEAT_ITEM:
if (wins_slctd() == APP && apoint_hilt() != 0)
recur_repeat_item();
inday = do_storage(0);
wins_update(FLAG_CAL | FLAG_APP | FLAG_STA);
break;
case KEY_FLAG_ITEM:
if (wins_slctd() == APP && apoint_hilt() != 0) {
apoint_switch_notify();
inday = do_storage(0);
wins_update(FLAG_APP);
} else if (wins_slctd() == TOD && todo_hilt() != 0) {
todo_flag();
wins_update(FLAG_TOD);
}
break;
case KEY_PIPE_ITEM:
if (wins_slctd() == APP && apoint_hilt() != 0)
day_pipe_item();
else if (wins_slctd() == TOD && todo_hilt() != 0)
todo_pipe_item();
wins_update(FLAG_ALL);
break;
case KEY_RAISE_PRIORITY:
case KEY_LOWER_PRIORITY:
if (wins_slctd() == TOD && todo_hilt() != 0) {
todo_chg_priority(key);
if (todo_hilt_pos() < 0)
todo_set_first(todo_hilt());
else if (todo_hilt_pos() >= win[TOD].h - 4)
todo_set_first(todo_hilt() - win[TOD].h + 5);
wins_update(FLAG_TOD);
}
break;
case KEY_EDIT_NOTE:
if (wins_slctd() == APP && apoint_hilt() != 0) {
day_edit_note(conf.editor);
inday = do_storage(0);
} else if (wins_slctd() == TOD && todo_hilt() != 0)
todo_edit_note(conf.editor);
wins_update(FLAG_ALL);
break;
case KEY_VIEW_NOTE:
if (wins_slctd() == APP && apoint_hilt() != 0)
day_view_note(conf.pager);
else if (wins_slctd() == TOD && todo_hilt() != 0)
todo_view_note(conf.pager);
wins_update(FLAG_ALL);
break;
case KEY_GENERIC_HELP:
wins_status_bar();
help_screen();
wins_update(FLAG_ALL);
break;
case KEY_GENERIC_SAVE:
io_save_cal(IO_SAVE_DISPLAY_BAR);
wins_update(FLAG_STA);
break;
case KEY_GENERIC_IMPORT:
wins_erase_status_bar();
io_import_data(IO_IMPORT_ICAL, NULL);
inday = do_storage(0);
wins_update(FLAG_ALL);
break;
case KEY_GENERIC_EXPORT:
wins_erase_status_bar();
io_export_bar();
while ((key = wgetch(win[STA].p)) != 'q') {
switch (key) {
case 'I':
case 'i':
io_export_data(IO_EXPORT_ICAL);
break;
case 'P':
case 'p':
io_export_data(IO_EXPORT_PCAL);
break;
}
wins_reset();
wins_update(FLAG_ALL);
wins_erase_status_bar();
io_export_bar();
}
inday = do_storage(0);
wins_update(FLAG_ALL);
break;
case KEY_GENERIC_NEXT_DAY:
case KEY_MOVE_RIGHT:
if (wins_slctd() == CAL || key == KEY_GENERIC_NEXT_DAY) {
calendar_move(RIGHT, count);
inday = do_storage(1);
wins_update(FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_PREV_DAY:
case KEY_MOVE_LEFT:
if (wins_slctd() == CAL || key == KEY_GENERIC_PREV_DAY) {
calendar_move(LEFT, count);
inday = do_storage(1);
wins_update(FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_PREV_WEEK:
case KEY_MOVE_UP:
if (wins_slctd() == CAL || key == KEY_GENERIC_PREV_WEEK) {
calendar_move(UP, count);
inday = do_storage(1);
wins_update(FLAG_CAL | FLAG_APP);
} else if (wins_slctd() == APP) {
if (count >= apoint_hilt())
count = apoint_hilt() - 1;
apoint_hilt_decrease(count);
apoint_scroll_pad_up(inday.nb_events);
wins_update(FLAG_APP);
} else if (wins_slctd() == TOD) {
if (count >= todo_hilt())
count = todo_hilt() - 1;
todo_hilt_decrease(count);
if (todo_hilt_pos() < 0)
todo_first_increase(todo_hilt_pos());
wins_update(FLAG_TOD);
}
break;
case KEY_GENERIC_NEXT_WEEK:
case KEY_MOVE_DOWN:
if (wins_slctd() == CAL || key == KEY_GENERIC_NEXT_WEEK) {
calendar_move(DOWN, count);
inday = do_storage(1);
wins_update(FLAG_CAL | FLAG_APP);
} else if (wins_slctd() == APP) {
if (count > inday.nb_events + inday.nb_apoints - apoint_hilt())
count = inday.nb_events + inday.nb_apoints - apoint_hilt();
apoint_hilt_increase(count);
apoint_scroll_pad_down(inday.nb_events, win[APP].h);
wins_update(FLAG_APP);
} else if (wins_slctd() == TOD) {
if (count > todo_nb() - todo_hilt())
count = todo_nb() - todo_hilt();
todo_hilt_increase(count);
if (todo_hilt_pos() >= win[TOD].h - 4)
todo_first_increase(todo_hilt_pos() - win[TOD].h + 5);
wins_update(FLAG_TOD);
}
break;
case KEY_START_OF_WEEK:
if (wins_slctd() == CAL) {
calendar_move(WEEK_START, count);
inday = do_storage(1);
wins_update(FLAG_CAL | FLAG_APP);
}
break;
case KEY_END_OF_WEEK:
if (wins_slctd() == CAL) {
calendar_move(WEEK_END, count);
inday = do_storage(1);
wins_update(FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_SCROLL_UP:
if (wins_slctd() == CAL) {
calendar_view_prev();
wins_update(FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_SCROLL_DOWN:
if (wins_slctd() == CAL) {
calendar_view_next();
wins_update(FLAG_CAL | FLAG_APP);
}
break;
case KEY_GENERIC_QUIT:
if (conf.auto_save)
io_save_cal(IO_SAVE_DISPLAY_BAR);
if (conf.auto_gc)
note_gc();
if (conf.confirm_quit) {
if (status_ask_bool(_("Do you really want to quit ?")) == 1)
exit_calcurse(EXIT_SUCCESS);
else {
wins_erase_status_bar();
wins_update(FLAG_STA);
break;
}
} else
exit_calcurse(EXIT_SUCCESS);
break;
case KEY_RESIZE:
case ERR:
/* Do not reset the count parameter on resize or error. */
continue;
default:
break;
}
count = 0;
}
} }

952
src/calcurse.h
View File

File diff suppressed because it is too large Load Diff

803
src/calendar.c
View File

File diff suppressed because it is too large Load Diff

552
src/config.c
View File

@ -49,28 +49,28 @@ struct confvar {
void *target; void *target;
}; };
static int config_parse_bool (unsigned *, const char *); static int config_parse_bool(unsigned *, const char *);
static int config_serialize_bool (char *, unsigned *); static int config_serialize_bool(char *, unsigned *);
static int config_parse_int (int *, const char *); static int config_parse_int(int *, const char *);
static int config_serialize_int (char *, int *); static int config_serialize_int(char *, int *);
static int config_parse_unsigned (unsigned *, const char *); static int config_parse_unsigned(unsigned *, const char *);
static int config_serialize_unsigned (char *, unsigned *); static int config_serialize_unsigned(char *, unsigned *);
static int config_parse_str (char *, const char *); static int config_parse_str(char *, const char *);
static int config_serialize_str (char *, const char *); static int config_serialize_str(char *, const char *);
static int config_parse_calendar_view (void *, const char *); static int config_parse_calendar_view(void *, const char *);
static int config_serialize_calendar_view (char *, void *); static int config_serialize_calendar_view(char *, void *);
static int config_parse_first_day_of_week (void *, const char *); static int config_parse_first_day_of_week(void *, const char *);
static int config_serialize_first_day_of_week (char *, void *); static int config_serialize_first_day_of_week(char *, void *);
static int config_parse_color_theme (void *, const char *); static int config_parse_color_theme(void *, const char *);
static int config_serialize_color_theme (char *, void *); static int config_serialize_color_theme(char *, void *);
static int config_parse_layout (void *, const char *); static int config_parse_layout(void *, const char *);
static int config_serialize_layout (char *, void *); static int config_serialize_layout(char *, void *);
static int config_parse_sidebar_width (void *, const char *); static int config_parse_sidebar_width(void *, const char *);
static int config_serialize_sidebar_width (char *, void *); static int config_serialize_sidebar_width(char *, void *);
static int config_parse_output_datefmt (void *, const char *); static int config_parse_output_datefmt(void *, const char *);
static int config_serialize_output_datefmt (char *, void *); static int config_serialize_output_datefmt(char *, void *);
static int config_parse_input_datefmt (void *, const char *); static int config_parse_input_datefmt(void *, const char *);
static int config_serialize_input_datefmt (char *, void *); static int config_serialize_input_datefmt(char *, void *);
#define CONFIG_HANDLER_BOOL(var) (config_fn_parse_t) config_parse_bool, \ #define CONFIG_HANDLER_BOOL(var) (config_fn_parse_t) config_parse_bool, \
(config_fn_serialize_t) config_serialize_bool, &(var) (config_fn_serialize_t) config_serialize_bool, &(var)
@ -82,44 +82,49 @@ static int config_serialize_input_datefmt (char *, void *);
(config_fn_serialize_t) config_serialize_str, &(var) (config_fn_serialize_t) config_serialize_str, &(var)
static const struct confvar confmap[] = { static const struct confvar confmap[] = {
{ "appearance.calendarview", config_parse_calendar_view, config_serialize_calendar_view, NULL }, {"appearance.calendarview", config_parse_calendar_view,
{ "appearance.layout", config_parse_layout, config_serialize_layout, NULL }, config_serialize_calendar_view, NULL},
{ "appearance.notifybar", CONFIG_HANDLER_BOOL (nbar.show) }, {"appearance.layout", config_parse_layout, config_serialize_layout, NULL},
{ "appearance.sidebarwidth", config_parse_sidebar_width, config_serialize_sidebar_width, NULL }, {"appearance.notifybar", CONFIG_HANDLER_BOOL(nbar.show)},
{ "appearance.theme", config_parse_color_theme, config_serialize_color_theme, NULL }, {"appearance.sidebarwidth", config_parse_sidebar_width,
{ "daemon.enable", CONFIG_HANDLER_BOOL (dmon.enable) }, config_serialize_sidebar_width, NULL},
{ "daemon.log", CONFIG_HANDLER_BOOL (dmon.log) }, {"appearance.theme", config_parse_color_theme, config_serialize_color_theme,
{ "format.inputdate", config_parse_input_datefmt, config_serialize_input_datefmt, NULL }, NULL},
{ "format.notifydate", CONFIG_HANDLER_STR (nbar.datefmt) }, {"daemon.enable", CONFIG_HANDLER_BOOL(dmon.enable)},
{ "format.notifytime", CONFIG_HANDLER_STR (nbar.timefmt) }, {"daemon.log", CONFIG_HANDLER_BOOL(dmon.log)},
{ "format.outputdate", config_parse_output_datefmt, config_serialize_output_datefmt, NULL }, {"format.inputdate", config_parse_input_datefmt,
{ "general.autogc", CONFIG_HANDLER_BOOL (conf.auto_gc) }, config_serialize_input_datefmt, NULL},
{ "general.autosave", CONFIG_HANDLER_BOOL (conf.auto_save) }, {"format.notifydate", CONFIG_HANDLER_STR(nbar.datefmt)},
{ "general.confirmdelete", CONFIG_HANDLER_BOOL (conf.confirm_delete) }, {"format.notifytime", CONFIG_HANDLER_STR(nbar.timefmt)},
{ "general.confirmquit", CONFIG_HANDLER_BOOL (conf.confirm_quit) }, {"format.outputdate", config_parse_output_datefmt,
{ "general.firstdayofweek", config_parse_first_day_of_week, config_serialize_first_day_of_week, NULL }, config_serialize_output_datefmt, NULL},
{ "general.periodicsave", CONFIG_HANDLER_UNSIGNED (conf.periodic_save) }, {"general.autogc", CONFIG_HANDLER_BOOL(conf.auto_gc)},
{ "general.progressbar", CONFIG_HANDLER_BOOL (conf.progress_bar) }, {"general.autosave", CONFIG_HANDLER_BOOL(conf.auto_save)},
{ "general.systemdialogs", CONFIG_HANDLER_BOOL (conf.system_dialogs) }, {"general.confirmdelete", CONFIG_HANDLER_BOOL(conf.confirm_delete)},
{ "notification.command", CONFIG_HANDLER_STR (nbar.cmd) }, {"general.confirmquit", CONFIG_HANDLER_BOOL(conf.confirm_quit)},
{ "notification.notifyall", CONFIG_HANDLER_BOOL (nbar.notify_all) }, {"general.firstdayofweek", config_parse_first_day_of_week,
{ "notification.warning", CONFIG_HANDLER_INT (nbar.cntdwn) } config_serialize_first_day_of_week, NULL},
{"general.periodicsave", CONFIG_HANDLER_UNSIGNED(conf.periodic_save)},
{"general.progressbar", CONFIG_HANDLER_BOOL(conf.progress_bar)},
{"general.systemdialogs", CONFIG_HANDLER_BOOL(conf.system_dialogs)},
{"notification.command", CONFIG_HANDLER_STR(nbar.cmd)},
{"notification.notifyall", CONFIG_HANDLER_BOOL(nbar.notify_all)},
{"notification.warning", CONFIG_HANDLER_INT(nbar.cntdwn)}
}; };
struct config_save_status { struct config_save_status {
FILE *fp; FILE *fp;
int done[sizeof (confmap) / sizeof (confmap[0])]; int done[sizeof(confmap) / sizeof(confmap[0])];
}; };
typedef int (*config_fn_walk_cb_t) (const char *, const char *, void *); typedef int (*config_fn_walk_cb_t) (const char *, const char *, void *);
typedef int (*config_fn_walk_junk_cb_t) (const char *, void *); typedef int (*config_fn_walk_junk_cb_t) (const char *, void *);
static int static int config_parse_bool(unsigned *dest, const char *val)
config_parse_bool (unsigned *dest, const char *val)
{ {
if (strcmp (val, "yes") == 0) if (strcmp(val, "yes") == 0)
*dest = 1; *dest = 1;
else if (strcmp (val, "no") == 0) else if (strcmp(val, "no") == 0)
*dest = 0; *dest = 0;
else else
return 0; return 0;
@ -127,55 +132,51 @@ config_parse_bool (unsigned *dest, const char *val)
return 1; return 1;
} }
static int static int config_parse_unsigned(unsigned *dest, const char *val)
config_parse_unsigned (unsigned *dest, const char *val)
{ {
if (is_all_digit (val)) if (is_all_digit(val))
*dest = atoi (val); *dest = atoi(val);
else else
return 0; return 0;
return 1; return 1;
} }
static int static int config_parse_int(int *dest, const char *val)
config_parse_int (int *dest, const char *val)
{ {
if ((*val == '+' || *val == '-' || isdigit (*val)) && is_all_digit (val + 1)) if ((*val == '+' || *val == '-' || isdigit(*val)) && is_all_digit(val + 1))
*dest = atoi (val); *dest = atoi(val);
else else
return 0; return 0;
return 1; return 1;
} }
static int static int config_parse_str(char *dest, const char *val)
config_parse_str (char *dest, const char *val)
{ {
strncpy (dest, val, BUFSIZ); strncpy(dest, val, BUFSIZ);
return 1; return 1;
} }
static int static int config_parse_color(int *dest, const char *val)
config_parse_color (int *dest, const char *val)
{ {
if (!strcmp (val, "black")) if (!strcmp(val, "black"))
*dest = COLOR_BLACK; *dest = COLOR_BLACK;
else if (!strcmp (val, "red")) else if (!strcmp(val, "red"))
*dest = COLOR_RED; *dest = COLOR_RED;
else if (!strcmp (val, "green")) else if (!strcmp(val, "green"))
*dest = COLOR_GREEN; *dest = COLOR_GREEN;
else if (!strcmp (val, "yellow")) else if (!strcmp(val, "yellow"))
*dest = COLOR_YELLOW; *dest = COLOR_YELLOW;
else if (!strcmp (val, "blue")) else if (!strcmp(val, "blue"))
*dest = COLOR_BLUE; *dest = COLOR_BLUE;
else if (!strcmp (val, "magenta")) else if (!strcmp(val, "magenta"))
*dest = COLOR_MAGENTA; *dest = COLOR_MAGENTA;
else if (!strcmp (val, "cyan")) else if (!strcmp(val, "cyan"))
*dest = COLOR_CYAN; *dest = COLOR_CYAN;
else if (!strcmp (val, "white")) else if (!strcmp(val, "white"))
*dest = COLOR_WHITE; *dest = COLOR_WHITE;
else if (!strcmp (val, "default")) else if (!strcmp(val, "default"))
*dest = background; *dest = background;
else else
return 0; return 0;
@ -183,137 +184,119 @@ config_parse_color (int *dest, const char *val)
return 1; return 1;
} }
static int static int config_parse_color_pair(int *dest1, int *dest2, const char *val)
config_parse_color_pair (int *dest1, int *dest2, const char *val)
{ {
char s1[BUFSIZ], s2[BUFSIZ]; char s1[BUFSIZ], s2[BUFSIZ];
if (sscanf (val, "%s on %s", s1, s2) != 2) if (sscanf(val, "%s on %s", s1, s2) != 2)
return 0; return 0;
return (config_parse_color (dest1, s1) && config_parse_color (dest2, s2)); return (config_parse_color(dest1, s1) && config_parse_color(dest2, s2));
} }
static int static int config_parse_calendar_view(void *dummy, const char *val)
config_parse_calendar_view (void *dummy, const char *val)
{ {
calendar_set_view (atoi (val)); calendar_set_view(atoi(val));
return 1; return 1;
} }
static int static int config_parse_first_day_of_week(void *dummy, const char *val)
config_parse_first_day_of_week (void *dummy, const char *val)
{ {
if (!strcmp (val, "monday")) if (!strcmp(val, "monday"))
calendar_set_first_day_of_week (MONDAY); calendar_set_first_day_of_week(MONDAY);
else if (!strcmp (val, "sunday")) else if (!strcmp(val, "sunday"))
calendar_set_first_day_of_week (SUNDAY); calendar_set_first_day_of_week(SUNDAY);
else else
return 0; return 0;
return 1; return 1;
} }
static int static int config_parse_color_theme(void *dummy, const char *val)
config_parse_color_theme (void *dummy, const char *val)
{ {
int color1, color2; int color1, color2;
if (!config_parse_color_pair (&color1, &color2, val)) if (!config_parse_color_pair(&color1, &color2, val))
return 0; return 0;
init_pair (COLR_CUSTOM, color1, color2); init_pair(COLR_CUSTOM, color1, color2);
return 1; return 1;
} }
static int static int config_parse_layout(void *dummy, const char *val)
config_parse_layout (void *dummy, const char *val)
{ {
wins_set_layout (atoi (val)); wins_set_layout(atoi(val));
return 1; return 1;
} }
static int static int config_parse_sidebar_width(void *dummy, const char *val)
config_parse_sidebar_width (void *dummy, const char *val)
{ {
wins_set_sbar_width (atoi (val)); wins_set_sbar_width(atoi(val));
return 1; return 1;
} }
static int static int config_parse_output_datefmt(void *dummy, const char *val)
config_parse_output_datefmt (void *dummy, const char *val)
{ {
if (val[0] != '\0') if (val[0] != '\0')
return config_parse_str (conf.output_datefmt, val); return config_parse_str(conf.output_datefmt, val);
return 1; return 1;
} }
static int static int config_parse_input_datefmt(void *dummy, const char *val)
config_parse_input_datefmt (void *dummy, const char *val)
{ {
if (config_parse_int (&conf.input_datefmt, val)) { if (config_parse_int(&conf.input_datefmt, val)) {
if (conf.input_datefmt <= 0 || conf.input_datefmt >= DATE_FORMATS) if (conf.input_datefmt <= 0 || conf.input_datefmt >= DATE_FORMATS)
conf.input_datefmt = 1; conf.input_datefmt = 1;
return 1; return 1;
} } else
else
return 0; return 0;
} }
/* Set a configuration variable. */ /* Set a configuration variable. */
static int static int config_set_conf(const char *key, const char *value)
config_set_conf (const char *key, const char *value)
{ {
int i; int i;
if (!key) if (!key)
return -1; return -1;
for (i = 0; i < sizeof (confmap) / sizeof (confmap[0]); i++) for (i = 0; i < sizeof(confmap) / sizeof(confmap[0]); i++) {
{ if (!strcmp(confmap[i].key, key))
if (!strcmp (confmap[i].key, key)) return confmap[i].fn_parse(confmap[i].target, value);
return confmap[i].fn_parse (confmap[i].target, value); }
}
return -1; return -1;
} }
static int static int config_serialize_bool(char *dest, unsigned *val)
config_serialize_bool (char *dest, unsigned *val)
{ {
if (*val) if (*val) {
{ dest[0] = 'y';
dest[0] = 'y'; dest[1] = 'e';
dest[1] = 'e'; dest[2] = 's';
dest[2] = 's'; dest[3] = '\0';
dest[3] = '\0'; } else {
} dest[0] = 'n';
else dest[1] = 'o';
{ dest[2] = '\0';
dest[0] = 'n'; }
dest[1] = 'o';
dest[2] = '\0';
}
return 1; return 1;
} }
static int static int config_serialize_unsigned(char *dest, unsigned *val)
config_serialize_unsigned (char *dest, unsigned *val)
{ {
snprintf (dest, BUFSIZ, "%u", *val); snprintf(dest, BUFSIZ, "%u", *val);
return 1; return 1;
} }
static int static int config_serialize_int(char *dest, int *val)
config_serialize_int (char *dest, int *val)
{ {
snprintf (dest, BUFSIZ, "%d", *val); snprintf(dest, BUFSIZ, "%d", *val);
return 1; return 1;
} }
static int static int config_serialize_str(char *dest, const char *val)
config_serialize_str (char *dest, const char *val)
{ {
strncpy (dest, val, BUFSIZ); strncpy(dest, val, BUFSIZ);
return 1; return 1;
} }
@ -325,8 +308,7 @@ config_serialize_str (char *dest, const char *val)
* If ncurses library was compiled with --enable-ext-funcs, * If ncurses library was compiled with --enable-ext-funcs,
* then default color is -1. * then default color is -1.
*/ */
static void static void config_color_theme_name(char *theme_name)
config_color_theme_name (char *theme_name)
{ {
#define MAXCOLORS 8 #define MAXCOLORS 8
#define NBCOLORS 2 #define NBCOLORS 2
@ -349,37 +331,32 @@ config_color_theme_name (char *theme_name)
}; };
if (!colorize) if (!colorize)
strncpy (theme_name, "0", BUFSIZ); strncpy(theme_name, "0", BUFSIZ);
else else {
{ pair_content(COLR_CUSTOM, &color[0], &color[1]);
pair_content (COLR_CUSTOM, &color[0], &color[1]); for (i = 0; i < NBCOLORS; i++) {
for (i = 0; i < NBCOLORS; i++) if ((color[i] == DEFAULTCOLOR) || (color[i] == DEFAULTCOLOR_EXT))
{ color_name[i] = default_color;
if ((color[i] == DEFAULTCOLOR) || (color[i] == DEFAULTCOLOR_EXT)) else if (color[i] >= 0 && color[i] <= MAXCOLORS)
color_name[i] = default_color; color_name[i] = name[color[i]];
else if (color[i] >= 0 && color[i] <= MAXCOLORS) else {
color_name[i] = name[color[i]]; EXIT(_("unknown color"));
else /* NOTREACHED */
{ }
EXIT (_("unknown color"));
/* NOTREACHED */
}
}
snprintf (theme_name, BUFSIZ, "%s on %s", color_name[0], color_name[1]);
} }
snprintf(theme_name, BUFSIZ, "%s on %s", color_name[0], color_name[1]);
}
} }
static int static int config_serialize_calendar_view(char *buf, void *dummy)
config_serialize_calendar_view (char *buf, void *dummy)
{ {
int tmp = calendar_get_view (); int tmp = calendar_get_view();
return config_serialize_int (buf, &tmp); return config_serialize_int(buf, &tmp);
} }
static int static int config_serialize_first_day_of_week(char *buf, void *dummy)
config_serialize_first_day_of_week (char *buf, void *dummy)
{ {
if (calendar_week_begins_on_monday ()) if (calendar_week_begins_on_monday())
strcpy(buf, "monday"); strcpy(buf, "monday");
else else
strcpy(buf, "sunday"); strcpy(buf, "sunday");
@ -387,195 +364,177 @@ config_serialize_first_day_of_week (char *buf, void *dummy)
return 1; return 1;
} }
static int static int config_serialize_color_theme(char *buf, void *dummy)
config_serialize_color_theme (char *buf, void *dummy)
{ {
config_color_theme_name (buf); config_color_theme_name(buf);
return 1; return 1;
} }
static int static int config_serialize_layout(char *buf, void *dummy)
config_serialize_layout (char *buf, void *dummy)
{ {
int tmp = wins_layout (); int tmp = wins_layout();
return config_serialize_int (buf, &tmp); return config_serialize_int(buf, &tmp);
} }
static int static int config_serialize_sidebar_width(char *buf, void *dummy)
config_serialize_sidebar_width (char *buf, void *dummy)
{ {
int tmp = wins_sbar_wperc (); int tmp = wins_sbar_wperc();
return config_serialize_int (buf, &tmp); return config_serialize_int(buf, &tmp);
} }
static int static int config_serialize_output_datefmt(char *buf, void *dummy)
config_serialize_output_datefmt (char *buf, void *dummy)
{ {
return config_serialize_str (buf, conf.output_datefmt); return config_serialize_str(buf, conf.output_datefmt);
} }
static int static int config_serialize_input_datefmt(char *buf, void *dummy)
config_serialize_input_datefmt (char *buf, void *dummy)
{ {
return config_serialize_int (buf, &conf.input_datefmt); return config_serialize_int(buf, &conf.input_datefmt);
} }
/* Serialize the value of a configuration variable. */ /* Serialize the value of a configuration variable. */
static int static int
config_serialize_conf (char *buf, const char *key, config_serialize_conf(char *buf, const char *key,
struct config_save_status *status) struct config_save_status *status)
{ {
int i; int i;
if (!key) if (!key)
return -1; return -1;
for (i = 0; i < sizeof (confmap) / sizeof (confmap[0]); i++) for (i = 0; i < sizeof(confmap) / sizeof(confmap[0]); i++) {
{ if (!strcmp(confmap[i].key, key)) {
if (!strcmp (confmap[i].key, key)) if (confmap[i].fn_serialize(buf, confmap[i].target)) {
{ if (status)
if (confmap[i].fn_serialize (buf, confmap[i].target)) status->done[i] = 1;
{ return 1;
if (status) } else
status->done[i] = 1; return 0;
return 1;
}
else
return 0;
}
} }
}
return -1; return -1;
} }
static void static void
config_file_walk (config_fn_walk_cb_t fn_cb, config_file_walk(config_fn_walk_cb_t fn_cb,
config_fn_walk_junk_cb_t fn_junk_cb, void *data) config_fn_walk_junk_cb_t fn_junk_cb, void *data)
{ {
FILE *data_file; FILE *data_file;
char buf[BUFSIZ], e_conf[BUFSIZ]; char buf[BUFSIZ], e_conf[BUFSIZ];
char *key, *value; char *key, *value;
data_file = fopen (path_conf, "r"); data_file = fopen(path_conf, "r");
EXIT_IF (data_file == NULL, _("failed to open configuration file")); EXIT_IF(data_file == NULL, _("failed to open configuration file"));
pthread_mutex_lock (&nbar.mutex); pthread_mutex_lock(&nbar.mutex);
for (;;) for (;;) {
{ if (fgets(buf, sizeof buf, data_file) == NULL)
if (fgets (buf, sizeof buf, data_file) == NULL) break;
break; io_extract_data(e_conf, buf, sizeof buf);
io_extract_data (e_conf, buf, sizeof buf);
if (*e_conf == '\0') if (*e_conf == '\0') {
{ if (fn_junk_cb)
if (fn_junk_cb) fn_junk_cb(buf, data);
fn_junk_cb (buf, data); continue;
continue;
}
key = e_conf;
value = strchr (e_conf, '=');
if (value)
{
*value = '\0';
value++;
}
if (strcmp(key, "auto_save") == 0 ||
strcmp(key, "auto_gc") == 0 ||
strcmp(key, "periodic_save") == 0 ||
strcmp(key, "confirm_quit") == 0 ||
strcmp(key, "confirm_delete") == 0 ||
strcmp(key, "skip_system_dialogs") == 0 ||
strcmp(key, "skip_progress_bar") == 0 ||
strcmp(key, "calendar_default_view") == 0 ||
strcmp(key, "week_begins_on_monday") == 0 ||
strcmp(key, "color-theme") == 0 ||
strcmp(key, "layout") == 0 ||
strcmp(key, "side-bar_width") == 0 ||
strcmp(key, "notify-bar_show") == 0 ||
strcmp(key, "notify-bar_date") == 0 ||
strcmp(key, "notify-bar_clock") == 0 ||
strcmp(key, "notify-bar_warning") == 0 ||
strcmp(key, "notify-bar_command") == 0 ||
strcmp(key, "notify-all") == 0 ||
strcmp(key, "output_datefmt") == 0 ||
strcmp(key, "input_datefmt") == 0 ||
strcmp(key, "notify-daemon_enable") == 0 ||
strcmp(key, "notify-daemon_log") == 0)
{
WARN_MSG (_("Pre-3.0.0 configuration file format detected, "
"please upgrade running `calcurse-upgrade`."));
}
if (value && (*value == '\0' || *value == '\n'))
{
/* Backward compatibility mode. */
if (fgets (buf, sizeof buf, data_file) == NULL)
break;
io_extract_data (e_conf, buf, sizeof buf);
value = e_conf;
}
fn_cb (key, value, data);
} }
file_close (data_file, __FILE_POS__);
pthread_mutex_unlock (&nbar.mutex); key = e_conf;
value = strchr(e_conf, '=');
if (value) {
*value = '\0';
value++;
}
if (strcmp(key, "auto_save") == 0 ||
strcmp(key, "auto_gc") == 0 ||
strcmp(key, "periodic_save") == 0 ||
strcmp(key, "confirm_quit") == 0 ||
strcmp(key, "confirm_delete") == 0 ||
strcmp(key, "skip_system_dialogs") == 0 ||
strcmp(key, "skip_progress_bar") == 0 ||
strcmp(key, "calendar_default_view") == 0 ||
strcmp(key, "week_begins_on_monday") == 0 ||
strcmp(key, "color-theme") == 0 ||
strcmp(key, "layout") == 0 ||
strcmp(key, "side-bar_width") == 0 ||
strcmp(key, "notify-bar_show") == 0 ||
strcmp(key, "notify-bar_date") == 0 ||
strcmp(key, "notify-bar_clock") == 0 ||
strcmp(key, "notify-bar_warning") == 0 ||
strcmp(key, "notify-bar_command") == 0 ||
strcmp(key, "notify-all") == 0 ||
strcmp(key, "output_datefmt") == 0 ||
strcmp(key, "input_datefmt") == 0 ||
strcmp(key, "notify-daemon_enable") == 0 ||
strcmp(key, "notify-daemon_log") == 0) {
WARN_MSG(_("Pre-3.0.0 configuration file format detected, "
"please upgrade running `calcurse-upgrade`."));
}
if (value && (*value == '\0' || *value == '\n')) {
/* Backward compatibility mode. */
if (fgets(buf, sizeof buf, data_file) == NULL)
break;
io_extract_data(e_conf, buf, sizeof buf);
value = e_conf;
}
fn_cb(key, value, data);
}
file_close(data_file, __FILE_POS__);
pthread_mutex_unlock(&nbar.mutex);
} }
static int static int config_load_cb(const char *key, const char *value, void *dummy)
config_load_cb (const char *key, const char *value, void *dummy)
{ {
int result = config_set_conf (key, value); int result = config_set_conf(key, value);
if (result < 0) if (result < 0)
EXIT (_("configuration variable unknown: \"%s\""), key); EXIT(_("configuration variable unknown: \"%s\""), key);
/* NOTREACHED */ /* NOTREACHED */
else if (result == 0) else if (result == 0)
EXIT (_("wrong configuration variable format for \"%s\""), key); EXIT(_("wrong configuration variable format for \"%s\""), key);
/* NOTREACHED */ /* NOTREACHED */
return 1; return 1;
} }
/* Load the user configuration. */ /* Load the user configuration. */
void void config_load(void)
config_load (void)
{ {
config_file_walk (config_load_cb, NULL, NULL); config_file_walk(config_load_cb, NULL, NULL);
} }
static int static int config_save_cb(const char *key, const char *value, void *status)
config_save_cb (const char *key, const char *value, void *status)
{ {
char buf[BUFSIZ]; char buf[BUFSIZ];
int result = config_serialize_conf (buf, key, (struct config_save_status *) status); int result =
config_serialize_conf(buf, key, (struct config_save_status *)status);
if (result < 0) if (result < 0)
EXIT (_("configuration variable unknown: \"%s\""), key); EXIT(_("configuration variable unknown: \"%s\""), key);
/* NOTREACHED */ /* NOTREACHED */
else if (result == 0) else if (result == 0)
EXIT (_("wrong configuration variable format for \"%s\""), key); EXIT(_("wrong configuration variable format for \"%s\""), key);
/* NOTREACHED */ /* NOTREACHED */
fputs (key, ((struct config_save_status *) status)->fp); fputs(key, ((struct config_save_status *)status)->fp);
fputc ('=', ((struct config_save_status *) status)->fp); fputc('=', ((struct config_save_status *)status)->fp);
fputs (buf, ((struct config_save_status *) status)->fp); fputs(buf, ((struct config_save_status *)status)->fp);
fputc ('\n', ((struct config_save_status *) status)->fp); fputc('\n', ((struct config_save_status *)status)->fp);
return 1; return 1;
} }
static int static int config_save_junk_cb(const char *data, void *status)
config_save_junk_cb (const char *data, void *status)
{ {
fputs (data, ((struct config_save_status *) status)->fp); fputs(data, ((struct config_save_status *)status)->fp);
return 1; return 1;
} }
/* Save the user configuration. */ /* Save the user configuration. */
unsigned unsigned config_save(void)
config_save (void)
{ {
char tmppath[BUFSIZ]; char tmppath[BUFSIZ];
char *tmpext; char *tmpext;
@ -585,32 +544,31 @@ config_save (void)
if (read_only) if (read_only)
return 1; return 1;
strncpy (tmppath, get_tempdir (), BUFSIZ); strncpy(tmppath, get_tempdir(), BUFSIZ);
strncat (tmppath, "/" CONF_PATH_NAME ".", BUFSIZ - strlen (tmppath) - 1); strncat(tmppath, "/" CONF_PATH_NAME ".", BUFSIZ - strlen(tmppath) - 1);
if ((tmpext = new_tempfile (tmppath, TMPEXTSIZ)) == NULL) if ((tmpext = new_tempfile(tmppath, TMPEXTSIZ)) == NULL)
return 0; return 0;
strncat (tmppath, tmpext, BUFSIZ - strlen (tmppath) - 1); strncat(tmppath, tmpext, BUFSIZ - strlen(tmppath) - 1);
mem_free (tmpext); mem_free(tmpext);
status.fp = fopen (tmppath, "w"); status.fp = fopen(tmppath, "w");
if (!status.fp) if (!status.fp)
return 0; return 0;
memset (status.done, 0, sizeof (status.done)); memset(status.done, 0, sizeof(status.done));
config_file_walk (config_save_cb, config_save_junk_cb, (void *) &status); config_file_walk(config_save_cb, config_save_junk_cb, (void *)&status);
/* Set variables that were missing from the configuration file. */ /* Set variables that were missing from the configuration file. */
for (i = 0; i < sizeof (confmap) / sizeof (confmap[0]); i++) for (i = 0; i < sizeof(confmap) / sizeof(confmap[0]); i++) {
{ if (!status.done[i])
if (!status.done[i]) config_save_cb(confmap[i].key, NULL, &status);
config_save_cb (confmap[i].key, NULL, &status); }
}
file_close (status.fp, __FILE_POS__); file_close(status.fp, __FILE_POS__);
if (io_file_cp (tmppath, path_conf)) if (io_file_cp(tmppath, path_conf))
unlink (tmppath); unlink(tmppath);
return 1; return 1;
} }

1482
src/custom.c
View File

File diff suppressed because it is too large Load Diff

1266
src/day.c
View File

File diff suppressed because it is too large Load Diff

169
src/dmon.c
View File

@ -64,26 +64,22 @@
static unsigned data_loaded; static unsigned data_loaded;
static void static void dmon_sigs_hdlr(int sig)
dmon_sigs_hdlr (int sig)
{ {
if (data_loaded) if (data_loaded)
free_user_data (); free_user_data();
DMON_LOG (_("terminated at %s with signal %d\n"), nowstr (), sig); DMON_LOG(_("terminated at %s with signal %d\n"), nowstr(), sig);
if (unlink (path_dpid) != 0) if (unlink(path_dpid) != 0) {
{ DMON_LOG(_("Could not remove daemon lock file: %s\n"), strerror(errno));
DMON_LOG (_("Could not remove daemon lock file: %s\n"), exit(EXIT_FAILURE);
strerror (errno)); }
exit (EXIT_FAILURE);
}
exit (EXIT_SUCCESS); exit(EXIT_SUCCESS);
} }
static unsigned static unsigned daemonize(int status)
daemonize (int status)
{ {
int fd; int fd;
@ -93,16 +89,15 @@ daemonize (int status)
* First need to fork in order to become a child of the init process, * First need to fork in order to become a child of the init process,
* once the father exits. * once the father exits.
*/ */
switch (fork ()) switch (fork()) {
{ case -1: /* fork error */
case -1: /* fork error */ EXIT(_("Could not fork: %s\n"), strerror(errno));
EXIT (_("Could not fork: %s\n"), strerror (errno)); break;
break; case 0: /* child */
case 0: /* child */ break;
break; default: /* parent */
default: /* parent */ exit(status);
exit (status); }
}
/* /*
* Process independency. * Process independency.
@ -110,109 +105,99 @@ daemonize (int status)
* Obtain a new process group and session in order to get detached from the * Obtain a new process group and session in order to get detached from the
* controlling terminal. * controlling terminal.
*/ */
if (setsid () == -1) if (setsid() == -1) {
{ DMON_LOG(_("Could not detach from the controlling terminal: %s\n"),
DMON_LOG (_("Could not detach from the controlling terminal: %s\n"), strerror(errno));
strerror (errno)); return 0;
return 0; }
}
/* /*
* Change working directory to root directory, * Change working directory to root directory,
* to prevent filesystem unmounts. * to prevent filesystem unmounts.
*/ */
if (chdir ("/") == -1) if (chdir("/") == -1) {
{ DMON_LOG(_("Could not change working directory: %s\n"), strerror(errno));
DMON_LOG (_("Could not change working directory: %s\n"), return 0;
strerror (errno)); }
return 0;
}
/* Redirect standard file descriptors to /dev/null. */ /* Redirect standard file descriptors to /dev/null. */
if ((fd = open (_PATH_DEVNULL, O_RDWR, 0)) != -1) if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
{ dup2(fd, STDIN_FILENO);
dup2 (fd, STDIN_FILENO); dup2(fd, STDOUT_FILENO);
dup2 (fd, STDOUT_FILENO); dup2(fd, STDERR_FILENO);
dup2 (fd, STDERR_FILENO); if (fd > 2)
if (fd > 2) close(fd);
close (fd); }
}
/* Write access for the owner only. */ /* Write access for the owner only. */
umask (0022); umask(0022);
if (!sigs_set_hdlr (SIGINT, dmon_sigs_hdlr) if (!sigs_set_hdlr(SIGINT, dmon_sigs_hdlr)
|| !sigs_set_hdlr (SIGTERM, dmon_sigs_hdlr) || !sigs_set_hdlr(SIGTERM, dmon_sigs_hdlr)
|| !sigs_set_hdlr (SIGALRM, dmon_sigs_hdlr) || !sigs_set_hdlr(SIGALRM, dmon_sigs_hdlr)
|| !sigs_set_hdlr (SIGQUIT, dmon_sigs_hdlr) || !sigs_set_hdlr(SIGQUIT, dmon_sigs_hdlr)
|| !sigs_set_hdlr (SIGCHLD, SIG_IGN)) || !sigs_set_hdlr(SIGCHLD, SIG_IGN))
return 0; return 0;
return 1; return 1;
} }
void void dmon_start(int parent_exit_status)
dmon_start (int parent_exit_status)
{ {
if (!daemonize (parent_exit_status)) if (!daemonize(parent_exit_status))
DMON_ABRT (_("Cannot daemonize, aborting\n")); DMON_ABRT(_("Cannot daemonize, aborting\n"));
if (!io_dump_pid (path_dpid)) if (!io_dump_pid(path_dpid))
DMON_ABRT (_("Could not set lock file\n")); DMON_ABRT(_("Could not set lock file\n"));
if (!io_file_exist (path_conf)) if (!io_file_exist(path_conf))
DMON_ABRT (_("Could not access \"%s\": %s\n"), DMON_ABRT(_("Could not access \"%s\": %s\n"), path_conf, strerror(errno));
path_conf, strerror (errno)); config_load();
config_load ();
if (!io_file_exist (path_apts)) if (!io_file_exist(path_apts))
DMON_ABRT (_("Could not access \"%s\": %s\n"), DMON_ABRT(_("Could not access \"%s\": %s\n"), path_apts, strerror(errno));
path_apts, strerror (errno)); apoint_llist_init();
apoint_llist_init (); recur_apoint_llist_init();
recur_apoint_llist_init (); event_llist_init();
event_llist_init (); todo_init_list();
todo_init_list (); io_load_app();
io_load_app ();
data_loaded = 1; data_loaded = 1;
DMON_LOG (_("started at %s\n"), nowstr ()); DMON_LOG(_("started at %s\n"), nowstr());
for (;;) for (;;) {
{ int left;
int left;
if (!notify_get_next_bkgd ()) if (!notify_get_next_bkgd())
DMON_ABRT (_("error loading next appointment\n")); DMON_ABRT(_("error loading next appointment\n"));
left = notify_time_left (); left = notify_time_left();
if (left > 0 && left < nbar.cntdwn && notify_needs_reminder ()) if (left > 0 && left < nbar.cntdwn && notify_needs_reminder()) {
{ DMON_LOG(_("launching notification at %s for: \"%s\"\n"),
DMON_LOG (_("launching notification at %s for: \"%s\"\n"), nowstr(), notify_app_txt());
nowstr (), notify_app_txt ()); if (!notify_launch_cmd())
if (!notify_launch_cmd ()) DMON_LOG(_("error while sending notification\n"));
DMON_LOG (_("error while sending notification\n"));
}
DMON_LOG (ngettext ("sleeping at %s for %d second\n",
"sleeping at %s for %d seconds\n",
DMON_SLEEP_TIME), nowstr (), DMON_SLEEP_TIME);
psleep (DMON_SLEEP_TIME);
DMON_LOG (_("awakened at %s\n"), nowstr ());
} }
DMON_LOG(ngettext("sleeping at %s for %d second\n",
"sleeping at %s for %d seconds\n",
DMON_SLEEP_TIME), nowstr(), DMON_SLEEP_TIME);
psleep(DMON_SLEEP_TIME);
DMON_LOG(_("awakened at %s\n"), nowstr());
}
} }
/* /*
* Check if calcurse is running in background, and if yes, send a SIGINT * Check if calcurse is running in background, and if yes, send a SIGINT
* signal to stop it. * signal to stop it.
*/ */
void void dmon_stop(void)
dmon_stop (void)
{ {
int dpid; int dpid;
dpid = io_get_pid (path_dpid); dpid = io_get_pid(path_dpid);
if (!dpid) if (!dpid)
return; return;
if (kill ((pid_t)dpid, SIGINT) < 0 && errno != ESRCH) if (kill((pid_t) dpid, SIGINT) < 0 && errno != ESRCH)
EXIT (_("Could not stop calcurse daemon: %s\n"), strerror (errno)); EXIT(_("Could not stop calcurse daemon: %s\n"), strerror(errno));
} }

160
src/event.c
View File

@ -41,118 +41,106 @@
#include "calcurse.h" #include "calcurse.h"
llist_t eventlist; llist_t eventlist;
static struct event bkp_cut_event; static struct event bkp_cut_event;
void void event_free_bkp(void)
event_free_bkp (void)
{ {
if (bkp_cut_event.mesg) if (bkp_cut_event.mesg) {
{ mem_free(bkp_cut_event.mesg);
mem_free (bkp_cut_event.mesg); bkp_cut_event.mesg = 0;
bkp_cut_event.mesg = 0; }
} erase_note(&bkp_cut_event.note);
erase_note (&bkp_cut_event.note);
} }
static void static void event_free(struct event *ev)
event_free (struct event *ev)
{ {
mem_free (ev->mesg); mem_free(ev->mesg);
erase_note (&ev->note); erase_note(&ev->note);
mem_free (ev); mem_free(ev);
} }
static void static void event_dup(struct event *in, struct event *bkp)
event_dup (struct event *in, struct event *bkp)
{ {
EXIT_IF (!in || !bkp, _("null pointer")); EXIT_IF(!in || !bkp, _("null pointer"));
bkp->id = in->id; bkp->id = in->id;
bkp->day = in->day; bkp->day = in->day;
bkp->mesg = mem_strdup (in->mesg); bkp->mesg = mem_strdup(in->mesg);
if (in->note) if (in->note)
bkp->note = mem_strdup (in->note); bkp->note = mem_strdup(in->note);
} }
void void event_llist_init(void)
event_llist_init (void)
{ {
LLIST_INIT (&eventlist); LLIST_INIT(&eventlist);
} }
void void event_llist_free(void)
event_llist_free (void)
{ {
LLIST_FREE_INNER (&eventlist, event_free); LLIST_FREE_INNER(&eventlist, event_free);
LLIST_FREE (&eventlist); LLIST_FREE(&eventlist);
} }
static int static int event_cmp_day(struct event *a, struct event *b)
event_cmp_day (struct event *a, struct event *b)
{ {
return a->day < b->day ? -1 : (a->day == b->day ? 0 : 1); return a->day < b->day ? -1 : (a->day == b->day ? 0 : 1);
} }
/* Create a new event */ /* Create a new event */
struct event * struct event *event_new(char *mesg, char *note, long day, int id)
event_new (char *mesg, char *note, long day, int id)
{ {
struct event *ev; struct event *ev;
ev = mem_malloc (sizeof (struct event)); ev = mem_malloc(sizeof(struct event));
ev->mesg = mem_strdup (mesg); ev->mesg = mem_strdup(mesg);
ev->day = day; ev->day = day;
ev->id = id; ev->id = id;
ev->note = (note != NULL) ? mem_strdup (note) : NULL; ev->note = (note != NULL) ? mem_strdup(note) : NULL;
LLIST_ADD_SORTED (&eventlist, ev, event_cmp_day); LLIST_ADD_SORTED(&eventlist, ev, event_cmp_day);
return ev; return ev;
} }
/* Check if the event belongs to the selected day */ /* Check if the event belongs to the selected day */
unsigned unsigned event_inday(struct event *i, long start)
event_inday (struct event *i, long start)
{ {
return (i->day < start + DAYINSEC && i->day >= start); return (i->day < start + DAYINSEC && i->day >= start);
} }
/* Write to file the event in user-friendly format */ /* Write to file the event in user-friendly format */
void void event_write(struct event *o, FILE * f)
event_write (struct event *o, FILE *f)
{ {
struct tm *lt; struct tm *lt;
time_t t; time_t t;
t = o->day; t = o->day;
lt = localtime (&t); lt = localtime(&t);
fprintf (f, "%02u/%02u/%04u [%d] ", lt->tm_mon + 1, lt->tm_mday, fprintf(f, "%02u/%02u/%04u [%d] ", lt->tm_mon + 1, lt->tm_mday,
1900 + lt->tm_year, o->id); 1900 + lt->tm_year, o->id);
if (o->note != NULL) if (o->note != NULL)
fprintf (f, ">%s ", o->note); fprintf(f, ">%s ", o->note);
fprintf (f, "%s\n", o->mesg); fprintf(f, "%s\n", o->mesg);
} }
/* Load the events from file */ /* Load the events from file */
struct event * struct event *event_scan(FILE * f, struct tm start, int id, char *note)
event_scan (FILE *f, struct tm start, int id, char *note)
{ {
char buf[BUFSIZ], *nl; char buf[BUFSIZ], *nl;
time_t tstart, t; time_t tstart, t;
t = time (NULL); t = time(NULL);
localtime (&t); localtime(&t);
/* Read the event description */ /* Read the event description */
if (!fgets (buf, sizeof buf, f)) if (!fgets(buf, sizeof buf, f))
return NULL; return NULL;
nl = strchr (buf, '\n'); nl = strchr(buf, '\n');
if (nl) if (nl) {
{ *nl = '\0';
*nl = '\0'; }
}
start.tm_hour = 0; start.tm_hour = 0;
start.tm_min = 0; start.tm_min = 0;
start.tm_sec = 0; start.tm_sec = 0;
@ -160,57 +148,53 @@ event_scan (FILE *f, struct tm start, int id, char *note)
start.tm_year -= 1900; start.tm_year -= 1900;
start.tm_mon--; start.tm_mon--;
tstart = mktime (&start); tstart = mktime(&start);
EXIT_IF (tstart == -1, _("date error in the event\n")); EXIT_IF(tstart == -1, _("date error in the event\n"));
return event_new (buf, note, tstart, id); return event_new(buf, note, tstart, id);
} }
/* Retrieve an event from the list, given the day and item position. */ /* Retrieve an event from the list, given the day and item position. */
struct event * struct event *event_get(long day, int pos)
event_get (long day, int pos)
{ {
llist_item_t *i = LLIST_FIND_NTH (&eventlist, pos, day, event_inday); llist_item_t *i = LLIST_FIND_NTH(&eventlist, pos, day, event_inday);
if (i) if (i)
return LLIST_TS_GET_DATA (i); return LLIST_TS_GET_DATA(i);
EXIT (_("event not found")); EXIT(_("event not found"));
/* NOTREACHED */ /* NOTREACHED */
} }
/* Delete an event from the list. */ /* Delete an event from the list. */
void void event_delete_bynum(long start, unsigned num, enum eraseflg flag)
event_delete_bynum (long start, unsigned num, enum eraseflg flag)
{ {
llist_item_t *i = LLIST_FIND_NTH (&eventlist, num, start, event_inday); llist_item_t *i = LLIST_FIND_NTH(&eventlist, num, start, event_inday);
if (!i) if (!i)
EXIT (_("no such appointment")); EXIT(_("no such appointment"));
struct event *ev = LLIST_TS_GET_DATA (i); struct event *ev = LLIST_TS_GET_DATA(i);
switch (flag) switch (flag) {
{ case ERASE_FORCE_ONLY_NOTE:
case ERASE_FORCE_ONLY_NOTE: erase_note(&ev->note);
erase_note (&ev->note); break;
break; case ERASE_CUT:
case ERASE_CUT: event_free_bkp();
event_free_bkp (); event_dup(ev, &bkp_cut_event);
event_dup (ev, &bkp_cut_event); erase_note(&ev->note);
erase_note (&ev->note); /* FALLTHROUGH */
/* FALLTHROUGH */ default:
default: LLIST_REMOVE(&eventlist, i);
LLIST_REMOVE (&eventlist, i); mem_free(ev->mesg);
mem_free (ev->mesg); mem_free(ev);
mem_free (ev); break;
break; }
}
} }
void void event_paste_item(void)
event_paste_item (void)
{ {
event_new (bkp_cut_event.mesg, bkp_cut_event.note, event_new(bkp_cut_event.mesg, bkp_cut_event.note,
date2sec (*calendar_get_slctd_day (), 0, 0), bkp_cut_event.id); date2sec(*calendar_get_slctd_day(), 0, 0), bkp_cut_event.id);
event_free_bkp (); event_free_bkp();
} }

271
src/getstring.c
View File

@ -48,14 +48,13 @@ struct getstr_status {
}; };
/* Print the string at the desired position. */ /* Print the string at the desired position. */
static void static void getstr_print(WINDOW * win, int x, int y, struct getstr_status *st)
getstr_print (WINDOW *win, int x, int y, struct getstr_status *st)
{ {
char c = 0; char c = 0;
/* print string */ /* print string */
mvwaddnstr (win, y, x, &st->s[st->ci[st->scrpos].offset], -1); mvwaddnstr(win, y, x, &st->s[st->ci[st->scrpos].offset], -1);
wclrtoeol (win); wclrtoeol(win);
/* print scrolling indicator */ /* print scrolling indicator */
if (st->scrpos > 0 && st->ci[st->len].dpyoff - if (st->scrpos > 0 && st->ci[st->len].dpyoff -
@ -65,62 +64,57 @@ getstr_print (WINDOW *win, int x, int y, struct getstr_status *st)
c = '<'; c = '<';
else if (st->ci[st->len].dpyoff - st->ci[st->scrpos].dpyoff > col - 2) else if (st->ci[st->len].dpyoff - st->ci[st->scrpos].dpyoff > col - 2)
c = '>'; c = '>';
mvwprintw (win, y, col - 2, " %c", c); mvwprintw(win, y, col - 2, " %c", c);
/* print cursor */ /* print cursor */
wmove (win, y, st->ci[st->pos].dpyoff - st->ci[st->scrpos].dpyoff); wmove(win, y, st->ci[st->pos].dpyoff - st->ci[st->scrpos].dpyoff);
wchgat (win, 1, A_REVERSE, COLR_CUSTOM, NULL); wchgat(win, 1, A_REVERSE, COLR_CUSTOM, NULL);
} }
/* Delete a character at the given position in string. */ /* Delete a character at the given position in string. */
static void static void getstr_del_char(struct getstr_status *st)
getstr_del_char (struct getstr_status *st)
{ {
char *str = st->s + st->ci[st->pos].offset; char *str = st->s + st->ci[st->pos].offset;
int cl = st->ci[st->pos + 1].offset - st->ci[st->pos].offset; int cl = st->ci[st->pos + 1].offset - st->ci[st->pos].offset;
int cw = st->ci[st->pos + 1].dpyoff - st->ci[st->pos].dpyoff; int cw = st->ci[st->pos + 1].dpyoff - st->ci[st->pos].dpyoff;
int i; int i;
memmove (str, str + cl, strlen (str) + 1); memmove(str, str + cl, strlen(str) + 1);
st->len--; st->len--;
for (i = st->pos; i <= st->len; i++) for (i = st->pos; i <= st->len; i++) {
{ st->ci[i].offset = st->ci[i + 1].offset - cl;
st->ci[i].offset = st->ci[i + 1].offset - cl; st->ci[i].dpyoff = st->ci[i + 1].dpyoff - cw;
st->ci[i].dpyoff = st->ci[i + 1].dpyoff - cw; }
}
} }
/* Add a character at the given position in string. */ /* Add a character at the given position in string. */
static void static void getstr_ins_char(struct getstr_status *st, char *c)
getstr_ins_char (struct getstr_status *st, char *c)
{ {
char *str = st->s + st->ci[st->pos].offset; char *str = st->s + st->ci[st->pos].offset;
int cl = UTF8_LENGTH (c[0]); int cl = UTF8_LENGTH(c[0]);
int cw = utf8_width (c); int cw = utf8_width(c);
int i; int i;
memmove (str + cl, str, strlen (str) + 1); memmove(str + cl, str, strlen(str) + 1);
for (i = 0; i < cl; i++, str++) for (i = 0; i < cl; i++, str++)
*str = c[i]; *str = c[i];
for (i = st->len; i >= st->pos; i--) for (i = st->len; i >= st->pos; i--) {
{ st->ci[i + 1].offset = st->ci[i].offset + cl;
st->ci[i + 1].offset = st->ci[i].offset + cl; st->ci[i + 1].dpyoff = st->ci[i].dpyoff + cw;
st->ci[i + 1].dpyoff = st->ci[i].dpyoff + cw; }
}
st->len++; st->len++;
} }
static void static void bell(void)
bell (void)
{ {
putchar ('\a'); putchar('\a');
} }
/* Initialize getstring data structure. */ /* Initialize getstring data structure. */
static void static void
getstr_init (struct getstr_status *st, char *str, struct getstr_charinfo *ci) getstr_init(struct getstr_status *st, char *str, struct getstr_charinfo *ci)
{ {
int width; int width;
@ -128,15 +122,14 @@ getstr_init (struct getstr_status *st, char *str, struct getstr_charinfo *ci)
st->ci = ci; st->ci = ci;
st->len = width = 0; st->len = width = 0;
while (*str) while (*str) {
{ st->ci[st->len].offset = str - st->s;
st->ci[st->len].offset = str - st->s; st->ci[st->len].dpyoff = width;
st->ci[st->len].dpyoff = width;
st->len++; st->len++;
width += utf8_width (str); width += utf8_width(str);
str += UTF8_LENGTH (*str); str += UTF8_LENGTH(*str);
} }
st->ci[st->len].offset = str - st->s; st->ci[st->len].offset = str - st->s;
st->ci[st->len].dpyoff = width; st->ci[st->len].dpyoff = width;
@ -145,30 +138,25 @@ getstr_init (struct getstr_status *st, char *str, struct getstr_charinfo *ci)
} }
/* Scroll left/right if the cursor moves outside the window range. */ /* Scroll left/right if the cursor moves outside the window range. */
static void static void getstr_fixscr(struct getstr_status *st)
getstr_fixscr (struct getstr_status *st)
{ {
const int pgsize = col / 3; const int pgsize = col / 3;
int pgskip; int pgskip;
while (st->pos < st->scrpos) while (st->pos < st->scrpos) {
{ pgskip = 0;
pgskip = 0; while (pgskip < pgsize && st->scrpos > 0) {
while (pgskip < pgsize && st->scrpos > 0) st->scrpos--;
{ pgskip += st->ci[st->scrpos + 1].dpyoff - st->ci[st->scrpos].dpyoff;
st->scrpos--;
pgskip += st->ci[st->scrpos + 1].dpyoff - st->ci[st->scrpos].dpyoff;
}
} }
while (st->ci[st->pos].dpyoff - st->ci[st->scrpos].dpyoff > col - 2) }
{ while (st->ci[st->pos].dpyoff - st->ci[st->scrpos].dpyoff > col - 2) {
pgskip = 0; pgskip = 0;
while (pgskip < pgsize && st->scrpos < st->len) while (pgskip < pgsize && st->scrpos < st->len) {
{ pgskip += st->ci[st->scrpos + 1].dpyoff - st->ci[st->scrpos].dpyoff;
pgskip += st->ci[st->scrpos + 1].dpyoff - st->ci[st->scrpos].dpyoff; st->scrpos++;
st->scrpos++;
}
} }
}
} }
/* /*
@ -179,8 +167,7 @@ getstr_fixscr (struct getstr_status *st)
* environment, otherwise the cursor would move from place to place without * environment, otherwise the cursor would move from place to place without
* control. * control.
*/ */
enum getstr enum getstr getstring(WINDOW * win, char *str, int l, int x, int y)
getstring (WINDOW *win, char *str, int l, int x, int y)
{ {
struct getstr_status st; struct getstr_status st;
struct getstr_charinfo ci[l + 1]; struct getstr_charinfo ci[l + 1];
@ -188,112 +175,106 @@ getstring (WINDOW *win, char *str, int l, int x, int y)
int ch, k; int ch, k;
char c[UTF8_MAXLEN]; char c[UTF8_MAXLEN];
getstr_init (&st, str, ci); getstr_init(&st, str, ci);
custom_apply_attr (win, ATTR_HIGHEST); custom_apply_attr(win, ATTR_HIGHEST);
for (;;) { for (;;) {
getstr_fixscr (&st); getstr_fixscr(&st);
getstr_print (win, x, y, &st); getstr_print(win, x, y, &st);
wins_doupdate (); wins_doupdate();
if ((ch = wgetch (win)) == '\n') break; if ((ch = wgetch(win)) == '\n')
switch (ch) break;
{ switch (ch) {
case KEY_BACKSPACE: /* delete one character */ case KEY_BACKSPACE: /* delete one character */
case 330: case 330:
case 127: case 127:
case CTRL ('H'): case CTRL('H'):
if (st.pos > 0) if (st.pos > 0) {
{ st.pos--;
st.pos--; getstr_del_char(&st);
getstr_del_char (&st); } else
} bell();
else break;
bell (); case CTRL('D'): /* delete next character */
break; if (st.pos < st.len)
case CTRL ('D'): /* delete next character */ getstr_del_char(&st);
if (st.pos < st.len) else
getstr_del_char (&st); bell();
else break;
bell (); case CTRL('W'): /* delete a word */
break; if (st.pos > 0) {
case CTRL ('W'): /* delete a word */ while (st.pos && st.s[st.ci[st.pos - 1].offset] == ' ') {
if (st.pos > 0) { st.pos--;
while (st.pos && st.s[st.ci[st.pos - 1].offset] == ' ') getstr_del_char(&st);
{ }
st.pos--; while (st.pos && st.s[st.ci[st.pos - 1].offset] != ' ') {
getstr_del_char (&st); st.pos--;
} getstr_del_char(&st);
while (st.pos && st.s[st.ci[st.pos - 1].offset] != ' ') }
{ } else
st.pos--; bell();
getstr_del_char (&st); break;
} case CTRL('K'): /* delete to end-of-line */
} st.s[st.ci[st.pos].offset] = 0;
else st.len = st.pos;
bell (); break;
break; case CTRL('A'): /* go to begginning of string */
case CTRL ('K'): /* delete to end-of-line */ st.pos = 0;
st.s[st.ci[st.pos].offset] = 0; break;
st.len = st.pos; case CTRL('E'): /* go to end of string */
break; st.pos = st.len;
case CTRL ('A'): /* go to begginning of string */ break;
st.pos = 0; case KEY_LEFT: /* move one char backward */
break; case CTRL('B'):
case CTRL ('E'): /* go to end of string */ if (st.pos > 0)
st.pos = st.len; st.pos--;
break; break;
case KEY_LEFT: /* move one char backward */ case KEY_RIGHT: /* move one char forward */
case CTRL ('B'): case CTRL('F'):
if (st.pos > 0) st.pos--; if (st.pos < st.len)
break; st.pos++;
case KEY_RIGHT: /* move one char forward */ break;
case CTRL ('F'): case ESCAPE: /* cancel editing */
if (st.pos < st.len) st.pos++; return GETSTRING_ESC;
break; break;
case ESCAPE: /* cancel editing */ default: /* insert one character */
return GETSTRING_ESC; c[0] = ch;
break; for (k = 1; k < MIN(UTF8_LENGTH(c[0]), UTF8_MAXLEN); k++)
default: /* insert one character */ c[k] = (unsigned char)wgetch(win);
c[0] = ch; if (st.ci[st.len].offset + k < l) {
for (k = 1; k < MIN (UTF8_LENGTH (c[0]), UTF8_MAXLEN); k++) getstr_ins_char(&st, c);
c[k] = (unsigned char)wgetch (win); st.pos++;
if (st.ci[st.len].offset + k < l)
{
getstr_ins_char (&st, c);
st.pos++;
}
} }
}
} }
custom_remove_attr (win, ATTR_HIGHEST); custom_remove_attr(win, ATTR_HIGHEST);
return st.len == 0 ? GETSTRING_RET : GETSTRING_VALID; return st.len == 0 ? GETSTRING_RET : GETSTRING_VALID;
} }
/* Update an already existing string. */ /* Update an already existing string. */
int int updatestring(WINDOW * win, char **str, int x, int y)
updatestring (WINDOW *win, char **str, int x, int y)
{ {
int len = strlen (*str); int len = strlen(*str);
char *buf; char *buf;
enum getstr ret; enum getstr ret;
EXIT_IF (len + 1 > BUFSIZ, _("Internal error: line too long")); EXIT_IF(len + 1 > BUFSIZ, _("Internal error: line too long"));
buf = mem_malloc (BUFSIZ); buf = mem_malloc(BUFSIZ);
memcpy (buf, *str, len + 1); memcpy(buf, *str, len + 1);
ret = getstring (win, buf, BUFSIZ, x, y); ret = getstring(win, buf, BUFSIZ, x, y);
if (ret == GETSTRING_VALID) if (ret == GETSTRING_VALID) {
{ len = strlen(buf);
len = strlen (buf); *str = mem_realloc(*str, len + 1, 1);
*str = mem_realloc (*str, len + 1, 1); EXIT_IF(*str == NULL, _("out of memory"));
EXIT_IF (*str == NULL, _("out of memory")); memcpy(*str, buf, len + 1);
memcpy (*str, buf, len + 1); }
}
mem_free (buf); mem_free(buf);
return ret; return ret;
} }

1116
src/help.c
View File

File diff suppressed because it is too large Load Diff

2
src/htable.h
View File

@ -69,7 +69,7 @@ struct name { \
} }
#define HTABLE_ENTRY(type) \ #define HTABLE_ENTRY(type) \
struct type *next /* To build the bucket chain list. */ struct type *next /* To build the bucket chain list. */
#define HTABLE_SIZE(head) \ #define HTABLE_SIZE(head) \
(sizeof (*(head)->bkts) ? sizeof ((head)->bkts) / sizeof (*(head)->bkts) : 0) (sizeof (*(head)->bkts) ? sizeof ((head)->bkts) / sizeof (*(head)->bkts) : 0)

1461
src/ical.c
View File

File diff suppressed because it is too large Load Diff

1551
src/io.c
View File

File diff suppressed because it is too large Load Diff

595
src/keys.c
View File

@ -39,7 +39,7 @@
#include "calcurse.h" #include "calcurse.h"
#define MAXKEYVAL KEY_MAX /* ncurses defines KEY_MAX as maximum key value */ #define MAXKEYVAL KEY_MAX /* ncurses defines KEY_MAX as maximum key value */
struct keydef_s { struct keydef_s {
const char *label; const char *label;
@ -94,89 +94,80 @@ static struct keydef_s keydef[NBKEYS] = {
{"lower-priority", "-"}, {"lower-priority", "-"},
}; };
static void static void dump_intro(FILE * fd)
dump_intro (FILE *fd)
{ {
const char *intro = const char *intro =
_("#\n" _("#\n"
"# Calcurse keys configuration file\n#\n" "# Calcurse keys configuration file\n#\n"
"# This file sets the keybindings used by Calcurse.\n" "# This file sets the keybindings used by Calcurse.\n"
"# Lines beginning with \"#\" are comments, and ignored by Calcurse.\n" "# Lines beginning with \"#\" are comments, and ignored by Calcurse.\n"
"# To assign a keybinding to an action, this file must contain a line\n" "# To assign a keybinding to an action, this file must contain a line\n"
"# with the following syntax:\n#\n" "# with the following syntax:\n#\n"
"# ACTION KEY1 KEY2 ... KEYn\n#\n" "# ACTION KEY1 KEY2 ... KEYn\n#\n"
"# Where ACTION is what will be performed when KEY1, KEY2, ..., or KEYn\n" "# Where ACTION is what will be performed when KEY1, KEY2, ..., or KEYn\n"
"# will be pressed.\n" "# will be pressed.\n"
"#\n" "#\n"
"# To define bindings which use the CONTROL key, prefix the key with " "# To define bindings which use the CONTROL key, prefix the key with "
"'C-'.\n" "'C-'.\n"
"# The escape, space bar and horizontal Tab key can be specified using\n" "# The escape, space bar and horizontal Tab key can be specified using\n"
"# the 'ESC', 'SPC' and 'TAB' keyword, respectively.\n" "# the 'ESC', 'SPC' and 'TAB' keyword, respectively.\n"
"# Arrow keys can also be specified with the UP, DWN, LFT, RGT keywords.\n" "# Arrow keys can also be specified with the UP, DWN, LFT, RGT keywords.\n"
"# Last, Home and End keys can be assigned using 'KEY_HOME' and 'KEY_END'\n" "# Last, Home and End keys can be assigned using 'KEY_HOME' and 'KEY_END'\n"
"# keywords." "# keywords."
"\n#\n" "\n#\n"
"# A description of what each ACTION keyword is used for is available\n" "# A description of what each ACTION keyword is used for is available\n"
"# from calcurse online configuration menu.\n"); "# from calcurse online configuration menu.\n");
fprintf (fd, "%s\n", intro); fprintf(fd, "%s\n", intro);
} }
void void keys_init(void)
keys_init (void)
{ {
int i; int i;
for (i = 0; i < MAXKEYVAL; i++) for (i = 0; i < MAXKEYVAL; i++)
actions[i] = KEY_UNDEF; actions[i] = KEY_UNDEF;
for (i = 0; i < NBKEYS; i++) for (i = 0; i < NBKEYS; i++)
LLIST_INIT (&keys[i]); LLIST_INIT(&keys[i]);
} }
static void static void key_free(char *s)
key_free (char *s)
{ {
mem_free (s); mem_free(s);
} }
void void keys_free(void)
keys_free (void)
{ {
int i; int i;
for (i = 0; i < NBKEYS; i++) for (i = 0; i < NBKEYS; i++) {
{ LLIST_FREE_INNER(&keys[i], key_free);
LLIST_FREE_INNER (&keys[i], key_free); LLIST_FREE(&keys[i]);
LLIST_FREE (&keys[i]); }
}
} }
void void keys_dump_defaults(char *file)
keys_dump_defaults (char *file)
{ {
FILE *fd; FILE *fd;
int i; int i;
fd = fopen (file, "w"); fd = fopen(file, "w");
EXIT_IF (fd == NULL, _("FATAL ERROR: could not create default keys file.")); EXIT_IF(fd == NULL, _("FATAL ERROR: could not create default keys file."));
dump_intro (fd); dump_intro(fd);
for (i = 0; i < NBKEYS; i++) for (i = 0; i < NBKEYS; i++)
fprintf (fd, "%s %s\n", keydef[i].label, keydef[i].binding); fprintf(fd, "%s %s\n", keydef[i].label, keydef[i].binding);
file_close (fd, __FILE_POS__); file_close(fd, __FILE_POS__);
} }
const char * const char *keys_get_label(enum key key)
keys_get_label (enum key key)
{ {
EXIT_IF (key < 0 || key > NBKEYS, EXIT_IF(key < 0 || key > NBKEYS, _("FATAL ERROR: key value out of bounds"));
_("FATAL ERROR: key value out of bounds"));
return keydef[key].label; return keydef[key].label;
} }
enum key enum key keys_get_action(int pressed)
keys_get_action (int pressed)
{ {
if (pressed < 0 || pressed > MAXKEYVAL) if (pressed < 0 || pressed > MAXKEYVAL)
return -1; return -1;
@ -184,61 +175,52 @@ keys_get_action (int pressed)
return actions[pressed]; return actions[pressed];
} }
enum key enum key keys_getch(WINDOW * win, int *count)
keys_getch (WINDOW *win, int *count)
{ {
int ch = '0'; int ch = '0';
if (count) if (count) {
{ *count = 0;
*count = 0; do {
do *count = *count * 10 + ch - '0';
{ ch = wgetch(win);
*count = *count * 10 + ch - '0';
ch = wgetch (win);
}
while ((ch == '0' && *count > 0) || (ch >= '1' && ch <= '9'));
if (*count == 0)
*count = 1;
} }
else while ((ch == '0' && *count > 0) || (ch >= '1' && ch <= '9'));
ch = wgetch (win);
switch (ch) if (*count == 0)
{ *count = 1;
case KEY_RESIZE: } else
return KEY_RESIZE; ch = wgetch(win);
default:
return keys_get_action (ch); switch (ch) {
} case KEY_RESIZE:
return KEY_RESIZE;
default:
return keys_get_action(ch);
}
} }
static void static void add_key_str(enum key action, int key)
add_key_str (enum key action, int key)
{ {
if (action < 0 || action > NBKEYS) if (action < 0 || action > NBKEYS)
return; return;
LLIST_ADD (&keys[action], mem_strdup (keys_int2str (key))); LLIST_ADD(&keys[action], mem_strdup(keys_int2str(key)));
} }
int int keys_assign_binding(int key, enum key action)
keys_assign_binding (int key, enum key action)
{ {
if (key < 0 || key > MAXKEYVAL || actions[key] != KEY_UNDEF) if (key < 0 || key > MAXKEYVAL || actions[key] != KEY_UNDEF)
return 1; return 1;
else else {
{ actions[key] = action;
actions[key] = action; add_key_str(action, key);
add_key_str (action, key); }
}
return 0; return 0;
} }
static void static void del_key_str(enum key action, int key)
del_key_str (enum key action, int key)
{ {
llist_item_t *i; llist_item_t *i;
char oldstr[BUFSIZ]; char oldstr[BUFSIZ];
@ -246,30 +228,25 @@ del_key_str (enum key action, int key)
if (action < 0 || action > NBKEYS) if (action < 0 || action > NBKEYS)
return; return;
strncpy (oldstr, keys_int2str (key), BUFSIZ); strncpy(oldstr, keys_int2str(key), BUFSIZ);
LLIST_FOREACH (&keys[action], i) LLIST_FOREACH(&keys[action], i) {
{ if (strcmp(LLIST_GET_DATA(i), oldstr) == 0) {
if (strcmp (LLIST_GET_DATA (i), oldstr) == 0) LLIST_REMOVE(&keys[action], i);
{ return;
LLIST_REMOVE (&keys[action], i);
return;
}
} }
}
} }
void void keys_remove_binding(int key, enum key action)
keys_remove_binding (int key, enum key action)
{ {
if (key >= 0 && key <= MAXKEYVAL) if (key >= 0 && key <= MAXKEYVAL) {
{ actions[key] = KEY_UNDEF;
actions[key] = KEY_UNDEF; del_key_str(action, key);
del_key_str (action, key); }
}
} }
int int keys_str2int(const char *key)
keys_str2int (const char *key)
{ {
const char CONTROL_KEY[] = "C-"; const char CONTROL_KEY[] = "C-";
const char TAB_KEY[] = "TAB"; const char TAB_KEY[] = "TAB";
@ -284,144 +261,132 @@ keys_str2int (const char *key)
if (!key) if (!key)
return -1; return -1;
if (strlen (key) == 1) if (strlen(key) == 1)
return (int)key[0]; return (int)key[0];
else else {
{ if (key[0] == '^')
if (key[0] == '^') return CTRL((int)key[1]);
return CTRL ((int)key[1]); else if (!strncmp(key, CONTROL_KEY, sizeof(CONTROL_KEY) - 1))
else if (!strncmp (key, CONTROL_KEY, sizeof (CONTROL_KEY) - 1)) return CTRL((int)key[sizeof(CONTROL_KEY) - 1]);
return CTRL ((int)key[sizeof (CONTROL_KEY) - 1]); else if (!strcmp(key, TAB_KEY))
else if (!strcmp (key, TAB_KEY)) return TAB;
return TAB; else if (!strcmp(key, ESCAPE_KEY))
else if (!strcmp (key, ESCAPE_KEY)) return ESCAPE;
return ESCAPE; else if (!strcmp(key, SPACE_KEY))
else if (!strcmp (key, SPACE_KEY)) return SPACE;
return SPACE; else if (!strcmp(key, CURSES_KEY_UP))
else if (!strcmp (key, CURSES_KEY_UP)) return KEY_UP;
return KEY_UP; else if (!strcmp(key, CURSES_KEY_DOWN))
else if (!strcmp (key, CURSES_KEY_DOWN)) return KEY_DOWN;
return KEY_DOWN; else if (!strcmp(key, CURSES_KEY_LEFT))
else if (!strcmp (key, CURSES_KEY_LEFT)) return KEY_LEFT;
return KEY_LEFT; else if (!strcmp(key, CURSES_KEY_RIGHT))
else if (!strcmp (key, CURSES_KEY_RIGHT)) return KEY_RIGHT;
return KEY_RIGHT; else if (!strcmp(key, CURSES_KEY_HOME))
else if (!strcmp (key, CURSES_KEY_HOME)) return KEY_HOME;
return KEY_HOME; else if (!strcmp(key, CURSES_KEY_END))
else if (!strcmp (key, CURSES_KEY_END)) return KEY_END;
return KEY_END; else
else return -1;
return -1; }
}
} }
const char * const char *keys_int2str(int key)
keys_int2str (int key)
{ {
switch (key) switch (key) {
{ case TAB:
case TAB: return "TAB";
return "TAB"; case SPACE:
case SPACE: return "SPC";
return "SPC"; case ESCAPE:
case ESCAPE: return "ESC";
return "ESC"; case KEY_UP:
case KEY_UP: return "UP";
return "UP"; case KEY_DOWN:
case KEY_DOWN: return "DWN";
return "DWN"; case KEY_LEFT:
case KEY_LEFT: return "LFT";
return "LFT"; case KEY_RIGHT:
case KEY_RIGHT: return "RGT";
return "RGT"; case KEY_HOME:
case KEY_HOME: return "KEY_HOME";
return "KEY_HOME"; case KEY_END:
case KEY_END: return "KEY_END";
return "KEY_END"; default:
default: return (char *)keyname(key);
return (char *)keyname (key); }
}
} }
int int keys_action_count_keys(enum key action)
keys_action_count_keys (enum key action)
{ {
llist_item_t *i; llist_item_t *i;
int n = 0; int n = 0;
LLIST_FOREACH (&keys[action], i) LLIST_FOREACH(&keys[action], i)
n++; n++;
return n; return n;
} }
const char * const char *keys_action_firstkey(enum key action)
keys_action_firstkey (enum key action)
{ {
const char *s = LLIST_GET_DATA (LLIST_FIRST (&keys[action])); const char *s = LLIST_GET_DATA(LLIST_FIRST(&keys[action]));
return (s != NULL) ? s : "XXX"; return (s != NULL) ? s : "XXX";
} }
const char * const char *keys_action_nkey(enum key action, int keynum)
keys_action_nkey (enum key action, int keynum)
{ {
return LLIST_GET_DATA (LLIST_NTH (&keys[action], keynum)); return LLIST_GET_DATA(LLIST_NTH(&keys[action], keynum));
} }
char * char *keys_action_allkeys(enum key action)
keys_action_allkeys (enum key action)
{ {
llist_item_t *i; llist_item_t *i;
static char keystr[BUFSIZ]; static char keystr[BUFSIZ];
const char *CHAR_SPACE = " "; const char *CHAR_SPACE = " ";
if (!LLIST_FIRST (&keys[action])) if (!LLIST_FIRST(&keys[action]))
return NULL; return NULL;
keystr[0] = '\0'; keystr[0] = '\0';
LLIST_FOREACH (&keys[action], i) LLIST_FOREACH(&keys[action], i) {
{ const int MAXLEN = sizeof(keystr) - 1 - strlen(keystr);
const int MAXLEN = sizeof (keystr) - 1 - strlen (keystr); strncat(keystr, LLIST_GET_DATA(i), MAXLEN - 1);
strncat (keystr, LLIST_GET_DATA (i), MAXLEN - 1); strncat(keystr, CHAR_SPACE, 1);
strncat (keystr, CHAR_SPACE, 1); }
}
return keystr; return keystr;
} }
/* Need this to display keys properly inside status bar. */ /* Need this to display keys properly inside status bar. */
static char * static char *keys_format_label(char *key, int keylen)
keys_format_label (char *key, int keylen)
{ {
static char fmtkey[BUFSIZ]; static char fmtkey[BUFSIZ];
const int len = strlen (key); const int len = strlen(key);
const char dot = '.'; const char dot = '.';
int i; int i;
if (keylen > BUFSIZ) if (keylen > BUFSIZ)
return NULL; return NULL;
memset (fmtkey, 0, sizeof(fmtkey)); memset(fmtkey, 0, sizeof(fmtkey));
if (len == 0) if (len == 0)
strncpy (fmtkey, "?", sizeof (fmtkey)); strncpy(fmtkey, "?", sizeof(fmtkey));
else if (len <= keylen) else if (len <= keylen) {
{ for (i = 0; i < keylen - len; i++)
for (i = 0; i < keylen - len; i++) fmtkey[i] = ' ';
fmtkey[i] = ' '; strncat(fmtkey, key, keylen);
strncat (fmtkey, key, keylen); } else {
} for (i = 0; i < keylen - 1; i++)
else fmtkey[i] = key[i];
{ fmtkey[keylen - 1] = dot;
for (i = 0; i < keylen - 1; i++) }
fmtkey[i] = key[i];
fmtkey[keylen - 1] = dot;
}
return fmtkey; return fmtkey;
} }
void void
keys_display_bindings_bar (WINDOW *win, struct binding *bindings[], int count, keys_display_bindings_bar(WINDOW * win, struct binding *bindings[], int count,
int page_base, int page_size, struct binding *more) int page_base, int page_size, struct binding *more)
{ {
/* Padding between two key bindings. */ /* Padding between two key bindings. */
const int padding = (col * 2) / page_size - (KEYS_KEYLEN + KEYS_LABELEN + 1); const int padding = (col * 2) / page_size - (KEYS_KEYLEN + KEYS_LABELEN + 1);
@ -430,203 +395,171 @@ keys_display_bindings_bar (WINDOW *win, struct binding *bindings[], int count,
int i; int i;
wins_erase_status_bar (); wins_erase_status_bar();
for (i = 0; i < page_size && page_base + i < count; i++) for (i = 0; i < page_size && page_base + i < count; i++) {
{ /* Location of key and label. */
/* Location of key and label. */ const int key_pos_x = (i / 2) * cmd_len;
const int key_pos_x = (i / 2) * cmd_len; const int key_pos_y = i % 2;
const int key_pos_y = i % 2; const int label_pos_x = key_pos_x + KEYS_KEYLEN + 1;
const int label_pos_x = key_pos_x + KEYS_KEYLEN + 1; const int label_pos_y = key_pos_y;
const int label_pos_y = key_pos_y;
struct binding *binding; struct binding *binding;
char key[KEYS_KEYLEN + 1], *fmtkey; char key[KEYS_KEYLEN + 1], *fmtkey;
if (!more || i < page_size - 1 || page_base + i == count - 1) if (!more || i < page_size - 1 || page_base + i == count - 1)
binding = bindings[page_base + i]; binding = bindings[page_base + i];
else else
binding = more; binding = more;
strncpy (key, keys_action_firstkey (binding->action), KEYS_KEYLEN); strncpy(key, keys_action_firstkey(binding->action), KEYS_KEYLEN);
key[KEYS_KEYLEN] = '\0'; key[KEYS_KEYLEN] = '\0';
fmtkey = keys_format_label (key, KEYS_KEYLEN); fmtkey = keys_format_label(key, KEYS_KEYLEN);
custom_apply_attr (win, ATTR_HIGHEST); custom_apply_attr(win, ATTR_HIGHEST);
mvwprintw (win, key_pos_y, key_pos_x, fmtkey); mvwprintw(win, key_pos_y, key_pos_x, fmtkey);
custom_remove_attr (win, ATTR_HIGHEST); custom_remove_attr(win, ATTR_HIGHEST);
mvwprintw (win, label_pos_y, label_pos_x, binding->label); mvwprintw(win, label_pos_y, label_pos_x, binding->label);
} }
wnoutrefresh (win); wnoutrefresh(win);
} }
/* /*
* Display information about the given key. * Display information about the given key.
* (could not add the keys descriptions to keydef variable, because of i18n). * (could not add the keys descriptions to keydef variable, because of i18n).
*/ */
void void keys_popup_info(enum key key)
keys_popup_info (enum key key)
{ {
char *info[NBKEYS]; char *info[NBKEYS];
WINDOW *infowin; WINDOW *infowin;
info[KEY_GENERIC_CANCEL] = info[KEY_GENERIC_CANCEL] = _("Cancel the ongoing action.");
_("Cancel the ongoing action."); info[KEY_GENERIC_SELECT] = _("Select the highlighted item.");
info[KEY_GENERIC_SELECT] =
_("Select the highlighted item.");
info[KEY_GENERIC_CREDITS] = info[KEY_GENERIC_CREDITS] =
_("Print general information about calcurse's authors, license, etc."); _("Print general information about calcurse's authors, license, etc.");
info[KEY_GENERIC_HELP] = info[KEY_GENERIC_HELP] =
_("Display hints whenever some help screens are available."); _("Display hints whenever some help screens are available.");
info[KEY_GENERIC_QUIT] = info[KEY_GENERIC_QUIT] = _("Exit from the current menu, or quit calcurse.");
_("Exit from the current menu, or quit calcurse."); info[KEY_GENERIC_SAVE] = _("Save calcurse data.");
info[KEY_GENERIC_SAVE] = info[KEY_GENERIC_CUT] = _("Help for `generic-cut`.");
_("Save calcurse data."); info[KEY_GENERIC_PASTE] = _("Help for `generic-paste`.");
info[KEY_GENERIC_CUT] =
_("Help for `generic-cut`.");
info[KEY_GENERIC_PASTE] =
_("Help for `generic-paste`.");
info[KEY_GENERIC_CHANGE_VIEW] = info[KEY_GENERIC_CHANGE_VIEW] =
_("Select next panel in calcurse main screen."); _("Select next panel in calcurse main screen.");
info[KEY_GENERIC_IMPORT] = info[KEY_GENERIC_IMPORT] = _("Import data from an external file.");
_("Import data from an external file."); info[KEY_GENERIC_EXPORT] = _("Export data to a new file format.");
info[KEY_GENERIC_EXPORT] = info[KEY_GENERIC_GOTO] = _("Select the day to go to.");
_("Export data to a new file format.");
info[KEY_GENERIC_GOTO] =
_("Select the day to go to.");
info[KEY_GENERIC_OTHER_CMD] = info[KEY_GENERIC_OTHER_CMD] =
_("Show next possible actions inside status bar."); _("Show next possible actions inside status bar.");
info[KEY_GENERIC_CONFIG_MENU] = info[KEY_GENERIC_CONFIG_MENU] = _("Enter the configuration menu.");
_("Enter the configuration menu."); info[KEY_GENERIC_REDRAW] = _("Redraw calcurse's screen.");
info[KEY_GENERIC_REDRAW] =
_("Redraw calcurse's screen.");
info[KEY_GENERIC_ADD_APPT] = info[KEY_GENERIC_ADD_APPT] =
_("Add an appointment, whichever panel is currently selected."); _("Add an appointment, whichever panel is currently selected.");
info[KEY_GENERIC_ADD_TODO] = info[KEY_GENERIC_ADD_TODO] =
_("Add a todo item, whichever panel is currently selected."); _("Add a todo item, whichever panel is currently selected.");
info[KEY_GENERIC_NEXT_DAY] = info[KEY_GENERIC_NEXT_DAY] =
_("Move to next day in calendar, whichever panel is currently selected."); _("Move to next day in calendar, whichever panel is currently selected.");
info[KEY_GENERIC_PREV_DAY] = info[KEY_GENERIC_PREV_DAY] =
_("Move to previous day in calendar, whichever panel is currently " _("Move to previous day in calendar, whichever panel is currently "
"selected."); "selected.");
info[KEY_GENERIC_NEXT_WEEK] = info[KEY_GENERIC_NEXT_WEEK] =
_("Move to next week in calendar, whichever panel is currently selected."); _
("Move to next week in calendar, whichever panel is currently selected.");
info[KEY_GENERIC_PREV_WEEK] = info[KEY_GENERIC_PREV_WEEK] =
_("Move to previous week in calendar, whichever panel is currently " _("Move to previous week in calendar, whichever panel is currently "
"selected"); "selected");
info[KEY_GENERIC_SCROLL_DOWN] = info[KEY_GENERIC_SCROLL_DOWN] =
_("Scroll window down (e.g. when displaying text inside a popup window)."); _
("Scroll window down (e.g. when displaying text inside a popup window).");
info[KEY_GENERIC_SCROLL_UP] = info[KEY_GENERIC_SCROLL_UP] =
_("Scroll window up (e.g. when displaying text inside a popup window)."); _("Scroll window up (e.g. when displaying text inside a popup window).");
info[KEY_GENERIC_GOTO_TODAY] = info[KEY_GENERIC_GOTO_TODAY] = _("Go to today, whichever panel is selected.");
_("Go to today, whichever panel is selected."); info[KEY_MOVE_RIGHT] = _("Move to the right.");
info[KEY_MOVE_RIGHT] = info[KEY_MOVE_LEFT] = _("Move to the left.");
_("Move to the right."); info[KEY_MOVE_DOWN] = _("Move down.");
info[KEY_MOVE_LEFT] = info[KEY_MOVE_UP] = _("Move up.");
_("Move to the left.");
info[KEY_MOVE_DOWN] =
_("Move down.");
info[KEY_MOVE_UP] =
_("Move up.");
info[KEY_START_OF_WEEK] = info[KEY_START_OF_WEEK] =
_("Select the first day of the current week when inside the calendar " _("Select the first day of the current week when inside the calendar "
"panel."); "panel.");
info[KEY_END_OF_WEEK] = info[KEY_END_OF_WEEK] =
_("Select the last day of the current week when inside the calendar " _("Select the last day of the current week when inside the calendar "
"panel."); "panel.");
info[KEY_ADD_ITEM] = info[KEY_ADD_ITEM] = _("Add an item to the currently selected panel.");
_("Add an item to the currently selected panel."); info[KEY_DEL_ITEM] = _("Delete the currently selected item.");
info[KEY_DEL_ITEM] = info[KEY_EDIT_ITEM] = _("Edit the currently seleted item.");
_("Delete the currently selected item.");
info[KEY_EDIT_ITEM] =
_("Edit the currently seleted item.");
info[KEY_VIEW_ITEM] = info[KEY_VIEW_ITEM] =
_("Display the currently selected item inside a popup window."); _("Display the currently selected item inside a popup window.");
info[KEY_FLAG_ITEM] = info[KEY_FLAG_ITEM] = _("Flag the currently selected item as important.");
_("Flag the currently selected item as important."); info[KEY_REPEAT_ITEM] = _("Repeat an item");
info[KEY_REPEAT_ITEM] =
_("Repeat an item");
info[KEY_PIPE_ITEM] = info[KEY_PIPE_ITEM] =
_("Pipe the currently selected item to an external program."); _("Pipe the currently selected item to an external program.");
info[KEY_EDIT_NOTE] = info[KEY_EDIT_NOTE] =
_("Attach (or edit if one exists) a note to the currently selected item"); _("Attach (or edit if one exists) a note to the currently selected item");
info[KEY_VIEW_NOTE] = info[KEY_VIEW_NOTE] =
_("View the note attached to the currently selected item."); _("View the note attached to the currently selected item.");
info[KEY_RAISE_PRIORITY] = info[KEY_RAISE_PRIORITY] = _("Raise a task priority inside the todo panel.");
_("Raise a task priority inside the todo panel."); info[KEY_LOWER_PRIORITY] = _("Lower a task priority inside the todo panel.");
info[KEY_LOWER_PRIORITY] =
_("Lower a task priority inside the todo panel.");
if (key < 0 || key > NBKEYS) if (key < 0 || key > NBKEYS)
return; return;
#define WINROW 10 #define WINROW 10
#define WINCOL (col - 4) #define WINCOL (col - 4)
infowin = popup (WINROW, WINCOL, (row - WINROW) / 2, (col - WINCOL) / 2, infowin = popup(WINROW, WINCOL, (row - WINROW) / 2, (col - WINCOL) / 2,
keydef[key].label, info[key], 1); keydef[key].label, info[key], 1);
keys_getch (infowin, NULL); keys_getch(infowin, NULL);
delwin (infowin); delwin(infowin);
#undef WINROW #undef WINROW
#undef WINCOL #undef WINCOL
} }
void void keys_save_bindings(FILE * fd)
keys_save_bindings (FILE *fd)
{ {
int i; int i;
EXIT_IF (fd == NULL, _("FATAL ERROR: null file pointer.")); EXIT_IF(fd == NULL, _("FATAL ERROR: null file pointer."));
dump_intro (fd); dump_intro(fd);
for (i = 0; i < NBKEYS; i++) for (i = 0; i < NBKEYS; i++)
fprintf (fd, "%s %s\n", keydef[i].label, keys_action_allkeys (i)); fprintf(fd, "%s %s\n", keydef[i].label, keys_action_allkeys(i));
} }
int int keys_check_missing_bindings(void)
keys_check_missing_bindings (void)
{ {
int i; int i;
for (i = 0; i < NBKEYS; i++) for (i = 0; i < NBKEYS; i++) {
{ if (!LLIST_FIRST(&keys[i]))
if (!LLIST_FIRST (&keys[i])) return 1;
return 1; }
}
return 0; return 0;
} }
void void keys_fill_missing(void)
keys_fill_missing (void)
{ {
int i; int i;
for (i = 0; i < NBKEYS; i++) for (i = 0; i < NBKEYS; i++) {
{ if (!LLIST_FIRST(&keys[i])) {
if (!LLIST_FIRST (&keys[i])) char *p, tmpbuf[BUFSIZ];
{
char *p, tmpbuf[BUFSIZ];
strncpy (tmpbuf, keydef[i].binding, BUFSIZ); strncpy(tmpbuf, keydef[i].binding, BUFSIZ);
p = tmpbuf; p = tmpbuf;
for (;;) for (;;) {
{ char key_ch[BUFSIZ];
char key_ch[BUFSIZ];
while (*p == ' ') while (*p == ' ')
p++; p++;
if (sscanf (p, "%s", key_ch) == 1) if (sscanf(p, "%s", key_ch) == 1) {
{ int ch, used;
int ch, used;
ch = keys_str2int (key_ch); ch = keys_str2int(key_ch);
used = keys_assign_binding (ch, i); used = keys_assign_binding(ch, i);
if (used) if (used)
WARN_MSG (_("When adding default key for \"%s\", " WARN_MSG(_("When adding default key for \"%s\", "
"\"%s\" was already assigned!"), "\"%s\" was already assigned!"),
keydef[i].label, key_ch); keydef[i].label, key_ch);
p += strlen (key_ch) + 1; p += strlen(key_ch) + 1;
} } else
else break;
break; }
}
}
} }
}
} }

190
src/llist.c
View File

@ -39,8 +39,7 @@
/* /*
* Initialize a list. * Initialize a list.
*/ */
void void llist_init(llist_t * l)
llist_init (llist_t *l)
{ {
l->head = NULL; l->head = NULL;
l->tail = NULL; l->tail = NULL;
@ -49,16 +48,14 @@ llist_init (llist_t *l)
/* /*
* Free a list, but not the contained data. * Free a list, but not the contained data.
*/ */
void void llist_free(llist_t * l)
llist_free (llist_t *l)
{ {
llist_item_t *i, *t; llist_item_t *i, *t;
for (i = l->head; i; i = t) for (i = l->head; i; i = t) {
{ t = i->next;
t = i->next; mem_free(i);
mem_free (i); }
}
l->head = NULL; l->head = NULL;
l->tail = NULL; l->tail = NULL;
@ -67,26 +64,22 @@ llist_free (llist_t *l)
/* /*
* Free the data contained in a list. * Free the data contained in a list.
*/ */
void void llist_free_inner(llist_t * l, llist_fn_free_t fn_free)
llist_free_inner (llist_t *l, llist_fn_free_t fn_free)
{ {
llist_item_t *i; llist_item_t *i;
for (i = l->head; i; i = i->next) for (i = l->head; i; i = i->next) {
{ if (i->data) {
if (i->data) fn_free(i->data);
{ i->data = NULL;
fn_free(i->data);
i->data = NULL;
}
} }
}
} }
/* /*
* Get the first item of a list. * Get the first item of a list.
*/ */
llist_item_t * llist_item_t *llist_first(llist_t * l)
llist_first (llist_t *l)
{ {
return l->head; return l->head;
} }
@ -94,8 +87,7 @@ llist_first (llist_t *l)
/* /*
* Get the nth item of a list. * Get the nth item of a list.
*/ */
llist_item_t * llist_item_t *llist_nth(llist_t * l, int n)
llist_nth (llist_t *l, int n)
{ {
llist_item_t *i; llist_item_t *i;
@ -111,8 +103,7 @@ llist_nth (llist_t *l, int n)
/* /*
* Get the successor of a list item. * Get the successor of a list item.
*/ */
llist_item_t * llist_item_t *llist_next(llist_item_t * i)
llist_next (llist_item_t *i)
{ {
return i ? i->next : NULL; return i ? i->next : NULL;
} }
@ -121,10 +112,10 @@ llist_next (llist_item_t *i)
* Return the successor of a list item if it is matched by some filter * Return the successor of a list item if it is matched by some filter
* callback. Return NULL otherwise. * callback. Return NULL otherwise.
*/ */
llist_item_t * llist_item_t *llist_next_filter(llist_item_t * i, long data,
llist_next_filter (llist_item_t *i, long data, llist_fn_match_t fn_match) llist_fn_match_t fn_match)
{ {
if (i && i->next && fn_match (i->next->data, data)) if (i && i->next && fn_match(i->next->data, data))
return i->next; return i->next;
else else
return NULL; return NULL;
@ -133,8 +124,7 @@ llist_next_filter (llist_item_t *i, long data, llist_fn_match_t fn_match)
/* /*
* Get the actual data of an item. * Get the actual data of an item.
*/ */
void * void *llist_get_data(llist_item_t * i)
llist_get_data (llist_item_t *i)
{ {
return i ? i->data : NULL; return i ? i->data : NULL;
} }
@ -142,103 +132,88 @@ llist_get_data (llist_item_t *i)
/* /*
* Add an item at the end of a list. * Add an item at the end of a list.
*/ */
void void llist_add(llist_t * l, void *data)
llist_add (llist_t *l, void *data)
{ {
llist_item_t *o = mem_malloc (sizeof (llist_item_t)); llist_item_t *o = mem_malloc(sizeof(llist_item_t));
if (o) if (o) {
{ o->data = data;
o->data = data; o->next = NULL;
o->next = NULL;
if (!l->head) if (!l->head)
l->head = l->tail = o; l->head = l->tail = o;
else else {
{ l->tail->next = o;
l->tail->next = o; l->tail = o;
l->tail = o;
}
} }
}
} }
/* /*
* Add an item to a sorted list. * Add an item to a sorted list.
*/ */
void void llist_add_sorted(llist_t * l, void *data, llist_fn_cmp_t fn_cmp)
llist_add_sorted (llist_t *l, void *data, llist_fn_cmp_t fn_cmp)
{ {
llist_item_t *o = mem_malloc (sizeof (llist_item_t)); llist_item_t *o = mem_malloc(sizeof(llist_item_t));
llist_item_t *i; llist_item_t *i;
if (o) if (o) {
{ o->data = data;
o->data = data; o->next = NULL;
o->next = NULL;
if (!l->head) if (!l->head)
l->head = l->tail = o; l->head = l->tail = o;
else if (fn_cmp(o->data, l->tail->data) >= 0) else if (fn_cmp(o->data, l->tail->data) >= 0) {
{ l->tail->next = o;
l->tail->next = o; l->tail = o;
l->tail = o; } else if (fn_cmp(o->data, l->head->data) < 0) {
} o->next = l->head;
else if (fn_cmp(o->data, l->head->data) < 0) l->head = o;
{ } else {
o->next = l->head; i = l->head;
l->head = o; while (i->next && fn_cmp(o->data, i->next->data) >= 0)
} i = i->next;
else o->next = i->next;
{ i->next = o;
i = l->head;
while (i->next && fn_cmp(o->data, i->next->data) >= 0)
i = i->next;
o->next = i->next;
i->next = o;
}
} }
}
} }
/* /*
* Remove an item from a list. * Remove an item from a list.
*/ */
void void llist_remove(llist_t * l, llist_item_t * i)
llist_remove (llist_t *l, llist_item_t *i)
{ {
llist_item_t *j = NULL; llist_item_t *j = NULL;
if (l->head && i == l->head) if (l->head && i == l->head)
l->head = i->next; l->head = i->next;
else else {
{ for (j = l->head; j && j->next != i; j = j->next) ;
for (j = l->head; j && j->next != i; j = j->next) }
;
}
if (i) if (i) {
{ if (j)
if (j) j->next = i->next;
j->next = i->next; if (i == l->tail)
if (i == l->tail) l->tail = j;
l->tail = j;
mem_free (i); mem_free(i);
} }
} }
/* /*
* Find the first item matched by some filter callback. * Find the first item matched by some filter callback.
*/ */
llist_item_t * llist_item_t *llist_find_first(llist_t * l, long data,
llist_find_first (llist_t *l, long data, llist_fn_match_t fn_match) llist_fn_match_t fn_match)
{ {
llist_item_t *i; llist_item_t *i;
for (i = l->head; i; i = i->next) for (i = l->head; i; i = i->next) {
{ if (fn_match(i->data, data))
if (fn_match (i->data, data)) return i;
return i; }
}
return NULL; return NULL;
} }
@ -246,18 +221,16 @@ llist_find_first (llist_t *l, long data, llist_fn_match_t fn_match)
/* /*
* Find the next item matched by some filter callback. * Find the next item matched by some filter callback.
*/ */
llist_item_t * llist_item_t *llist_find_next(llist_item_t * i, long data,
llist_find_next (llist_item_t *i, long data, llist_fn_match_t fn_match) llist_fn_match_t fn_match)
{ {
if (i) if (i) {
{ i = i->next;
i = i->next; for (; i; i = i->next) {
for (; i; i = i->next) if (fn_match(i->data, data))
{ return i;
if (fn_match (i->data, data))
return i;
}
} }
}
return NULL; return NULL;
} }
@ -265,19 +238,18 @@ llist_find_next (llist_item_t *i, long data, llist_fn_match_t fn_match)
/* /*
* Find the nth item matched by some filter callback. * Find the nth item matched by some filter callback.
*/ */
llist_item_t * llist_item_t *llist_find_nth(llist_t * l, int n, long data,
llist_find_nth (llist_t *l, int n, long data, llist_fn_match_t fn_match) llist_fn_match_t fn_match)
{ {
llist_item_t *i; llist_item_t *i;
if (n < 0) if (n < 0)
return NULL; return NULL;
for (i = l->head; i; i = i->next) for (i = l->head; i; i = i->next) {
{ if (fn_match(i->data, data) && (n-- == 0))
if (fn_match (i->data, data) && (n-- == 0)) return i;
return i; }
}
return NULL; return NULL;
} }

30
src/llist.h
View File

@ -38,7 +38,7 @@
typedef struct llist_item llist_item_t; typedef struct llist_item llist_item_t;
struct llist_item { struct llist_item {
struct llist_item *next; struct llist_item *next;
void *data; void *data;
}; };
typedef struct llist llist_t; typedef struct llist llist_t;
@ -52,9 +52,9 @@ typedef int (*llist_fn_match_t) (void *, long);
typedef void (*llist_fn_free_t) (void *); typedef void (*llist_fn_free_t) (void *);
/* Initialization and deallocation. */ /* Initialization and deallocation. */
void llist_init (llist_t *); void llist_init(llist_t *);
void llist_free (llist_t *); void llist_free(llist_t *);
void llist_free_inner (llist_t *, llist_fn_free_t); void llist_free_inner(llist_t *, llist_fn_free_t);
#define LLIST_INIT(l) llist_init(l) #define LLIST_INIT(l) llist_init(l)
#define LLIST_FREE(l) llist_free(l) #define LLIST_FREE(l) llist_free(l)
@ -62,13 +62,13 @@ void llist_free_inner (llist_t *, llist_fn_free_t);
llist_free_inner(l, (llist_fn_free_t)fn_free) llist_free_inner(l, (llist_fn_free_t)fn_free)
/* Retrieving list items. */ /* Retrieving list items. */
llist_item_t *llist_first (llist_t *); llist_item_t *llist_first(llist_t *);
llist_item_t *llist_nth (llist_t *, int); llist_item_t *llist_nth(llist_t *, int);
llist_item_t *llist_next (llist_item_t *); llist_item_t *llist_next(llist_item_t *);
llist_item_t *llist_next_filter (llist_item_t *, long, llist_fn_match_t); llist_item_t *llist_next_filter(llist_item_t *, long, llist_fn_match_t);
llist_item_t *llist_find_first (llist_t *, long, llist_fn_match_t); llist_item_t *llist_find_first(llist_t *, long, llist_fn_match_t);
llist_item_t *llist_find_next (llist_item_t *, long, llist_fn_match_t); llist_item_t *llist_find_next(llist_item_t *, long, llist_fn_match_t);
llist_item_t *llist_find_nth (llist_t *, int, long, llist_fn_match_t); llist_item_t *llist_find_nth(llist_t *, int, long, llist_fn_match_t);
#define LLIST_FIRST(l) llist_first(l) #define LLIST_FIRST(l) llist_first(l)
#define LLIST_NTH(l, n) llist_nth(l, n) #define LLIST_NTH(l, n) llist_nth(l, n)
@ -91,14 +91,14 @@ llist_item_t *llist_find_nth (llist_t *, int, long, llist_fn_match_t);
i = LLIST_NEXT_FILTER (i, data, fn_match)) i = LLIST_NEXT_FILTER (i, data, fn_match))
/* Accessing list item data. */ /* Accessing list item data. */
void *llist_get_data (llist_item_t *); void *llist_get_data(llist_item_t *);
#define LLIST_GET_DATA(i) llist_get_data(i) #define LLIST_GET_DATA(i) llist_get_data(i)
/* List manipulation. */ /* List manipulation. */
void llist_add (llist_t *, void *); void llist_add(llist_t *, void *);
void llist_add_sorted (llist_t *, void *, llist_fn_cmp_t); void llist_add_sorted(llist_t *, void *, llist_fn_cmp_t);
void llist_remove (llist_t *, llist_item_t *); void llist_remove(llist_t *, llist_item_t *);
#define LLIST_ADD(l, data) llist_add(l, data) #define LLIST_ADD(l, data) llist_add(l, data)
#define LLIST_ADD_SORTED(l, data, fn_cmp) \ #define LLIST_ADD_SORTED(l, data, fn_cmp) \

7
src/llist_ts.h
View File

@ -37,9 +37,9 @@
/* Thread-safe linked lists. */ /* Thread-safe linked lists. */
typedef struct llist_ts llist_ts_t; typedef struct llist_ts llist_ts_t;
struct llist_ts { struct llist_ts {
llist_item_t *head; llist_item_t *head;
llist_item_t *tail; llist_item_t *tail;
pthread_mutex_t mutex; pthread_mutex_t mutex;
}; };
/* Initialization and deallocation. */ /* Initialization and deallocation. */
@ -90,4 +90,3 @@ struct llist_ts {
#define LLIST_TS_REMOVE(l_ts, i) llist_remove ((llist_t *)l_ts, i) #define LLIST_TS_REMOVE(l_ts, i) llist_remove ((llist_t *)l_ts, i)
#define LLIST_TS_ADD_SORTED(l_ts, data, fn_cmp) \ #define LLIST_TS_ADD_SORTED(l_ts, data, fn_cmp) \
llist_add_sorted ((llist_t *)l_ts, data, (llist_fn_cmp_t)fn_cmp) llist_add_sorted ((llist_t *)l_ts, data, (llist_fn_cmp_t)fn_cmp)

192
src/mem.c
View File

@ -71,75 +71,68 @@ static struct mem_stats mstats;
#endif /* CALCURSE_MEMORY_DEBUG */ #endif /* CALCURSE_MEMORY_DEBUG */
void *xmalloc(size_t size)
void *
xmalloc (size_t size)
{ {
void *p; void *p;
EXIT_IF (size == 0, _("xmalloc: zero size")); EXIT_IF(size == 0, _("xmalloc: zero size"));
p = malloc (size); p = malloc(size);
EXIT_IF (p == NULL, _("xmalloc: out of memory")); EXIT_IF(p == NULL, _("xmalloc: out of memory"));
return p; return p;
} }
void * void *xcalloc(size_t nmemb, size_t size)
xcalloc (size_t nmemb, size_t size)
{ {
void *p; void *p;
EXIT_IF (nmemb == 0 || size == 0, _("xcalloc: zero size")); EXIT_IF(nmemb == 0 || size == 0, _("xcalloc: zero size"));
EXIT_IF (SIZE_MAX / nmemb < size, _("xcalloc: overflow")); EXIT_IF(SIZE_MAX / nmemb < size, _("xcalloc: overflow"));
p = calloc (nmemb, size); p = calloc(nmemb, size);
EXIT_IF (p == NULL, _("xcalloc: out of memory")); EXIT_IF(p == NULL, _("xcalloc: out of memory"));
return p; return p;
} }
void * void *xrealloc(void *ptr, size_t nmemb, size_t size)
xrealloc (void *ptr, size_t nmemb, size_t size)
{ {
void *new_ptr; void *new_ptr;
size_t new_size; size_t new_size;
new_size = nmemb * size; new_size = nmemb * size;
EXIT_IF (new_size == 0, _("xrealloc: zero size")); EXIT_IF(new_size == 0, _("xrealloc: zero size"));
EXIT_IF (SIZE_MAX / nmemb < size, _("xrealloc: overflow")); EXIT_IF(SIZE_MAX / nmemb < size, _("xrealloc: overflow"));
new_ptr = realloc (ptr, new_size); new_ptr = realloc(ptr, new_size);
EXIT_IF (new_ptr == NULL, _("xrealloc: out of memory")); EXIT_IF(new_ptr == NULL, _("xrealloc: out of memory"));
return new_ptr; return new_ptr;
} }
char * char *xstrdup(const char *str)
xstrdup (const char *str)
{ {
size_t len; size_t len;
char *cp; char *cp;
len = strlen (str) + 1; len = strlen(str) + 1;
cp = xmalloc (len); cp = xmalloc(len);
return strncpy (cp, str, len); return strncpy(cp, str, len);
} }
void void xfree(void *p)
xfree (void *p)
{ {
EXIT_IF (p == NULL, _("xfree: null pointer")); EXIT_IF(p == NULL, _("xfree: null pointer"));
free (p); free(p);
} }
#ifdef CALCURSE_MEMORY_DEBUG #ifdef CALCURSE_MEMORY_DEBUG
static unsigned static unsigned stats_add_blk(size_t size, const char *pos)
stats_add_blk (size_t size, const char *pos)
{ {
struct mem_blk *o, **i; struct mem_blk *o, **i;
o = malloc (sizeof (*o)); o = malloc(sizeof(*o));
EXIT_IF (o == NULL, _("could not allocate memory to store block info")); EXIT_IF(o == NULL, _("could not allocate memory to store block info"));
mstats.ncall++; mstats.ncall++;
@ -147,103 +140,95 @@ stats_add_blk (size_t size, const char *pos)
o->size = (unsigned)size; o->size = (unsigned)size;
o->next = 0; o->next = 0;
for (i = &mstats.blk; *i; i = &(*i)->next) for (i = &mstats.blk; *i; i = &(*i)->next) ;
;
o->id = mstats.ncall; o->id = mstats.ncall;
*i = o; *i = o;
return o->id; return o->id;
} }
static void static void stats_del_blk(unsigned id)
stats_del_blk (unsigned id)
{ {
struct mem_blk *o, **i; struct mem_blk *o, **i;
i = &mstats.blk; i = &mstats.blk;
for (o = mstats.blk; o; o = o->next) for (o = mstats.blk; o; o = o->next) {
{ if (o->id == id) {
if (o->id == id) *i = o->next;
{ free(o);
*i = o->next; return;
free (o);
return;
}
i = &o->next;
} }
i = &o->next;
}
EXIT (_("Block not found")); EXIT(_("Block not found"));
/* NOTREACHED */ /* NOTREACHED */
} }
void * void *dbg_malloc(size_t size, const char *pos)
dbg_malloc (size_t size, const char *pos)
{ {
unsigned *buf; unsigned *buf;
if (size == 0) if (size == 0)
return NULL; return NULL;
size = EXTRA_SPACE + (size + sizeof (unsigned) - 1) / sizeof (unsigned); size = EXTRA_SPACE + (size + sizeof(unsigned) - 1) / sizeof(unsigned);
buf = xmalloc (size * sizeof (unsigned)); buf = xmalloc(size * sizeof(unsigned));
buf[BLK_STATE] = MAGIC_ALLOC; /* state of the block */ buf[BLK_STATE] = MAGIC_ALLOC; /* state of the block */
buf[BLK_SIZE] = size; /* size of the block */ buf[BLK_SIZE] = size; /* size of the block */
buf[BLK_ID] = stats_add_blk (size, pos); /* identify a block by its id */ buf[BLK_ID] = stats_add_blk(size, pos); /* identify a block by its id */
buf[size - 1] = buf[BLK_ID]; /* mark at end of block */ buf[size - 1] = buf[BLK_ID]; /* mark at end of block */
mstats.nalloc += size; mstats.nalloc += size;
return (void *)(buf + EXTRA_SPACE_START); return (void *)(buf + EXTRA_SPACE_START);
} }
void * void *dbg_calloc(size_t nmemb, size_t size, const char *pos)
dbg_calloc (size_t nmemb, size_t size, const char *pos)
{ {
void *buf; void *buf;
if (!nmemb || !size) if (!nmemb || !size)
return NULL; return NULL;
EXIT_IF (nmemb > SIZE_MAX / size, _("overflow at %s"), pos); EXIT_IF(nmemb > SIZE_MAX / size, _("overflow at %s"), pos);
size *= nmemb; size *= nmemb;
if ((buf = dbg_malloc (size, pos)) == NULL) if ((buf = dbg_malloc(size, pos)) == NULL)
return NULL; return NULL;
memset (buf, 0, size); memset(buf, 0, size);
return buf; return buf;
} }
void * void *dbg_realloc(void *ptr, size_t nmemb, size_t size, const char *pos)
dbg_realloc (void *ptr, size_t nmemb, size_t size, const char *pos)
{ {
unsigned *buf, old_size, new_size, cpy_size; unsigned *buf, old_size, new_size, cpy_size;
if (ptr == NULL) if (ptr == NULL)
return NULL; return NULL;
new_size = nmemb *size; new_size = nmemb * size;
if (new_size == 0) if (new_size == 0)
return NULL; return NULL;
EXIT_IF (nmemb > SIZE_MAX / size, _("overflow at %s"), pos); EXIT_IF(nmemb > SIZE_MAX / size, _("overflow at %s"), pos);
if ((buf = dbg_malloc (new_size, pos)) == NULL) if ((buf = dbg_malloc(new_size, pos)) == NULL)
return NULL; return NULL;
old_size = *((unsigned *)ptr - EXTRA_SPACE_START + BLK_SIZE); old_size = *((unsigned *)ptr - EXTRA_SPACE_START + BLK_SIZE);
cpy_size = (old_size > new_size) ? new_size : old_size; cpy_size = (old_size > new_size) ? new_size : old_size;
memmove (buf, ptr, cpy_size); memmove(buf, ptr, cpy_size);
mem_free (ptr); mem_free(ptr);
return (void *)buf; return (void *)buf;
} }
char * char *dbg_strdup(const char *s, const char *pos)
dbg_strdup (const char *s, const char *pos)
{ {
size_t size; size_t size;
char *buf; char *buf;
@ -251,71 +236,66 @@ dbg_strdup (const char *s, const char *pos)
if (s == NULL) if (s == NULL)
return NULL; return NULL;
size = strlen (s); size = strlen(s);
if ((buf = dbg_malloc (size + 1, pos)) == NULL) if ((buf = dbg_malloc(size + 1, pos)) == NULL)
return NULL; return NULL;
return strncpy (buf, s, size + 1); return strncpy(buf, s, size + 1);
} }
void void dbg_free(void *ptr, const char *pos)
dbg_free (void *ptr, const char *pos)
{ {
unsigned *buf, size; unsigned *buf, size;
EXIT_IF (ptr == NULL, _("dbg_free: null pointer at %s"), pos); EXIT_IF(ptr == NULL, _("dbg_free: null pointer at %s"), pos);
buf = (unsigned *)ptr - EXTRA_SPACE_START; buf = (unsigned *)ptr - EXTRA_SPACE_START;
size = buf[BLK_SIZE]; size = buf[BLK_SIZE];
EXIT_IF (buf[BLK_STATE] == MAGIC_FREE, EXIT_IF(buf[BLK_STATE] == MAGIC_FREE,
_("block seems already freed at %s"), pos); _("block seems already freed at %s"), pos);
EXIT_IF (buf[BLK_STATE] != MAGIC_ALLOC, EXIT_IF(buf[BLK_STATE] != MAGIC_ALLOC, _("corrupt block header at %s"), pos);
_("corrupt block header at %s"), pos); EXIT_IF(buf[size - 1] != buf[BLK_ID],
EXIT_IF (buf[size - 1] != buf[BLK_ID], _("corrupt block end at %s, (end = %u, should be %d)"), pos,
_("corrupt block end at %s, (end = %u, should be %d)"), pos, buf[size - 1], buf[BLK_ID]);
buf[size - 1], buf[BLK_ID]);
buf[0] = MAGIC_FREE; buf[0] = MAGIC_FREE;
stats_del_blk (buf[BLK_ID]); stats_del_blk(buf[BLK_ID]);
free (buf); free(buf);
mstats.nfree += size; mstats.nfree += size;
} }
static void static void dump_block_info(struct mem_blk *blk)
dump_block_info (struct mem_blk *blk)
{ {
if (blk == NULL) if (blk == NULL)
return; return;
puts (_("---==== MEMORY BLOCK ====----------------\n")); puts(_("---==== MEMORY BLOCK ====----------------\n"));
printf (_(" id: %u\n"), blk->id); printf(_(" id: %u\n"), blk->id);
printf (_(" size: %u\n"), blk->size); printf(_(" size: %u\n"), blk->size);
printf (_(" allocated in: %s\n"), blk->pos); printf(_(" allocated in: %s\n"), blk->pos);
puts (_("-----------------------------------------\n")); puts(_("-----------------------------------------\n"));
} }
void void mem_stats(void)
mem_stats (void)
{ {
putchar ('\n'); putchar('\n');
puts (_("+------------------------------+\n")); puts(_("+------------------------------+\n"));
puts (_("| calcurse memory usage report |\n")); puts(_("| calcurse memory usage report |\n"));
puts (_("+------------------------------+\n")); puts(_("+------------------------------+\n"));
printf (_(" number of calls: %u\n"), mstats.ncall); printf(_(" number of calls: %u\n"), mstats.ncall);
printf (_(" allocated blocks: %u\n"), mstats.nalloc); printf(_(" allocated blocks: %u\n"), mstats.nalloc);
printf (_(" unfreed blocks: %u\n"), mstats.nalloc - mstats.nfree); printf(_(" unfreed blocks: %u\n"), mstats.nalloc - mstats.nfree);
putchar ('\n'); putchar('\n');
if (mstats.nfree < mstats.nalloc) if (mstats.nfree < mstats.nalloc) {
{ struct mem_blk *blk;
struct mem_blk *blk;
for (blk = mstats.blk; blk; blk = blk->next) for (blk = mstats.blk; blk; blk = blk->next)
dump_block_info (blk); dump_block_info(blk);
} }
} }
#endif /* CALCURSE_MEMORY_DEBUG */ #endif /* CALCURSE_MEMORY_DEBUG */

220
src/note.c
View File

@ -43,135 +43,124 @@
struct note_gc_hash { struct note_gc_hash {
char *hash; char *hash;
char buf[MAX_NOTESIZ + 1]; char buf[MAX_NOTESIZ + 1];
HTABLE_ENTRY (note_gc_hash); HTABLE_ENTRY(note_gc_hash);
}; };
static void note_gc_extract_key (struct note_gc_hash *, const char **, int *); static void note_gc_extract_key(struct note_gc_hash *, const char **, int *);
static int note_gc_cmp (struct note_gc_hash *, struct note_gc_hash *); static int note_gc_cmp(struct note_gc_hash *, struct note_gc_hash *);
HTABLE_HEAD (htp, NOTE_GC_HSIZE, note_gc_hash); HTABLE_HEAD(htp, NOTE_GC_HSIZE, note_gc_hash);
HTABLE_PROTOTYPE (htp, note_gc_hash) HTABLE_PROTOTYPE(htp, note_gc_hash)
HTABLE_GENERATE (htp, note_gc_hash, note_gc_extract_key, note_gc_cmp) HTABLE_GENERATE(htp, note_gc_hash, note_gc_extract_key, note_gc_cmp)
/* Create note file from a string and return a newly allocated string that /* Create note file from a string and return a newly allocated string that
* contains its name. */ * contains its name. */
char * char *generate_note(const char *str)
generate_note (const char *str)
{ {
char *sha1 = mem_malloc (SHA1_DIGESTLEN * 2 + 1); char *sha1 = mem_malloc(SHA1_DIGESTLEN * 2 + 1);
char notepath[BUFSIZ]; char notepath[BUFSIZ];
FILE *fp; FILE *fp;
sha1_digest (str, sha1); sha1_digest(str, sha1);
snprintf (notepath, BUFSIZ, "%s%s", path_notes, sha1); snprintf(notepath, BUFSIZ, "%s%s", path_notes, sha1);
fp = fopen (notepath, "w"); fp = fopen(notepath, "w");
EXIT_IF (fp == NULL, _("Warning: could not open %s, Aborting..."), notepath); EXIT_IF(fp == NULL, _("Warning: could not open %s, Aborting..."), notepath);
fputs (str, fp); fputs(str, fp);
file_close (fp, __FILE_POS__); file_close(fp, __FILE_POS__);
return sha1; return sha1;
} }
/* Edit a note with an external editor. */ /* Edit a note with an external editor. */
void void edit_note(char **note, const char *editor)
edit_note (char **note, const char *editor)
{ {
char tmppath[BUFSIZ]; char tmppath[BUFSIZ];
char *tmpext; char *tmpext;
char notepath[BUFSIZ]; char notepath[BUFSIZ];
char *sha1 = mem_malloc (SHA1_DIGESTLEN * 2 + 1); char *sha1 = mem_malloc(SHA1_DIGESTLEN * 2 + 1);
FILE *fp; FILE *fp;
strncpy (tmppath, get_tempdir (), BUFSIZ); strncpy(tmppath, get_tempdir(), BUFSIZ);
strncat (tmppath, "/calcurse-note.", BUFSIZ - strlen (tmppath) - 1); strncat(tmppath, "/calcurse-note.", BUFSIZ - strlen(tmppath) - 1);
if ((tmpext = new_tempfile (tmppath, TMPEXTSIZ)) == NULL) if ((tmpext = new_tempfile(tmppath, TMPEXTSIZ)) == NULL)
return; return;
strncat (tmppath, tmpext, BUFSIZ - strlen (tmppath) - 1); strncat(tmppath, tmpext, BUFSIZ - strlen(tmppath) - 1);
mem_free (tmpext); mem_free(tmpext);
if (*note != NULL) if (*note != NULL) {
{ snprintf(notepath, BUFSIZ, "%s%s", path_notes, *note);
snprintf (notepath, BUFSIZ, "%s%s", path_notes, *note); io_file_cp(notepath, tmppath);
io_file_cp (notepath, tmppath); }
}
wins_launch_external (tmppath, editor); wins_launch_external(tmppath, editor);
if (io_file_is_empty (tmppath) > 0) if (io_file_is_empty(tmppath) > 0)
erase_note (note); erase_note(note);
else if ((fp = fopen (tmppath, "r"))) else if ((fp = fopen(tmppath, "r"))) {
{ sha1_stream(fp, sha1);
sha1_stream (fp, sha1); fclose(fp);
fclose (fp); *note = sha1;
*note = sha1;
snprintf (notepath, BUFSIZ, "%s%s", path_notes, *note); snprintf(notepath, BUFSIZ, "%s%s", path_notes, *note);
io_file_cp (tmppath, notepath); io_file_cp(tmppath, notepath);
} }
unlink (tmppath); unlink(tmppath);
} }
/* View a note in an external pager. */ /* View a note in an external pager. */
void void view_note(const char *note, const char *pager)
view_note (const char *note, const char *pager)
{ {
char fullname[BUFSIZ]; char fullname[BUFSIZ];
if (note == NULL) if (note == NULL)
return; return;
snprintf (fullname, BUFSIZ, "%s%s", path_notes, note); snprintf(fullname, BUFSIZ, "%s%s", path_notes, note);
wins_launch_external (fullname, pager); wins_launch_external(fullname, pager);
} }
/* Erase a note previously attached to an item. */ /* Erase a note previously attached to an item. */
void void erase_note(char **note)
erase_note (char **note)
{ {
if (*note == NULL) if (*note == NULL)
return; return;
mem_free (*note); mem_free(*note);
*note = NULL; *note = NULL;
} }
/* Read a serialized note file name from a stream and deserialize it. */ /* Read a serialized note file name from a stream and deserialize it. */
void void note_read(char *buffer, FILE * fp)
note_read (char *buffer, FILE *fp)
{ {
int i; int i;
for (i = 0; i < MAX_NOTESIZ; i++) for (i = 0; i < MAX_NOTESIZ; i++) {
{ buffer[i] = getc(fp);
buffer[i] = getc (fp); if (buffer[i] == ' ') {
if (buffer[i] == ' ') buffer[i] = '\0';
{ return;
buffer[i] = '\0';
return;
}
} }
}
while (getc (fp) != ' '); while (getc(fp) != ' ') ;
buffer[MAX_NOTESIZ] = '\0'; buffer[MAX_NOTESIZ] = '\0';
} }
static void static void
note_gc_extract_key (struct note_gc_hash *data, const char **key, int *len) note_gc_extract_key(struct note_gc_hash *data, const char **key, int *len)
{ {
*key = data->hash; *key = data->hash;
*len = strlen (data->hash); *len = strlen(data->hash);
} }
static int static int note_gc_cmp(struct note_gc_hash *a, struct note_gc_hash *b)
note_gc_cmp (struct note_gc_hash *a, struct note_gc_hash *b)
{ {
return strcmp (a->hash, b->hash); return strcmp(a->hash, b->hash);
} }
/* Spot and unlink unused note files. */ /* Spot and unlink unused note files. */
void void note_gc(void)
note_gc (void)
{ {
struct htp gc_htable = HTABLE_INITIALIZER (&gc_htable); struct htp gc_htable = HTABLE_INITIALIZER(&gc_htable);
struct note_gc_hash *hp; struct note_gc_hash *hp;
DIR *dirp; DIR *dirp;
struct dirent *dp; struct dirent *dp;
@ -179,81 +168,68 @@ note_gc (void)
struct note_gc_hash tmph; struct note_gc_hash tmph;
char notepath[BUFSIZ]; char notepath[BUFSIZ];
if (!(dirp = opendir (path_notes))) if (!(dirp = opendir(path_notes)))
return; return;
/* Insert all note file names into a hash table. */ /* Insert all note file names into a hash table. */
do do {
{ if ((dp = readdir(dirp)) && *(dp->d_name) != '.') {
if ((dp = readdir (dirp)) && *(dp->d_name) != '.') hp = mem_malloc(sizeof(struct note_gc_hash));
{
hp = mem_malloc (sizeof (struct note_gc_hash));
strncpy (hp->buf, dp->d_name, MAX_NOTESIZ + 1); strncpy(hp->buf, dp->d_name, MAX_NOTESIZ + 1);
hp->hash = hp->buf; hp->hash = hp->buf;
HTABLE_INSERT (htp, &gc_htable, hp); HTABLE_INSERT(htp, &gc_htable, hp);
}
} }
}
while (dp); while (dp);
closedir (dirp); closedir(dirp);
/* Remove hashes that are actually in use. */ /* Remove hashes that are actually in use. */
LLIST_TS_FOREACH (&alist_p, i) LLIST_TS_FOREACH(&alist_p, i) {
{ struct apoint *apt = LLIST_GET_DATA(i);
struct apoint *apt = LLIST_GET_DATA (i); if (apt->note) {
if (apt->note) tmph.hash = apt->note;
{ free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
tmph.hash = apt->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
} }
}
LLIST_FOREACH (&eventlist, i) LLIST_FOREACH(&eventlist, i) {
{ struct event *ev = LLIST_GET_DATA(i);
struct event *ev = LLIST_GET_DATA (i); if (ev->note) {
if (ev->note) tmph.hash = ev->note;
{ free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
tmph.hash = ev->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
} }
}
LLIST_TS_FOREACH (&recur_alist_p, i) LLIST_TS_FOREACH(&recur_alist_p, i) {
{ struct recur_apoint *rapt = LLIST_GET_DATA(i);
struct recur_apoint *rapt = LLIST_GET_DATA (i); if (rapt->note) {
if (rapt->note) tmph.hash = rapt->note;
{ free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
tmph.hash = rapt->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
} }
}
LLIST_FOREACH (&recur_elist, i) LLIST_FOREACH(&recur_elist, i) {
{ struct recur_event *rev = LLIST_GET_DATA(i);
struct recur_event *rev = LLIST_GET_DATA (i); if (rev->note) {
if (rev->note) tmph.hash = rev->note;
{ free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
tmph.hash = rev->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
} }
}
LLIST_FOREACH (&todolist, i) LLIST_FOREACH(&todolist, i) {
{ struct todo *todo = LLIST_GET_DATA(i);
struct todo *todo = LLIST_GET_DATA (i); if (todo->note) {
if (todo->note) tmph.hash = todo->note;
{ free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
tmph.hash = todo->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
} }
}
/* Unlink unused note files. */ /* Unlink unused note files. */
HTABLE_FOREACH (hp, htp, &gc_htable) HTABLE_FOREACH(hp, htp, &gc_htable) {
{ snprintf(notepath, BUFSIZ, "%s%s", path_notes, hp->hash);
snprintf (notepath, BUFSIZ, "%s%s", path_notes, hp->hash); unlink(notepath);
unlink (notepath); }
}
} }

824
src/notify.c
View File

File diff suppressed because it is too large Load Diff

368
src/pcal.c
View File

@ -39,279 +39,253 @@
#include "calcurse.h" #include "calcurse.h"
/* Static functions used to add export functionalities. */ /* Static functions used to add export functionalities. */
static void pcal_export_header (FILE *); static void pcal_export_header(FILE *);
static void pcal_export_recur_events (FILE *); static void pcal_export_recur_events(FILE *);
static void pcal_export_events (FILE *); static void pcal_export_events(FILE *);
static void pcal_export_recur_apoints (FILE *); static void pcal_export_recur_apoints(FILE *);
static void pcal_export_apoints (FILE *); static void pcal_export_apoints(FILE *);
static void pcal_export_todo (FILE *); static void pcal_export_todo(FILE *);
static void pcal_export_footer (FILE *); static void pcal_export_footer(FILE *);
/* Type definition for callbacks to export functions. */ /* Type definition for callbacks to export functions. */
typedef void (*cb_dump_t)(FILE *, long, long, char *); typedef void (*cb_dump_t) (FILE *, long, long, char *);
/* /*
* Travel through each occurence of an item, and execute the given callback * Travel through each occurence of an item, and execute the given callback
* (mainly used to export data). * (mainly used to export data).
*/ */
static void static void
foreach_date_dump (const long date_end, struct rpt *rpt, llist_t *exc, foreach_date_dump(const long date_end, struct rpt *rpt, llist_t * exc,
long item_first_date, long item_dur, char *item_mesg, long item_first_date, long item_dur, char *item_mesg,
cb_dump_t cb_dump, FILE *stream) cb_dump_t cb_dump, FILE * stream)
{ {
long date, item_time; long date, item_time;
struct tm lt; struct tm lt;
time_t t; time_t t;
t = item_first_date; t = item_first_date;
lt = *localtime (&t); lt = *localtime(&t);
lt.tm_hour = lt.tm_min = lt.tm_sec = 0; lt.tm_hour = lt.tm_min = lt.tm_sec = 0;
lt.tm_isdst = -1; lt.tm_isdst = -1;
date = mktime (&lt); date = mktime(&lt);
item_time = item_first_date - date; item_time = item_first_date - date;
while (date <= date_end && date <= rpt->until) while (date <= date_end && date <= rpt->until) {
{ if (recur_item_inday(item_first_date, item_dur, exc, rpt->type,
if (recur_item_inday (item_first_date, item_dur, exc, rpt->type, rpt->freq, rpt->until, date)) {
rpt->freq, rpt->until, date)) (*cb_dump) (stream, date + item_time, item_dur, item_mesg);
{
(*cb_dump)(stream, date + item_time, item_dur, item_mesg);
}
switch (rpt->type)
{
case RECUR_DAILY:
date = date_sec_change (date, 0, rpt->freq);
break;
case RECUR_WEEKLY:
date = date_sec_change (date, 0, rpt->freq * WEEKINDAYS);
break;
case RECUR_MONTHLY:
date = date_sec_change (date, rpt->freq, 0);
break;
case RECUR_YEARLY:
date = date_sec_change (date, rpt->freq * 12, 0);
break;
default:
EXIT (_("incoherent repetition type"));
/* NOTREACHED */
break;
}
} }
switch (rpt->type) {
case RECUR_DAILY:
date = date_sec_change(date, 0, rpt->freq);
break;
case RECUR_WEEKLY:
date = date_sec_change(date, 0, rpt->freq * WEEKINDAYS);
break;
case RECUR_MONTHLY:
date = date_sec_change(date, rpt->freq, 0);
break;
case RECUR_YEARLY:
date = date_sec_change(date, rpt->freq * 12, 0);
break;
default:
EXIT(_("incoherent repetition type"));
/* NOTREACHED */
break;
}
}
} }
static void static void pcal_export_header(FILE * stream)
pcal_export_header (FILE *stream)
{ {
fputs ("# calcurse pcal export\n", stream); fputs("# calcurse pcal export\n", stream);
fputs ("\n# =======\n# options\n# =======\n", stream); fputs("\n# =======\n# options\n# =======\n", stream);
fprintf (stream, "opt -A -K -l -m -F %s\n", fprintf(stream, "opt -A -K -l -m -F %s\n",
calendar_week_begins_on_monday () ? "Monday" : "Sunday"); calendar_week_begins_on_monday()? "Monday" : "Sunday");
fputs ("# Display week number (i.e. 1-52) on every Monday\n", stream); fputs("# Display week number (i.e. 1-52) on every Monday\n", stream);
fprintf (stream, "all monday in all %s %%w\n", _("Week")); fprintf(stream, "all monday in all %s %%w\n", _("Week"));
fputc ('\n', stream); fputc('\n', stream);
} }
static void static void pcal_export_footer(FILE * stream)
pcal_export_footer (FILE *stream)
{ {
} }
/* Format and dump event data to a pcal formatted file. */ /* Format and dump event data to a pcal formatted file. */
static void static void
pcal_dump_event (FILE *stream, long event_date, long event_dur, pcal_dump_event(FILE * stream, long event_date, long event_dur,
char *event_mesg) char *event_mesg)
{ {
char pcal_date[BUFSIZ]; char pcal_date[BUFSIZ];
date_sec2date_fmt (event_date, "%b %d", pcal_date); date_sec2date_fmt(event_date, "%b %d", pcal_date);
fprintf (stream, "%s %s\n", pcal_date, event_mesg); fprintf(stream, "%s %s\n", pcal_date, event_mesg);
} }
/* Format and dump appointment data to a pcal formatted file. */ /* Format and dump appointment data to a pcal formatted file. */
static void static void
pcal_dump_apoint (FILE *stream, long apoint_date, long apoint_dur, pcal_dump_apoint(FILE * stream, long apoint_date, long apoint_dur,
char *apoint_mesg) char *apoint_mesg)
{ {
char pcal_date[BUFSIZ], pcal_beg[BUFSIZ], pcal_end[BUFSIZ]; char pcal_date[BUFSIZ], pcal_beg[BUFSIZ], pcal_end[BUFSIZ];
date_sec2date_fmt (apoint_date, "%b %d", pcal_date); date_sec2date_fmt(apoint_date, "%b %d", pcal_date);
date_sec2date_fmt (apoint_date, "%R", pcal_beg); date_sec2date_fmt(apoint_date, "%R", pcal_beg);
date_sec2date_fmt (apoint_date + apoint_dur, "%R", pcal_end); date_sec2date_fmt(apoint_date + apoint_dur, "%R", pcal_end);
fprintf (stream, "%s ", pcal_date); fprintf(stream, "%s ", pcal_date);
fprintf (stream, "(%s -> %s) %s\n", pcal_beg, pcal_end, apoint_mesg); fprintf(stream, "(%s -> %s) %s\n", pcal_beg, pcal_end, apoint_mesg);
} }
static void static void pcal_export_recur_events(FILE * stream)
pcal_export_recur_events (FILE *stream)
{ {
llist_item_t *i; llist_item_t *i;
char pcal_date[BUFSIZ]; char pcal_date[BUFSIZ];
fputs ("\n# =============", stream); fputs("\n# =============", stream);
fputs ("\n# Recur. Events", stream); fputs("\n# Recur. Events", stream);
fputs ("\n# =============\n", stream); fputs("\n# =============\n", stream);
fputs ("# (pcal does not support from..until dates specification\n", stream); fputs("# (pcal does not support from..until dates specification\n", stream);
LLIST_FOREACH (&recur_elist, i) LLIST_FOREACH(&recur_elist, i) {
{ struct recur_event *rev = LLIST_GET_DATA(i);
struct recur_event *rev = LLIST_GET_DATA (i); if (rev->rpt->until == 0 && rev->rpt->freq == 1) {
if (rev->rpt->until == 0 && rev->rpt->freq == 1) switch (rev->rpt->type) {
{ case RECUR_DAILY:
switch (rev->rpt->type) date_sec2date_fmt(rev->day, "%b %d", pcal_date);
{ fprintf(stream, "all day on_or_after %s %s\n", pcal_date, rev->mesg);
case RECUR_DAILY: break;
date_sec2date_fmt (rev->day, "%b %d", pcal_date); case RECUR_WEEKLY:
fprintf (stream, "all day on_or_after %s %s\n", pcal_date, date_sec2date_fmt(rev->day, "%a", pcal_date);
rev->mesg); fprintf(stream, "all %s on_or_after ", pcal_date);
break; date_sec2date_fmt(rev->day, "%b %d", pcal_date);
case RECUR_WEEKLY: fprintf(stream, "%s %s\n", pcal_date, rev->mesg);
date_sec2date_fmt (rev->day, "%a", pcal_date); break;
fprintf (stream, "all %s on_or_after ", pcal_date); case RECUR_MONTHLY:
date_sec2date_fmt (rev->day, "%b %d", pcal_date); date_sec2date_fmt(rev->day, "%d", pcal_date);
fprintf (stream, "%s %s\n", pcal_date, rev->mesg); fprintf(stream, "day on all %s %s\n", pcal_date, rev->mesg);
break; break;
case RECUR_MONTHLY: case RECUR_YEARLY:
date_sec2date_fmt (rev->day, "%d", pcal_date); date_sec2date_fmt(rev->day, "%b %d", pcal_date);
fprintf (stream, "day on all %s %s\n", pcal_date, rev->mesg); fprintf(stream, "%s %s\n", pcal_date, rev->mesg);
break; break;
case RECUR_YEARLY: default:
date_sec2date_fmt (rev->day, "%b %d", pcal_date); EXIT(_("incoherent repetition type"));
fprintf (stream, "%s %s\n", pcal_date, rev->mesg); }
break; } else {
default: const long YEAR_START = calendar_start_of_year();
EXIT (_("incoherent repetition type")); const long YEAR_END = calendar_end_of_year();
}
}
else
{
const long YEAR_START = calendar_start_of_year ();
const long YEAR_END = calendar_end_of_year ();
if (rev->day < YEAR_END && rev->day > YEAR_START) if (rev->day < YEAR_END && rev->day > YEAR_START)
foreach_date_dump (YEAR_END, rev->rpt, &rev->exc, rev->day, 0, foreach_date_dump(YEAR_END, rev->rpt, &rev->exc, rev->day, 0,
rev->mesg, (cb_dump_t) pcal_dump_event, stream); rev->mesg, (cb_dump_t) pcal_dump_event, stream);
}
} }
}
} }
static void static void pcal_export_events(FILE * stream)
pcal_export_events (FILE *stream)
{ {
llist_item_t *i; llist_item_t *i;
fputs ("\n# ======\n# Events\n# ======\n", stream); fputs("\n# ======\n# Events\n# ======\n", stream);
LLIST_FOREACH (&eventlist, i) LLIST_FOREACH(&eventlist, i) {
{ struct event *ev = LLIST_TS_GET_DATA(i);
struct event *ev = LLIST_TS_GET_DATA (i); pcal_dump_event(stream, ev->day, 0, ev->mesg);
pcal_dump_event (stream, ev->day, 0, ev->mesg); }
} fputc('\n', stream);
fputc ('\n', stream);
} }
static void static void pcal_export_recur_apoints(FILE * stream)
pcal_export_recur_apoints (FILE *stream)
{ {
llist_item_t *i; llist_item_t *i;
char pcal_date[BUFSIZ], pcal_beg[BUFSIZ], pcal_end[BUFSIZ]; char pcal_date[BUFSIZ], pcal_beg[BUFSIZ], pcal_end[BUFSIZ];
fputs ("\n# ==============", stream); fputs("\n# ==============", stream);
fputs ("\n# Recur. Apoints", stream); fputs("\n# Recur. Apoints", stream);
fputs ("\n# ==============\n", stream); fputs("\n# ==============\n", stream);
fputs ("# (pcal does not support from..until dates specification\n", stream); fputs("# (pcal does not support from..until dates specification\n", stream);
LLIST_TS_FOREACH (&recur_alist_p, i) LLIST_TS_FOREACH(&recur_alist_p, i) {
{ struct recur_apoint *rapt = LLIST_TS_GET_DATA(i);
struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
if (rapt->rpt->until == 0 && rapt->rpt->freq == 1) if (rapt->rpt->until == 0 && rapt->rpt->freq == 1) {
{ date_sec2date_fmt(rapt->start, "%R", pcal_beg);
date_sec2date_fmt (rapt->start, "%R", pcal_beg); date_sec2date_fmt(rapt->start + rapt->dur, "%R", pcal_end);
date_sec2date_fmt (rapt->start + rapt->dur, "%R", pcal_end); switch (rapt->rpt->type) {
switch (rapt->rpt->type) case RECUR_DAILY:
{ date_sec2date_fmt(rapt->start, "%b %d", pcal_date);
case RECUR_DAILY: fprintf(stream, "all day on_or_after %s (%s -> %s) %s\n",
date_sec2date_fmt (rapt->start, "%b %d", pcal_date); pcal_date, pcal_beg, pcal_end, rapt->mesg);
fprintf (stream, "all day on_or_after %s (%s -> %s) %s\n", break;
pcal_date, pcal_beg, pcal_end, rapt->mesg); case RECUR_WEEKLY:
break; date_sec2date_fmt(rapt->start, "%a", pcal_date);
case RECUR_WEEKLY: fprintf(stream, "all %s on_or_after ", pcal_date);
date_sec2date_fmt (rapt->start, "%a", pcal_date); date_sec2date_fmt(rapt->start, "%b %d", pcal_date);
fprintf (stream, "all %s on_or_after ", pcal_date); fprintf(stream, "%s (%s -> %s) %s\n", pcal_date, pcal_beg,
date_sec2date_fmt (rapt->start, "%b %d", pcal_date); pcal_end, rapt->mesg);
fprintf (stream, "%s (%s -> %s) %s\n", pcal_date, pcal_beg, break;
pcal_end, rapt->mesg); case RECUR_MONTHLY:
break; date_sec2date_fmt(rapt->start, "%d", pcal_date);
case RECUR_MONTHLY: fprintf(stream, "day on all %s (%s -> %s) %s\n", pcal_date,
date_sec2date_fmt (rapt->start, "%d", pcal_date); pcal_beg, pcal_end, rapt->mesg);
fprintf (stream, "day on all %s (%s -> %s) %s\n", pcal_date, break;
pcal_beg, pcal_end, rapt->mesg); case RECUR_YEARLY:
break; date_sec2date_fmt(rapt->start, "%b %d", pcal_date);
case RECUR_YEARLY: fprintf(stream, "%s (%s -> %s) %s\n", pcal_date, pcal_beg,
date_sec2date_fmt (rapt->start, "%b %d", pcal_date); pcal_end, rapt->mesg);
fprintf (stream, "%s (%s -> %s) %s\n", pcal_date, pcal_beg, break;
pcal_end, rapt->mesg); default:
break; EXIT(_("incoherent repetition type"));
default: }
EXIT (_("incoherent repetition type")); } else {
} const long YEAR_START = calendar_start_of_year();
} const long YEAR_END = calendar_end_of_year();
else
{
const long YEAR_START = calendar_start_of_year ();
const long YEAR_END = calendar_end_of_year ();
if (rapt->start < YEAR_END && rapt->start > YEAR_START) if (rapt->start < YEAR_END && rapt->start > YEAR_START)
foreach_date_dump (YEAR_END, rapt->rpt, &rapt->exc, rapt->start, foreach_date_dump(YEAR_END, rapt->rpt, &rapt->exc, rapt->start,
rapt->dur, rapt->mesg, rapt->dur, rapt->mesg,
(cb_dump_t)pcal_dump_apoint, stream); (cb_dump_t) pcal_dump_apoint, stream);
}
} }
}
} }
static void static void pcal_export_apoints(FILE * stream)
pcal_export_apoints (FILE *stream)
{ {
llist_item_t *i; llist_item_t *i;
fputs ("\n# ============\n# Appointments\n# ============\n", stream); fputs("\n# ============\n# Appointments\n# ============\n", stream);
LLIST_TS_LOCK (&alist_p); LLIST_TS_LOCK(&alist_p);
LLIST_TS_FOREACH (&alist_p, i) LLIST_TS_FOREACH(&alist_p, i) {
{ struct apoint *apt = LLIST_TS_GET_DATA(i);
struct apoint *apt = LLIST_TS_GET_DATA (i); pcal_dump_apoint(stream, apt->start, apt->dur, apt->mesg);
pcal_dump_apoint (stream, apt->start, apt->dur, apt->mesg); }
} LLIST_TS_UNLOCK(&alist_p);
LLIST_TS_UNLOCK (&alist_p); fputc('\n', stream);
fputc ('\n', stream);
} }
static void static void pcal_export_todo(FILE * stream)
pcal_export_todo (FILE *stream)
{ {
llist_item_t *i; llist_item_t *i;
fputs ("#\n# Todos\n#\n", stream); fputs("#\n# Todos\n#\n", stream);
LLIST_FOREACH (&todolist, i) LLIST_FOREACH(&todolist, i) {
{ struct todo *todo = LLIST_TS_GET_DATA(i);
struct todo *todo = LLIST_TS_GET_DATA (i); if (todo->id < 0) /* completed items */
if (todo->id < 0) /* completed items */ continue;
continue;
fputs ("note all ", stream); fputs("note all ", stream);
fprintf (stream, "%d. %s\n", todo->id, todo->mesg); fprintf(stream, "%d. %s\n", todo->id, todo->mesg);
} }
fputc ('\n', stream); fputc('\n', stream);
} }
/* Export calcurse data. */ /* Export calcurse data. */
void void pcal_export_data(FILE * stream)
pcal_export_data (FILE *stream)
{ {
pcal_export_header (stream); pcal_export_header(stream);
pcal_export_recur_events (stream); pcal_export_recur_events(stream);
pcal_export_events (stream); pcal_export_events(stream);
pcal_export_recur_apoints (stream); pcal_export_recur_apoints(stream);
pcal_export_apoints (stream); pcal_export_apoints(stream);
pcal_export_todo (stream); pcal_export_todo(stream);
pcal_export_footer (stream); pcal_export_footer(stream);
} }

1191
src/recur.c
View File

File diff suppressed because it is too large Load Diff

224
src/sha1.c
View File

@ -67,61 +67,100 @@
#define R4(v, w, x, y, z, i) z += (w ^ x ^ y) + blk (i) + 0xCA62C1D6 + \ #define R4(v, w, x, y, z, i) z += (w ^ x ^ y) + blk (i) + 0xCA62C1D6 + \
rol (v, 5); w = rol (w, 30); rol (v, 5); w = rol (w, 30);
static void static void sha1_transform(uint32_t state[5], const uint8_t buffer[64])
sha1_transform (uint32_t state[5], const uint8_t buffer[64])
{ {
typedef union { typedef union {
uint8_t c[64]; uint8_t c[64];
uint32_t l[16]; uint32_t l[16];
} b64_t; } b64_t;
b64_t *block = (b64_t *)buffer; b64_t *block = (b64_t *) buffer;
uint32_t a = state[0]; uint32_t a = state[0];
uint32_t b = state[1]; uint32_t b = state[1];
uint32_t c = state[2]; uint32_t c = state[2];
uint32_t d = state[3]; uint32_t d = state[3];
uint32_t e = state[4]; uint32_t e = state[4];
R0 (a, b, c, d, e, 0); R0 (e, a, b, c, d, 1); R0(a, b, c, d, e, 0);
R0 (d, e, a, b, c, 2); R0 (c, d, e, a, b, 3); R0(e, a, b, c, d, 1);
R0 (b, c, d, e, a, 4); R0 (a, b, c, d, e, 5); R0(d, e, a, b, c, 2);
R0 (e, a, b, c, d, 6); R0 (d, e, a, b, c, 7); R0(c, d, e, a, b, 3);
R0 (c, d, e, a, b, 8); R0 (b, c, d, e, a, 9); R0(b, c, d, e, a, 4);
R0 (a, b, c, d, e, 10); R0 (e, a, b, c, d, 11); R0(a, b, c, d, e, 5);
R0 (d, e, a, b, c, 12); R0 (c, d, e, a, b, 13); R0(e, a, b, c, d, 6);
R0 (b, c, d, e, a, 14); R0 (a, b, c, d, e, 15); R0(d, e, a, b, c, 7);
R1 (e, a, b, c, d, 16); R1 (d, e, a, b, c, 17); R0(c, d, e, a, b, 8);
R1 (c, d, e, a, b, 18); R1 (b, c, d, e, a, 19); R0(b, c, d, e, a, 9);
R2 (a, b, c, d, e, 20); R2 (e, a, b, c, d, 21); R0(a, b, c, d, e, 10);
R2 (d, e, a, b, c, 22); R2 (c, d, e, a, b, 23); R0(e, a, b, c, d, 11);
R2 (b, c, d, e, a, 24); R2 (a, b, c, d, e, 25); R0(d, e, a, b, c, 12);
R2 (e, a, b, c, d, 26); R2 (d, e, a, b, c, 27); R0(c, d, e, a, b, 13);
R2 (c, d, e, a, b, 28); R2 (b, c, d, e, a, 29); R0(b, c, d, e, a, 14);
R2 (a, b, c, d, e, 30); R2 (e, a, b, c, d, 31); R0(a, b, c, d, e, 15);
R2 (d, e, a, b, c, 32); R2 (c, d, e, a, b, 33); R1(e, a, b, c, d, 16);
R2 (b, c, d, e, a, 34); R2 (a, b, c, d, e, 35); R1(d, e, a, b, c, 17);
R2 (e, a, b, c, d, 36); R2 (d, e, a, b, c, 37); R1(c, d, e, a, b, 18);
R2 (c, d, e, a, b, 38); R2 (b, c, d, e, a, 39); R1(b, c, d, e, a, 19);
R3 (a, b, c, d, e, 40); R3 (e, a, b, c, d, 41); R2(a, b, c, d, e, 20);
R3 (d, e, a, b, c, 42); R3 (c, d, e, a, b, 43); R2(e, a, b, c, d, 21);
R3 (b, c, d, e, a, 44); R3 (a, b, c, d, e, 45); R2(d, e, a, b, c, 22);
R3 (e, a, b, c, d, 46); R3 (d, e, a, b, c, 47); R2(c, d, e, a, b, 23);
R3 (c, d, e, a, b, 48); R3 (b, c, d, e, a, 49); R2(b, c, d, e, a, 24);
R3 (a, b, c, d, e, 50); R3 (e, a, b, c, d, 51); R2(a, b, c, d, e, 25);
R3 (d, e, a, b, c, 52); R3 (c, d, e, a, b, 53); R2(e, a, b, c, d, 26);
R3 (b, c, d, e, a, 54); R3 (a, b, c, d, e, 55); R2(d, e, a, b, c, 27);
R3 (e, a, b, c, d, 56); R3 (d, e, a, b, c, 57); R2(c, d, e, a, b, 28);
R3 (c, d, e, a, b, 58); R3 (b, c, d, e, a, 59); R2(b, c, d, e, a, 29);
R4 (a, b, c, d, e, 60); R4 (e, a, b, c, d, 61); R2(a, b, c, d, e, 30);
R4 (d, e, a, b, c, 62); R4 (c, d, e, a, b, 63); R2(e, a, b, c, d, 31);
R4 (b, c, d, e, a, 64); R4 (a, b, c, d, e, 65); R2(d, e, a, b, c, 32);
R4 (e, a, b, c, d, 66); R4 (d, e, a, b, c, 67); R2(c, d, e, a, b, 33);
R4 (c, d, e, a, b, 68); R4 (b, c, d, e, a, 69); R2(b, c, d, e, a, 34);
R4 (a, b, c, d, e, 70); R4 (e, a, b, c, d, 71); R2(a, b, c, d, e, 35);
R4 (d, e, a, b, c, 72); R4 (c, d, e, a, b, 73); R2(e, a, b, c, d, 36);
R4 (b, c, d, e, a, 74); R4 (a, b, c, d, e, 75); R2(d, e, a, b, c, 37);
R4 (e, a, b, c, d, 76); R4 (d, e, a, b, c, 77); R2(c, d, e, a, b, 38);
R4 (c, d, e, a, b, 78); R4 (b, c, d, e, a, 79); R2(b, c, d, e, a, 39);
R3(a, b, c, d, e, 40);
R3(e, a, b, c, d, 41);
R3(d, e, a, b, c, 42);
R3(c, d, e, a, b, 43);
R3(b, c, d, e, a, 44);
R3(a, b, c, d, e, 45);
R3(e, a, b, c, d, 46);
R3(d, e, a, b, c, 47);
R3(c, d, e, a, b, 48);
R3(b, c, d, e, a, 49);
R3(a, b, c, d, e, 50);
R3(e, a, b, c, d, 51);
R3(d, e, a, b, c, 52);
R3(c, d, e, a, b, 53);
R3(b, c, d, e, a, 54);
R3(a, b, c, d, e, 55);
R3(e, a, b, c, d, 56);
R3(d, e, a, b, c, 57);
R3(c, d, e, a, b, 58);
R3(b, c, d, e, a, 59);
R4(a, b, c, d, e, 60);
R4(e, a, b, c, d, 61);
R4(d, e, a, b, c, 62);
R4(c, d, e, a, b, 63);
R4(b, c, d, e, a, 64);
R4(a, b, c, d, e, 65);
R4(e, a, b, c, d, 66);
R4(d, e, a, b, c, 67);
R4(c, d, e, a, b, 68);
R4(b, c, d, e, a, 69);
R4(a, b, c, d, e, 70);
R4(e, a, b, c, d, 71);
R4(d, e, a, b, c, 72);
R4(c, d, e, a, b, 73);
R4(b, c, d, e, a, 74);
R4(a, b, c, d, e, 75);
R4(e, a, b, c, d, 76);
R4(d, e, a, b, c, 77);
R4(c, d, e, a, b, 78);
R4(b, c, d, e, a, 79);
state[0] += a; state[0] += a;
state[1] += b; state[1] += b;
@ -132,9 +171,7 @@ sha1_transform (uint32_t state[5], const uint8_t buffer[64])
a = b = c = d = e = 0; a = b = c = d = e = 0;
} }
void sha1_init(sha1_ctx_t * ctx)
void
sha1_init (sha1_ctx_t *ctx)
{ {
ctx->state[0] = 0x67452301; ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89; ctx->state[1] = 0xEFCDAB89;
@ -145,8 +182,7 @@ sha1_init (sha1_ctx_t *ctx)
ctx->count[0] = ctx->count[1] = 0; ctx->count[0] = ctx->count[1] = 0;
} }
void void sha1_update(sha1_ctx_t * ctx, const uint8_t * data, unsigned int len)
sha1_update (sha1_ctx_t *ctx, const uint8_t *data, unsigned int len)
{ {
unsigned int i, j; unsigned int i, j;
@ -155,67 +191,59 @@ sha1_update (sha1_ctx_t *ctx, const uint8_t *data, unsigned int len)
ctx->count[1]++; ctx->count[1]++;
ctx->count[1] += (len >> 29); ctx->count[1] += (len >> 29);
if (j + len > 63) if (j + len > 63) {
{ memcpy(&ctx->buffer[j], data, (i = 64 - j));
memcpy (&ctx->buffer[j], data, (i = 64 - j)); sha1_transform(ctx->state, ctx->buffer);
sha1_transform (ctx->state, ctx->buffer); for (; i + 63 < len; i += 64)
for (; i + 63 < len; i += 64) sha1_transform(ctx->state, &data[i]);
sha1_transform (ctx->state, &data[i]); j = 0;
j = 0; } else
}
else
i = 0; i = 0;
memcpy (&ctx->buffer[j], &data[i], len - i); memcpy(&ctx->buffer[j], &data[i], len - i);
} }
void sha1_final(sha1_ctx_t * ctx, uint8_t digest[SHA1_DIGESTLEN])
void
sha1_final (sha1_ctx_t *ctx, uint8_t digest[SHA1_DIGESTLEN])
{ {
uint32_t i, j; uint32_t i, j;
uint8_t finalcount[8]; uint8_t finalcount[8];
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++) {
{ finalcount[i] = (uint8_t) ((ctx->count[(i >= 4 ? 0 : 1)] >>
finalcount[i] = (uint8_t)((ctx->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255);
((3 - (i & 3)) * 8)) & 255); }
}
sha1_update (ctx, (uint8_t *)"\200", 1); sha1_update(ctx, (uint8_t *) "\200", 1);
while ((ctx->count[0] & 504) != 448) while ((ctx->count[0] & 504) != 448)
sha1_update (ctx, (uint8_t *)"\0", 1); sha1_update(ctx, (uint8_t *) "\0", 1);
sha1_update (ctx, finalcount, 8); sha1_update(ctx, finalcount, 8);
for (i = 0; i < SHA1_DIGESTLEN; i++) for (i = 0; i < SHA1_DIGESTLEN; i++)
digest[i] = (uint8_t)((ctx->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255); digest[i] = (uint8_t) ((ctx->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
i = j = 0; i = j = 0;
memset (ctx->buffer, 0, SHA1_BLOCKLEN); memset(ctx->buffer, 0, SHA1_BLOCKLEN);
memset (ctx->state, 0, SHA1_DIGESTLEN); memset(ctx->state, 0, SHA1_DIGESTLEN);
memset (ctx->count, 0, 8); memset(ctx->count, 0, 8);
memset (&finalcount, 0, 8); memset(&finalcount, 0, 8);
} }
void void sha1_digest(const char *data, char *buffer)
sha1_digest (const char *data, char *buffer)
{ {
sha1_ctx_t ctx; sha1_ctx_t ctx;
uint8_t digest[SHA1_DIGESTLEN]; uint8_t digest[SHA1_DIGESTLEN];
int i; int i;
sha1_init (&ctx); sha1_init(&ctx);
sha1_update (&ctx, (const uint8_t *)data, strlen (data)); sha1_update(&ctx, (const uint8_t *)data, strlen(data));
sha1_final (&ctx, (uint8_t *)digest); sha1_final(&ctx, (uint8_t *) digest);
for (i = 0; i < SHA1_DIGESTLEN; i++) for (i = 0; i < SHA1_DIGESTLEN; i++) {
{ snprintf(buffer, 3, "%02x", digest[i]);
snprintf (buffer, 3, "%02x", digest[i]); buffer += sizeof(char) * 2;
buffer += sizeof (char) * 2; }
}
} }
void void sha1_stream(FILE * fp, char *buffer)
sha1_stream (FILE *fp, char *buffer)
{ {
sha1_ctx_t ctx; sha1_ctx_t ctx;
uint8_t data[BUFSIZ]; uint8_t data[BUFSIZ];
@ -223,19 +251,17 @@ sha1_stream (FILE *fp, char *buffer)
uint8_t digest[SHA1_DIGESTLEN]; uint8_t digest[SHA1_DIGESTLEN];
int i; int i;
sha1_init (&ctx); sha1_init(&ctx);
while (!feof (fp)) while (!feof(fp)) {
{ bytes_read = fread(data, 1, BUFSIZ, fp);
bytes_read = fread (data, 1, BUFSIZ, fp); sha1_update(&ctx, data, bytes_read);
sha1_update (&ctx, data, bytes_read); }
}
sha1_final (&ctx, (uint8_t *)digest); sha1_final(&ctx, (uint8_t *) digest);
for (i = 0; i < SHA1_DIGESTLEN; i++) for (i = 0; i < SHA1_DIGESTLEN; i++) {
{ snprintf(buffer, 3, "%02x", digest[i]);
snprintf (buffer, 3, "%02x", digest[i]); buffer += sizeof(char) * 2;
buffer += sizeof (char) * 2; }
}
} }

10
src/sha1.h
View File

@ -50,8 +50,8 @@ typedef struct {
uint8_t buffer[SHA1_BLOCKLEN]; uint8_t buffer[SHA1_BLOCKLEN];
} sha1_ctx_t; } sha1_ctx_t;
void sha1_init (sha1_ctx_t *); void sha1_init(sha1_ctx_t *);
void sha1_update (sha1_ctx_t *, const uint8_t *, unsigned int); void sha1_update(sha1_ctx_t *, const uint8_t *, unsigned int);
void sha1_final (sha1_ctx_t *, uint8_t *); void sha1_final(sha1_ctx_t *, uint8_t *);
void sha1_digest (const char *, char *); void sha1_digest(const char *, char *);
void sha1_stream (FILE *, char *); void sha1_stream(FILE *, char *);

67
src/sigs.c
View File

@ -53,57 +53,48 @@
* This is needed to avoid zombie processes running on system. * This is needed to avoid zombie processes running on system.
* Also catch CTRL-C (SIGINT), and SIGWINCH to resize screen automatically. * Also catch CTRL-C (SIGINT), and SIGWINCH to resize screen automatically.
*/ */
static void static void generic_hdlr(int sig)
generic_hdlr (int sig)
{ {
switch (sig) switch (sig) {
{ case SIGCHLD:
case SIGCHLD: while (waitpid(WAIT_MYPGRP, NULL, WNOHANG) > 0) ;
while (waitpid (WAIT_MYPGRP, NULL, WNOHANG) > 0) break;
; case SIGWINCH:
break; resize = 1;
case SIGWINCH: clearok(curscr, TRUE);
resize = 1; ungetch(KEY_RESIZE);
clearok (curscr, TRUE); break;
ungetch (KEY_RESIZE); case SIGTERM:
break; if (unlink(path_cpid) != 0) {
case SIGTERM: EXIT(_("Could not remove calcurse lock file: %s\n"), strerror(errno));
if (unlink (path_cpid) != 0)
{
EXIT (_("Could not remove calcurse lock file: %s\n"),
strerror (errno));
}
exit (EXIT_SUCCESS);
break;
} }
exit(EXIT_SUCCESS);
break;
}
} }
unsigned unsigned sigs_set_hdlr(int sig, void (*handler) (int))
sigs_set_hdlr (int sig, void (*handler)(int))
{ {
struct sigaction sa; struct sigaction sa;
memset (&sa, 0, sizeof sa); memset(&sa, 0, sizeof sa);
sigemptyset (&sa.sa_mask); sigemptyset(&sa.sa_mask);
sa.sa_handler = handler; sa.sa_handler = handler;
sa.sa_flags = 0; sa.sa_flags = 0;
if (sigaction (sig, &sa, NULL) == -1) if (sigaction(sig, &sa, NULL) == -1) {
{ ERROR_MSG(_("Error setting signal #%d : %s\n"), sig, strerror(errno));
ERROR_MSG (_("Error setting signal #%d : %s\n"), return 0;
sig, strerror (errno)); }
return 0;
}
return 1; return 1;
} }
/* Signal handling init. */ /* Signal handling init. */
void void sigs_init()
sigs_init ()
{ {
if (!sigs_set_hdlr (SIGCHLD, generic_hdlr) if (!sigs_set_hdlr(SIGCHLD, generic_hdlr)
|| !sigs_set_hdlr (SIGWINCH, generic_hdlr) || !sigs_set_hdlr(SIGWINCH, generic_hdlr)
|| !sigs_set_hdlr (SIGTERM, generic_hdlr) || !sigs_set_hdlr(SIGTERM, generic_hdlr)
|| !sigs_set_hdlr (SIGINT, SIG_IGN)) || !sigs_set_hdlr(SIGINT, SIG_IGN))
exit_calcurse (1); exit_calcurse(1);
} }

413
src/todo.c
View File

@ -47,67 +47,57 @@ static int first = 1;
static char *msgsav; static char *msgsav;
/* Returns a structure containing the selected item. */ /* Returns a structure containing the selected item. */
static struct todo * static struct todo *todo_get_item(int item_number)
todo_get_item (int item_number)
{ {
return LLIST_GET_DATA (LLIST_NTH (&todolist, item_number - 1)); return LLIST_GET_DATA(LLIST_NTH(&todolist, item_number - 1));
} }
/* Sets which todo is highlighted. */ /* Sets which todo is highlighted. */
void void todo_hilt_set(int highlighted)
todo_hilt_set (int highlighted)
{ {
hilt = highlighted; hilt = highlighted;
} }
void void todo_hilt_decrease(int n)
todo_hilt_decrease (int n)
{ {
hilt -= n; hilt -= n;
} }
void void todo_hilt_increase(int n)
todo_hilt_increase (int n)
{ {
hilt += n; hilt += n;
} }
/* Return which todo is highlighted. */ /* Return which todo is highlighted. */
int int todo_hilt(void)
todo_hilt (void)
{ {
return hilt; return hilt;
} }
/* Return the number of todos. */ /* Return the number of todos. */
int int todo_nb(void)
todo_nb (void)
{ {
return todos; return todos;
} }
/* Set the number of todos. */ /* Set the number of todos. */
void void todo_set_nb(int nb)
todo_set_nb (int nb)
{ {
todos = nb; todos = nb;
} }
/* Set which one is the first todo to be displayed. */ /* Set which one is the first todo to be displayed. */
void void todo_set_first(int nb)
todo_set_first (int nb)
{ {
first = nb; first = nb;
} }
void void todo_first_increase(int n)
todo_first_increase (int n)
{ {
first += n; first += n;
} }
void void todo_first_decrease(int n)
todo_first_decrease (int n)
{ {
first -= n; first -= n;
} }
@ -116,51 +106,46 @@ todo_first_decrease (int n)
* Return the position of the hilghlighted item, relative to the first one * Return the position of the hilghlighted item, relative to the first one
* displayed. * displayed.
*/ */
int int todo_hilt_pos(void)
todo_hilt_pos (void)
{ {
return hilt - first; return hilt - first;
} }
/* Return the last visited todo. */ /* Return the last visited todo. */
char * char *todo_saved_mesg(void)
todo_saved_mesg (void)
{ {
return msgsav; return msgsav;
} }
/* Request user to enter a new todo item. */ /* Request user to enter a new todo item. */
void void todo_new_item(void)
todo_new_item (void)
{ {
int ch = 0; int ch = 0;
const char *mesg = _("Enter the new ToDo item : "); const char *mesg = _("Enter the new ToDo item : ");
const char *mesg_id = _("Enter the ToDo priority [1 (highest) - 9 (lowest)] :"); const char *mesg_id =
_("Enter the ToDo priority [1 (highest) - 9 (lowest)] :");
char todo_input[BUFSIZ] = ""; char todo_input[BUFSIZ] = "";
status_mesg (mesg, ""); status_mesg(mesg, "");
if (getstring (win[STA].p, todo_input, BUFSIZ, 0, 1) == GETSTRING_VALID) if (getstring(win[STA].p, todo_input, BUFSIZ, 0, 1) == GETSTRING_VALID) {
{ while ((ch < '1') || (ch > '9')) {
while ((ch < '1') || (ch > '9')) status_mesg(mesg_id, "");
{ ch = wgetch(win[STA].p);
status_mesg (mesg_id, "");
ch = wgetch (win[STA].p);
}
todo_add (todo_input, ch - '0', NULL);
todos++;
} }
todo_add(todo_input, ch - '0', NULL);
todos++;
}
} }
static int static int todo_cmp_id(struct todo *a, struct todo *b)
todo_cmp_id (struct todo *a, struct todo *b)
{ {
/* /*
* As of version 2.6, todo items can have a negative id, which means they * As of version 2.6, todo items can have a negative id, which means they
* were completed. To keep them sorted, we need to consider the absolute id * were completed. To keep them sorted, we need to consider the absolute id
* value. * value.
*/ */
int abs_a = abs (a->id); int abs_a = abs(a->id);
int abs_b = abs (b->id); int abs_b = abs(b->id);
return abs_a < abs_b ? -1 : (abs_a == abs_b ? 0 : 1); return abs_a < abs_b ? -1 : (abs_a == abs_b ? 0 : 1);
} }
@ -168,59 +153,55 @@ todo_cmp_id (struct todo *a, struct todo *b)
/* /*
* Add an item in the todo linked list. * Add an item in the todo linked list.
*/ */
struct todo * struct todo *todo_add(char *mesg, int id, char *note)
todo_add (char *mesg, int id, char *note)
{ {
struct todo *todo; struct todo *todo;
todo = mem_malloc (sizeof (struct todo)); todo = mem_malloc(sizeof(struct todo));
todo->mesg = mem_strdup (mesg); todo->mesg = mem_strdup(mesg);
todo->id = id; todo->id = id;
todo->note = (note != NULL && note[0] != '\0') ? mem_strdup (note) : NULL; todo->note = (note != NULL && note[0] != '\0') ? mem_strdup(note) : NULL;
LLIST_ADD_SORTED (&todolist, todo, todo_cmp_id); LLIST_ADD_SORTED(&todolist, todo, todo_cmp_id);
return todo; return todo;
} }
void void todo_write(struct todo *todo, FILE * f)
todo_write (struct todo *todo, FILE *f)
{ {
if (todo->note) if (todo->note)
fprintf (f, "[%d]>%s %s\n", todo->id, todo->note, todo->mesg); fprintf(f, "[%d]>%s %s\n", todo->id, todo->note, todo->mesg);
else else
fprintf (f, "[%d] %s\n", todo->id, todo->mesg); fprintf(f, "[%d] %s\n", todo->id, todo->mesg);
} }
/* Delete a note previously attached to a todo item. */ /* Delete a note previously attached to a todo item. */
static void static void todo_delete_note_bynum(unsigned num)
todo_delete_note_bynum (unsigned num)
{ {
llist_item_t *i = LLIST_NTH (&todolist, num); llist_item_t *i = LLIST_NTH(&todolist, num);
if (!i) if (!i)
EXIT (_("no such todo")); EXIT(_("no such todo"));
struct todo *todo = LLIST_TS_GET_DATA (i); struct todo *todo = LLIST_TS_GET_DATA(i);
if (!todo->note) if (!todo->note)
EXIT (_("no note attached")); EXIT(_("no note attached"));
erase_note (&todo->note); erase_note(&todo->note);
} }
/* Delete an item from the todo linked list. */ /* Delete an item from the todo linked list. */
static void static void todo_delete_bynum(unsigned num)
todo_delete_bynum (unsigned num)
{ {
llist_item_t *i = LLIST_NTH (&todolist, num); llist_item_t *i = LLIST_NTH(&todolist, num);
if (!i) if (!i)
EXIT (_("no such todo")); EXIT(_("no such todo"));
struct todo *todo = LLIST_TS_GET_DATA (i); struct todo *todo = LLIST_TS_GET_DATA(i);
LLIST_REMOVE (&todolist, i); LLIST_REMOVE(&todolist, i);
mem_free (todo->mesg); mem_free(todo->mesg);
erase_note (&todo->note); erase_note(&todo->note);
mem_free (todo); mem_free(todo);
} }
/* /*
@ -229,18 +210,16 @@ todo_delete_bynum (unsigned num)
* This way, it is easy to retrive its original priority if the user decides * This way, it is easy to retrive its original priority if the user decides
* that in fact it was not completed. * that in fact it was not completed.
*/ */
void void todo_flag(void)
todo_flag (void)
{ {
struct todo *t; struct todo *t;
t = todo_get_item (hilt); t = todo_get_item(hilt);
t->id = -t->id; t->id = -t->id;
} }
/* Delete an item from the ToDo list. */ /* Delete an item from the ToDo list. */
void void todo_delete(void)
todo_delete (void)
{ {
const char *del_todo_str = _("Do you really want to delete this task ?"); const char *del_todo_str = _("Do you really want to delete this task ?");
const char *erase_warning = const char *erase_warning =
@ -251,116 +230,109 @@ todo_delete (void)
int answer; int answer;
if ((todos <= 0) || if ((todos <= 0) ||
(conf.confirm_delete && (status_ask_bool (del_todo_str) != 1))) (conf.confirm_delete && (status_ask_bool(del_todo_str) != 1))) {
{ wins_erase_status_bar();
wins_erase_status_bar (); return;
return; }
}
/* This todo item doesn't have any note associated. */ /* This todo item doesn't have any note associated. */
if (todo_get_item (hilt)->note == NULL) if (todo_get_item(hilt)->note == NULL)
answer = 1; answer = 1;
else else
answer = status_ask_choice (erase_warning, erase_choice, nb_erase_choice); answer = status_ask_choice(erase_warning, erase_choice, nb_erase_choice);
switch (answer) switch (answer) {
{ case 1:
case 1: todo_delete_bynum(hilt - 1);
todo_delete_bynum (hilt - 1); todos--;
todos--; if (hilt > 1)
if (hilt > 1) hilt--;
hilt--; if (todos == 0)
if (todos == 0) hilt = 0;
hilt = 0; if (hilt - first < 0)
if (hilt - first < 0) first--;
first--; break;
break; case 2:
case 2: todo_delete_note_bynum(hilt - 1);
todo_delete_note_bynum (hilt - 1); break;
break; default:
default: wins_erase_status_bar();
wins_erase_status_bar (); return;
return; }
}
} }
/* /*
* Returns the position into the linked list corresponding to the * Returns the position into the linked list corresponding to the
* given todo item. * given todo item.
*/ */
static int static int todo_get_position(struct todo *needle)
todo_get_position (struct todo *needle)
{ {
llist_item_t *i; llist_item_t *i;
int n = 0; int n = 0;
LLIST_FOREACH (&todolist, i) LLIST_FOREACH(&todolist, i) {
{ n++;
n++; if (LLIST_TS_GET_DATA(i) == needle)
if (LLIST_TS_GET_DATA (i) == needle) return n;
return n; }
}
EXIT (_("todo not found")); EXIT(_("todo not found"));
return -1; /* avoid compiler warnings */ return -1; /* avoid compiler warnings */
} }
/* Change an item priority by pressing '+' or '-' inside TODO panel. */ /* Change an item priority by pressing '+' or '-' inside TODO panel. */
void void todo_chg_priority(int action)
todo_chg_priority (int action)
{ {
struct todo *backup; struct todo *backup;
char backup_mesg[BUFSIZ]; char backup_mesg[BUFSIZ];
int backup_id; int backup_id;
char backup_note[MAX_NOTESIZ + 1]; char backup_note[MAX_NOTESIZ + 1];
backup = todo_get_item (hilt); backup = todo_get_item(hilt);
strncpy (backup_mesg, backup->mesg, strlen (backup->mesg) + 1); strncpy(backup_mesg, backup->mesg, strlen(backup->mesg) + 1);
backup_id = backup->id; backup_id = backup->id;
if (backup->note) if (backup->note)
strncpy (backup_note, backup->note, MAX_NOTESIZ + 1); strncpy(backup_note, backup->note, MAX_NOTESIZ + 1);
else else
backup_note[0] = '\0'; backup_note[0] = '\0';
switch (action) switch (action) {
{ case KEY_RAISE_PRIORITY:
case KEY_RAISE_PRIORITY: if (backup_id > 1)
if (backup_id > 1) backup_id--;
backup_id--; else
else return;
return; break;
break; case KEY_LOWER_PRIORITY:
case KEY_LOWER_PRIORITY: if (backup_id > 0 && backup_id < 9)
if (backup_id > 0 && backup_id < 9) backup_id++;
backup_id++; else
else return;
return; break;
break; default:
default: EXIT(_("no such action"));
EXIT (_("no such action")); /* NOTREACHED */
/* NOTREACHED */ }
}
todo_delete_bynum (hilt - 1); todo_delete_bynum(hilt - 1);
backup = todo_add (backup_mesg, backup_id, backup_note); backup = todo_add(backup_mesg, backup_id, backup_note);
hilt = todo_get_position (backup); hilt = todo_get_position(backup);
} }
/* Edit the description of an already existing todo item. */ /* Edit the description of an already existing todo item. */
void void todo_edit_item(void)
todo_edit_item (void)
{ {
struct todo *i; struct todo *i;
const char *mesg = _("Enter the new ToDo description :"); const char *mesg = _("Enter the new ToDo description :");
status_mesg (mesg, ""); status_mesg(mesg, "");
i = todo_get_item (hilt); i = todo_get_item(hilt);
updatestring (win[STA].p, &i->mesg, 0, 1); updatestring(win[STA].p, &i->mesg, 0, 1);
} }
/* Display todo items in the corresponding panel. */ /* Display todo items in the corresponding panel. */
static void static void
display_todo_item (int incolor, char *msg, int prio, int note, int width, int y, display_todo_item(int incolor, char *msg, int prio, int note, int width, int y,
int x) int x)
{ {
WINDOW *w; WINDOW *w;
int ch_note; int ch_note;
@ -370,35 +342,32 @@ display_todo_item (int incolor, char *msg, int prio, int note, int width, int y,
w = win[TOD].p; w = win[TOD].p;
ch_note = (note) ? '>' : '.'; ch_note = (note) ? '>' : '.';
if (prio > 0) if (prio > 0)
snprintf (priostr, sizeof priostr, "%d", prio); snprintf(priostr, sizeof priostr, "%d", prio);
else else
strncpy (priostr, "X", sizeof priostr); strncpy(priostr, "X", sizeof priostr);
if (incolor == 0) if (incolor == 0)
custom_apply_attr (w, ATTR_HIGHEST); custom_apply_attr(w, ATTR_HIGHEST);
if (utf8_strwidth (msg) < width) if (utf8_strwidth(msg) < width)
mvwprintw (w, y, x, "%s%c %s", priostr, ch_note, msg); mvwprintw(w, y, x, "%s%c %s", priostr, ch_note, msg);
else else {
{ for (i = 0; msg[i] && width > 0; i++) {
for (i = 0; msg[i] && width > 0; i++) if (!UTF8_ISCONT(msg[i]))
{ width -= utf8_width(&msg[i]);
if (!UTF8_ISCONT (msg[i])) buf[i] = msg[i];
width -= utf8_width (&msg[i]);
buf[i] = msg[i];
}
if (i)
buf[i - 1] = 0;
else
buf[0] = 0;
mvwprintw (w, y, x, "%s%c %s...", priostr, ch_note, buf);
} }
if (i)
buf[i - 1] = 0;
else
buf[0] = 0;
mvwprintw(w, y, x, "%s%c %s...", priostr, ch_note, buf);
}
if (incolor == 0) if (incolor == 0)
custom_remove_attr (w, ATTR_HIGHEST); custom_remove_attr(w, ATTR_HIGHEST);
} }
/* Updates the ToDo panel. */ /* Updates the ToDo panel. */
void void todo_update_panel(int which_pan)
todo_update_panel (int which_pan)
{ {
llist_item_t *i; llist_item_t *i;
int len = win[TOD].w - 8; int len = win[TOD].w - 8;
@ -411,62 +380,54 @@ todo_update_panel (int which_pan)
int incolor = -1; int incolor = -1;
/* Print todo item in the panel. */ /* Print todo item in the panel. */
erase_window_part (win[TOD].p, 1, title_lines, win[TOD].w - 2, erase_window_part(win[TOD].p, 1, title_lines, win[TOD].w - 2, win[TOD].h - 2);
win[TOD].h - 2); LLIST_FOREACH(&todolist, i) {
LLIST_FOREACH (&todolist, i) struct todo *todo = LLIST_TS_GET_DATA(i);
{ num_todo++;
struct todo *todo = LLIST_TS_GET_DATA (i); t_realpos = num_todo - first;
num_todo++; incolor = (which_pan == TOD) ? num_todo - hilt : num_todo;
t_realpos = num_todo - first; if (incolor == 0)
incolor = (which_pan == TOD) ? num_todo - hilt : num_todo; msgsav = todo->mesg;
if (incolor == 0) if (t_realpos >= 0 && t_realpos < max_items) {
msgsav = todo->mesg; display_todo_item(incolor, todo->mesg, todo->id,
if (t_realpos >= 0 && t_realpos < max_items) (todo->note != NULL) ? 1 : 0, len, y_offset, x_offset);
{ y_offset = y_offset + todo_lines;
display_todo_item (incolor, todo->mesg, todo->id,
(todo->note != NULL) ? 1 : 0, len, y_offset,
x_offset);
y_offset = y_offset + todo_lines;
}
} }
}
/* Draw the scrollbar if necessary. */ /* Draw the scrollbar if necessary. */
if (todos > max_items) if (todos > max_items) {
{ float ratio = ((float)max_items) / ((float)todos);
float ratio = ((float) max_items) / ((float) todos); int sbar_length = (int)(ratio * (max_items + 1));
int sbar_length = (int) (ratio * (max_items + 1)); int highend = (int)(ratio * first);
int highend = (int) (ratio * first); unsigned hilt_bar = (which_pan == TOD) ? 1 : 0;
unsigned hilt_bar = (which_pan == TOD) ? 1 : 0; int sbar_top = highend + title_lines;
int sbar_top = highend + title_lines;
if ((sbar_top + sbar_length) > win[TOD].h - 1) if ((sbar_top + sbar_length) > win[TOD].h - 1)
sbar_length = win[TOD].h - 1 - sbar_top; sbar_length = win[TOD].h - 1 - sbar_top;
draw_scrollbar (win[TOD].p, sbar_top, win[TOD].w - 2, draw_scrollbar(win[TOD].p, sbar_top, win[TOD].w - 2,
sbar_length, title_lines, win[TOD].h - 1, hilt_bar); sbar_length, title_lines, win[TOD].h - 1, hilt_bar);
} }
wnoutrefresh (win[TOD].p); wnoutrefresh(win[TOD].p);
} }
/* Attach a note to a todo */ /* Attach a note to a todo */
void void todo_edit_note(const char *editor)
todo_edit_note (const char *editor)
{ {
struct todo *i = todo_get_item (hilt); struct todo *i = todo_get_item(hilt);
edit_note (&i->note, editor); edit_note(&i->note, editor);
} }
/* View a note previously attached to a todo */ /* View a note previously attached to a todo */
void void todo_view_note(const char *pager)
todo_view_note (const char *pager)
{ {
struct todo *i = todo_get_item (hilt); struct todo *i = todo_get_item(hilt);
view_note (i->note, pager); view_note(i->note, pager);
} }
/* Pipe a todo item to an external program. */ /* Pipe a todo item to an external program. */
void void todo_pipe_item(void)
todo_pipe_item (void)
{ {
char cmd[BUFSIZ] = ""; char cmd[BUFSIZ] = "";
char const *arg[] = { cmd, NULL }; char const *arg[] = { cmd, NULL };
@ -475,42 +436,38 @@ todo_pipe_item (void)
FILE *fpout; FILE *fpout;
struct todo *todo; struct todo *todo;
status_mesg (_("Pipe item to external command:"), ""); status_mesg(_("Pipe item to external command:"), "");
if (getstring (win[STA].p, cmd, BUFSIZ, 0, 1) != GETSTRING_VALID) if (getstring(win[STA].p, cmd, BUFSIZ, 0, 1) != GETSTRING_VALID)
return; return;
wins_prepare_external (); wins_prepare_external();
if ((pid = shell_exec (NULL, &pout, *arg, arg))) if ((pid = shell_exec(NULL, &pout, *arg, arg))) {
{ fpout = fdopen(pout, "w");
fpout = fdopen (pout, "w");
todo = todo_get_item (hilt); todo = todo_get_item(hilt);
todo_write (todo, fpout); todo_write(todo, fpout);
fclose (fpout); fclose(fpout);
child_wait (NULL, &pout, pid); child_wait(NULL, &pout, pid);
press_any_key (); press_any_key();
} }
wins_unprepare_external (); wins_unprepare_external();
} }
static void static void todo_free(struct todo *todo)
todo_free (struct todo *todo)
{ {
mem_free (todo->mesg); mem_free(todo->mesg);
erase_note (&todo->note); erase_note(&todo->note);
mem_free (todo); mem_free(todo);
} }
void void todo_init_list(void)
todo_init_list (void)
{ {
LLIST_INIT (&todolist); LLIST_INIT(&todolist);
} }
void void todo_free_list(void)
todo_free_list (void)
{ {
LLIST_FREE_INNER (&todolist, todo_free); LLIST_FREE_INNER(&todolist, todo_free);
LLIST_FREE (&todolist); LLIST_FREE(&todolist);
} }

545
src/utf8.c
View File

@ -41,304 +41,295 @@ struct utf8_range {
}; };
static const struct utf8_range utf8_widthtab[] = { static const struct utf8_range utf8_widthtab[] = {
{ 0x00300, 0x0036f, 0 }, {0x00300, 0x0036f, 0},
{ 0x00483, 0x00489, 0 }, {0x00483, 0x00489, 0},
{ 0x00591, 0x005bd, 0 }, {0x00591, 0x005bd, 0},
{ 0x005bf, 0x005bf, 0 }, {0x005bf, 0x005bf, 0},
{ 0x005c1, 0x005c2, 0 }, {0x005c1, 0x005c2, 0},
{ 0x005c4, 0x005c5, 0 }, {0x005c4, 0x005c5, 0},
{ 0x005c7, 0x005c7, 0 }, {0x005c7, 0x005c7, 0},
{ 0x00610, 0x0061a, 0 }, {0x00610, 0x0061a, 0},
{ 0x0064b, 0x0065e, 0 }, {0x0064b, 0x0065e, 0},
{ 0x00670, 0x00670, 0 }, {0x00670, 0x00670, 0},
{ 0x006d6, 0x006dc, 0 }, {0x006d6, 0x006dc, 0},
{ 0x006de, 0x006e4, 0 }, {0x006de, 0x006e4, 0},
{ 0x006e7, 0x006e8, 0 }, {0x006e7, 0x006e8, 0},
{ 0x006ea, 0x006ed, 0 }, {0x006ea, 0x006ed, 0},
{ 0x00711, 0x00711, 0 }, {0x00711, 0x00711, 0},
{ 0x00730, 0x0074a, 0 }, {0x00730, 0x0074a, 0},
{ 0x007a6, 0x007b0, 0 }, {0x007a6, 0x007b0, 0},
{ 0x007eb, 0x007f3, 0 }, {0x007eb, 0x007f3, 0},
{ 0x00816, 0x00819, 0 }, {0x00816, 0x00819, 0},
{ 0x0081b, 0x00823, 0 }, {0x0081b, 0x00823, 0},
{ 0x00825, 0x00827, 0 }, {0x00825, 0x00827, 0},
{ 0x00829, 0x0082d, 0 }, {0x00829, 0x0082d, 0},
{ 0x00900, 0x00903, 0 }, {0x00900, 0x00903, 0},
{ 0x0093c, 0x0093c, 0 }, {0x0093c, 0x0093c, 0},
{ 0x0093e, 0x0094e, 0 }, {0x0093e, 0x0094e, 0},
{ 0x00951, 0x00955, 0 }, {0x00951, 0x00955, 0},
{ 0x00962, 0x00963, 0 }, {0x00962, 0x00963, 0},
{ 0x00981, 0x00983, 0 }, {0x00981, 0x00983, 0},
{ 0x009bc, 0x009bc, 0 }, {0x009bc, 0x009bc, 0},
{ 0x009be, 0x009c4, 0 }, {0x009be, 0x009c4, 0},
{ 0x009c7, 0x009c8, 0 }, {0x009c7, 0x009c8, 0},
{ 0x009cb, 0x009cd, 0 }, {0x009cb, 0x009cd, 0},
{ 0x009d7, 0x009d7, 0 }, {0x009d7, 0x009d7, 0},
{ 0x009e2, 0x009e3, 0 }, {0x009e2, 0x009e3, 0},
{ 0x00a01, 0x00a03, 0 }, {0x00a01, 0x00a03, 0},
{ 0x00a3c, 0x00a3c, 0 }, {0x00a3c, 0x00a3c, 0},
{ 0x00a3e, 0x00a42, 0 }, {0x00a3e, 0x00a42, 0},
{ 0x00a47, 0x00a48, 0 }, {0x00a47, 0x00a48, 0},
{ 0x00a4b, 0x00a4d, 0 }, {0x00a4b, 0x00a4d, 0},
{ 0x00a51, 0x00a51, 0 }, {0x00a51, 0x00a51, 0},
{ 0x00a70, 0x00a71, 0 }, {0x00a70, 0x00a71, 0},
{ 0x00a75, 0x00a75, 0 }, {0x00a75, 0x00a75, 0},
{ 0x00a81, 0x00a83, 0 }, {0x00a81, 0x00a83, 0},
{ 0x00abc, 0x00abc, 0 }, {0x00abc, 0x00abc, 0},
{ 0x00abe, 0x00ac5, 0 }, {0x00abe, 0x00ac5, 0},
{ 0x00ac7, 0x00ac9, 0 }, {0x00ac7, 0x00ac9, 0},
{ 0x00acb, 0x00acd, 0 }, {0x00acb, 0x00acd, 0},
{ 0x00ae2, 0x00ae3, 0 }, {0x00ae2, 0x00ae3, 0},
{ 0x00b01, 0x00b03, 0 }, {0x00b01, 0x00b03, 0},
{ 0x00b3c, 0x00b3c, 0 }, {0x00b3c, 0x00b3c, 0},
{ 0x00b3e, 0x00b44, 0 }, {0x00b3e, 0x00b44, 0},
{ 0x00b47, 0x00b48, 0 }, {0x00b47, 0x00b48, 0},
{ 0x00b4b, 0x00b4d, 0 }, {0x00b4b, 0x00b4d, 0},
{ 0x00b56, 0x00b57, 0 }, {0x00b56, 0x00b57, 0},
{ 0x00b62, 0x00b63, 0 }, {0x00b62, 0x00b63, 0},
{ 0x00b82, 0x00b82, 0 }, {0x00b82, 0x00b82, 0},
{ 0x00bbe, 0x00bc2, 0 }, {0x00bbe, 0x00bc2, 0},
{ 0x00bc6, 0x00bc8, 0 }, {0x00bc6, 0x00bc8, 0},
{ 0x00bca, 0x00bcd, 0 }, {0x00bca, 0x00bcd, 0},
{ 0x00bd7, 0x00bd7, 0 }, {0x00bd7, 0x00bd7, 0},
{ 0x00c01, 0x00c03, 0 }, {0x00c01, 0x00c03, 0},
{ 0x00c3e, 0x00c44, 0 }, {0x00c3e, 0x00c44, 0},
{ 0x00c46, 0x00c48, 0 }, {0x00c46, 0x00c48, 0},
{ 0x00c4a, 0x00c4d, 0 }, {0x00c4a, 0x00c4d, 0},
{ 0x00c55, 0x00c56, 0 }, {0x00c55, 0x00c56, 0},
{ 0x00c62, 0x00c63, 0 }, {0x00c62, 0x00c63, 0},
{ 0x00c82, 0x00c83, 0 }, {0x00c82, 0x00c83, 0},
{ 0x00cbc, 0x00cbc, 0 }, {0x00cbc, 0x00cbc, 0},
{ 0x00cbe, 0x00cc4, 0 }, {0x00cbe, 0x00cc4, 0},
{ 0x00cc6, 0x00cc8, 0 }, {0x00cc6, 0x00cc8, 0},
{ 0x00cca, 0x00ccd, 0 }, {0x00cca, 0x00ccd, 0},
{ 0x00cd5, 0x00cd6, 0 }, {0x00cd5, 0x00cd6, 0},
{ 0x00ce2, 0x00ce3, 0 }, {0x00ce2, 0x00ce3, 0},
{ 0x00d02, 0x00d03, 0 }, {0x00d02, 0x00d03, 0},
{ 0x00d3e, 0x00d44, 0 }, {0x00d3e, 0x00d44, 0},
{ 0x00d46, 0x00d48, 0 }, {0x00d46, 0x00d48, 0},
{ 0x00d4a, 0x00d4d, 0 }, {0x00d4a, 0x00d4d, 0},
{ 0x00d57, 0x00d57, 0 }, {0x00d57, 0x00d57, 0},
{ 0x00d62, 0x00d63, 0 }, {0x00d62, 0x00d63, 0},
{ 0x00d82, 0x00d83, 0 }, {0x00d82, 0x00d83, 0},
{ 0x00dca, 0x00dca, 0 }, {0x00dca, 0x00dca, 0},
{ 0x00dcf, 0x00dd4, 0 }, {0x00dcf, 0x00dd4, 0},
{ 0x00dd6, 0x00dd6, 0 }, {0x00dd6, 0x00dd6, 0},
{ 0x00dd8, 0x00ddf, 0 }, {0x00dd8, 0x00ddf, 0},
{ 0x00df2, 0x00df3, 0 }, {0x00df2, 0x00df3, 0},
{ 0x00e31, 0x00e31, 0 }, {0x00e31, 0x00e31, 0},
{ 0x00e34, 0x00e3a, 0 }, {0x00e34, 0x00e3a, 0},
{ 0x00e47, 0x00e4e, 0 }, {0x00e47, 0x00e4e, 0},
{ 0x00eb1, 0x00eb1, 0 }, {0x00eb1, 0x00eb1, 0},
{ 0x00eb4, 0x00eb9, 0 }, {0x00eb4, 0x00eb9, 0},
{ 0x00ebb, 0x00ebc, 0 }, {0x00ebb, 0x00ebc, 0},
{ 0x00ec8, 0x00ecd, 0 }, {0x00ec8, 0x00ecd, 0},
{ 0x00f18, 0x00f19, 0 }, {0x00f18, 0x00f19, 0},
{ 0x00f35, 0x00f35, 0 }, {0x00f35, 0x00f35, 0},
{ 0x00f37, 0x00f37, 0 }, {0x00f37, 0x00f37, 0},
{ 0x00f39, 0x00f39, 0 }, {0x00f39, 0x00f39, 0},
{ 0x00f3e, 0x00f3f, 0 }, {0x00f3e, 0x00f3f, 0},
{ 0x00f71, 0x00f84, 0 }, {0x00f71, 0x00f84, 0},
{ 0x00f86, 0x00f87, 0 }, {0x00f86, 0x00f87, 0},
{ 0x00f90, 0x00f97, 0 }, {0x00f90, 0x00f97, 0},
{ 0x00f99, 0x00fbc, 0 }, {0x00f99, 0x00fbc, 0},
{ 0x00fc6, 0x00fc6, 0 }, {0x00fc6, 0x00fc6, 0},
{ 0x0102b, 0x0103e, 0 }, {0x0102b, 0x0103e, 0},
{ 0x01056, 0x01059, 0 }, {0x01056, 0x01059, 0},
{ 0x0105e, 0x01060, 0 }, {0x0105e, 0x01060, 0},
{ 0x01062, 0x01064, 0 }, {0x01062, 0x01064, 0},
{ 0x01067, 0x0106d, 0 }, {0x01067, 0x0106d, 0},
{ 0x01071, 0x01074, 0 }, {0x01071, 0x01074, 0},
{ 0x01082, 0x0108d, 0 }, {0x01082, 0x0108d, 0},
{ 0x0108f, 0x0108f, 0 }, {0x0108f, 0x0108f, 0},
{ 0x0109a, 0x0109d, 0 }, {0x0109a, 0x0109d, 0},
{ 0x01100, 0x0115f, 2 }, {0x01100, 0x0115f, 2},
{ 0x011a3, 0x011a7, 2 }, {0x011a3, 0x011a7, 2},
{ 0x011fa, 0x011ff, 2 }, {0x011fa, 0x011ff, 2},
{ 0x0135f, 0x0135f, 0 }, {0x0135f, 0x0135f, 0},
{ 0x01712, 0x01714, 0 }, {0x01712, 0x01714, 0},
{ 0x01732, 0x01734, 0 }, {0x01732, 0x01734, 0},
{ 0x01752, 0x01753, 0 }, {0x01752, 0x01753, 0},
{ 0x01772, 0x01773, 0 }, {0x01772, 0x01773, 0},
{ 0x017b6, 0x017d3, 0 }, {0x017b6, 0x017d3, 0},
{ 0x017dd, 0x017dd, 0 }, {0x017dd, 0x017dd, 0},
{ 0x0180b, 0x0180d, 0 }, {0x0180b, 0x0180d, 0},
{ 0x018a9, 0x018a9, 0 }, {0x018a9, 0x018a9, 0},
{ 0x01920, 0x0192b, 0 }, {0x01920, 0x0192b, 0},
{ 0x01930, 0x0193b, 0 }, {0x01930, 0x0193b, 0},
{ 0x019b0, 0x019c0, 0 }, {0x019b0, 0x019c0, 0},
{ 0x019c8, 0x019c9, 0 }, {0x019c8, 0x019c9, 0},
{ 0x01a17, 0x01a1b, 0 }, {0x01a17, 0x01a1b, 0},
{ 0x01a55, 0x01a5e, 0 }, {0x01a55, 0x01a5e, 0},
{ 0x01a60, 0x01a7c, 0 }, {0x01a60, 0x01a7c, 0},
{ 0x01a7f, 0x01a7f, 0 }, {0x01a7f, 0x01a7f, 0},
{ 0x01b00, 0x01b04, 0 }, {0x01b00, 0x01b04, 0},
{ 0x01b34, 0x01b44, 0 }, {0x01b34, 0x01b44, 0},
{ 0x01b6b, 0x01b73, 0 }, {0x01b6b, 0x01b73, 0},
{ 0x01b80, 0x01b82, 0 }, {0x01b80, 0x01b82, 0},
{ 0x01ba1, 0x01baa, 0 }, {0x01ba1, 0x01baa, 0},
{ 0x01c24, 0x01c37, 0 }, {0x01c24, 0x01c37, 0},
{ 0x01cd0, 0x01cd2, 0 }, {0x01cd0, 0x01cd2, 0},
{ 0x01cd4, 0x01ce8, 0 }, {0x01cd4, 0x01ce8, 0},
{ 0x01ced, 0x01ced, 0 }, {0x01ced, 0x01ced, 0},
{ 0x01cf2, 0x01cf2, 0 }, {0x01cf2, 0x01cf2, 0},
{ 0x01dc0, 0x01de6, 0 }, {0x01dc0, 0x01de6, 0},
{ 0x01dfd, 0x01dff, 0 }, {0x01dfd, 0x01dff, 0},
{ 0x020d0, 0x020f0, 0 }, {0x020d0, 0x020f0, 0},
{ 0x02329, 0x0232a, 2 }, {0x02329, 0x0232a, 2},
{ 0x02cef, 0x02cf1, 0 }, {0x02cef, 0x02cf1, 0},
{ 0x02de0, 0x02dff, 0 }, {0x02de0, 0x02dff, 0},
{ 0x02e80, 0x02e99, 2 }, {0x02e80, 0x02e99, 2},
{ 0x02e9b, 0x02ef3, 2 }, {0x02e9b, 0x02ef3, 2},
{ 0x02f00, 0x02fd5, 2 }, {0x02f00, 0x02fd5, 2},
{ 0x02ff0, 0x02ffb, 2 }, {0x02ff0, 0x02ffb, 2},
{ 0x03000, 0x03029, 2 }, {0x03000, 0x03029, 2},
{ 0x0302a, 0x0302f, 0 }, {0x0302a, 0x0302f, 0},
{ 0x03030, 0x0303e, 2 }, {0x03030, 0x0303e, 2},
{ 0x03041, 0x03096, 2 }, {0x03041, 0x03096, 2},
{ 0x03099, 0x0309a, 0 }, {0x03099, 0x0309a, 0},
{ 0x0309b, 0x030ff, 2 }, {0x0309b, 0x030ff, 2},
{ 0x03105, 0x0312d, 2 }, {0x03105, 0x0312d, 2},
{ 0x03131, 0x0318e, 2 }, {0x03131, 0x0318e, 2},
{ 0x03190, 0x031b7, 2 }, {0x03190, 0x031b7, 2},
{ 0x031c0, 0x031e3, 2 }, {0x031c0, 0x031e3, 2},
{ 0x031f0, 0x0321e, 2 }, {0x031f0, 0x0321e, 2},
{ 0x03220, 0x03247, 2 }, {0x03220, 0x03247, 2},
{ 0x03250, 0x032fe, 2 }, {0x03250, 0x032fe, 2},
{ 0x03300, 0x04dbf, 2 }, {0x03300, 0x04dbf, 2},
{ 0x04e00, 0x0a48c, 2 }, {0x04e00, 0x0a48c, 2},
{ 0x0a490, 0x0a4c6, 2 }, {0x0a490, 0x0a4c6, 2},
{ 0x0a66f, 0x0a672, 0 }, {0x0a66f, 0x0a672, 0},
{ 0x0a67c, 0x0a67d, 0 }, {0x0a67c, 0x0a67d, 0},
{ 0x0a6f0, 0x0a6f1, 0 }, {0x0a6f0, 0x0a6f1, 0},
{ 0x0a802, 0x0a802, 0 }, {0x0a802, 0x0a802, 0},
{ 0x0a806, 0x0a806, 0 }, {0x0a806, 0x0a806, 0},
{ 0x0a80b, 0x0a80b, 0 }, {0x0a80b, 0x0a80b, 0},
{ 0x0a823, 0x0a827, 0 }, {0x0a823, 0x0a827, 0},
{ 0x0a880, 0x0a881, 0 }, {0x0a880, 0x0a881, 0},
{ 0x0a8b4, 0x0a8c4, 0 }, {0x0a8b4, 0x0a8c4, 0},
{ 0x0a8e0, 0x0a8f1, 0 }, {0x0a8e0, 0x0a8f1, 0},
{ 0x0a926, 0x0a92d, 0 }, {0x0a926, 0x0a92d, 0},
{ 0x0a947, 0x0a953, 0 }, {0x0a947, 0x0a953, 0},
{ 0x0a960, 0x0a97c, 2 }, {0x0a960, 0x0a97c, 2},
{ 0x0a980, 0x0a983, 0 }, {0x0a980, 0x0a983, 0},
{ 0x0a9b3, 0x0a9c0, 0 }, {0x0a9b3, 0x0a9c0, 0},
{ 0x0aa29, 0x0aa36, 0 }, {0x0aa29, 0x0aa36, 0},
{ 0x0aa43, 0x0aa43, 0 }, {0x0aa43, 0x0aa43, 0},
{ 0x0aa4c, 0x0aa4d, 0 }, {0x0aa4c, 0x0aa4d, 0},
{ 0x0aa7b, 0x0aa7b, 0 }, {0x0aa7b, 0x0aa7b, 0},
{ 0x0aab0, 0x0aab0, 0 }, {0x0aab0, 0x0aab0, 0},
{ 0x0aab2, 0x0aab4, 0 }, {0x0aab2, 0x0aab4, 0},
{ 0x0aab7, 0x0aab8, 0 }, {0x0aab7, 0x0aab8, 0},
{ 0x0aabe, 0x0aabf, 0 }, {0x0aabe, 0x0aabf, 0},
{ 0x0aac1, 0x0aac1, 0 }, {0x0aac1, 0x0aac1, 0},
{ 0x0abe3, 0x0abea, 0 }, {0x0abe3, 0x0abea, 0},
{ 0x0abec, 0x0abed, 0 }, {0x0abec, 0x0abed, 0},
{ 0x0ac00, 0x0d7a3, 2 }, {0x0ac00, 0x0d7a3, 2},
{ 0x0d7b0, 0x0d7c6, 2 }, {0x0d7b0, 0x0d7c6, 2},
{ 0x0d7cb, 0x0d7fb, 2 }, {0x0d7cb, 0x0d7fb, 2},
{ 0x0f900, 0x0faff, 2 }, {0x0f900, 0x0faff, 2},
{ 0x0fb1e, 0x0fb1e, 0 }, {0x0fb1e, 0x0fb1e, 0},
{ 0x0fe00, 0x0fe0f, 0 }, {0x0fe00, 0x0fe0f, 0},
{ 0x0fe10, 0x0fe19, 2 }, {0x0fe10, 0x0fe19, 2},
{ 0x0fe20, 0x0fe26, 0 }, {0x0fe20, 0x0fe26, 0},
{ 0x0fe30, 0x0fe52, 2 }, {0x0fe30, 0x0fe52, 2},
{ 0x0fe54, 0x0fe66, 2 }, {0x0fe54, 0x0fe66, 2},
{ 0x0fe68, 0x0fe6b, 2 }, {0x0fe68, 0x0fe6b, 2},
{ 0x0ff01, 0x0ff60, 2 }, {0x0ff01, 0x0ff60, 2},
{ 0x0ffe0, 0x0ffe6, 2 }, {0x0ffe0, 0x0ffe6, 2},
{ 0x101fd, 0x101fd, 0 }, {0x101fd, 0x101fd, 0},
{ 0x10a01, 0x10a03, 0 }, {0x10a01, 0x10a03, 0},
{ 0x10a05, 0x10a06, 0 }, {0x10a05, 0x10a06, 0},
{ 0x10a0c, 0x10a0f, 0 }, {0x10a0c, 0x10a0f, 0},
{ 0x10a38, 0x10a3a, 0 }, {0x10a38, 0x10a3a, 0},
{ 0x10a3f, 0x10a3f, 0 }, {0x10a3f, 0x10a3f, 0},
{ 0x11080, 0x11082, 0 }, {0x11080, 0x11082, 0},
{ 0x110b0, 0x110ba, 0 }, {0x110b0, 0x110ba, 0},
{ 0x1d165, 0x1d169, 0 }, {0x1d165, 0x1d169, 0},
{ 0x1d16d, 0x1d172, 0 }, {0x1d16d, 0x1d172, 0},
{ 0x1d17b, 0x1d182, 0 }, {0x1d17b, 0x1d182, 0},
{ 0x1d185, 0x1d18b, 0 }, {0x1d185, 0x1d18b, 0},
{ 0x1d1aa, 0x1d1ad, 0 }, {0x1d1aa, 0x1d1ad, 0},
{ 0x1d242, 0x1d244, 0 }, {0x1d242, 0x1d244, 0},
{ 0x1f200, 0x1f200, 2 }, {0x1f200, 0x1f200, 2},
{ 0x1f210, 0x1f231, 2 }, {0x1f210, 0x1f231, 2},
{ 0x1f240, 0x1f248, 2 }, {0x1f240, 0x1f248, 2},
{ 0x20000, 0x2fffd, 2 }, {0x20000, 0x2fffd, 2},
{ 0x30000, 0x3fffd, 2 }, {0x30000, 0x3fffd, 2},
{ 0xe0100, 0xe01ef, 0 } {0xe0100, 0xe01ef, 0}
}; };
/* Get the width of a UTF-8 character. */ /* Get the width of a UTF-8 character. */
int int utf8_width(char *s)
utf8_width (char *s)
{ {
int val, low, high, cur; int val, low, high, cur;
if (UTF8_ISCONT (*s)) if (UTF8_ISCONT(*s))
return 0; return 0;
switch (UTF8_LENGTH (*s)) switch (UTF8_LENGTH(*s)) {
{ case 1:
case 1: val = s[0];
val = s[0]; break;
break; case 2:
case 2: val = (s[1] & 0x3f) | (s[0] & 0x1f) << 6;
val = (s[1] & 0x3f) | (s[0] & 0x1f) << 6; break;
break; case 3:
case 3: val = ((s[2] & 0x3f) | (s[1] & 0x3f) << 6) | (s[0] & 0x0f) << 12;
val = ((s[2] & 0x3f) | (s[1] & 0x3f) << 6) | break;
(s[0] & 0x0f) << 12; case 4:
break; val = (((s[3] & 0x3f) | (s[2] & 0x3f) << 6) |
case 4: (s[1] & 0x3f) << 12) | (s[0] & 0x3f) << 18;
val = (((s[3] & 0x3f) | (s[2] & 0x3f) << 6) | break;
(s[1] & 0x3f) << 12) | (s[0] & 0x3f) << 18; case 5:
break; val = ((((s[4] & 0x3f) | (s[3] & 0x3f) << 6) |
case 5: (s[2] & 0x3f) << 12) | (s[1] & 0x3f) << 18) | (s[0] & 0x3f) << 24;
val = ((((s[4] & 0x3f) | (s[3] & 0x3f) << 6) | break;
(s[2] & 0x3f) << 12) | (s[1] & 0x3f) << 18) | case 6:
(s[0] & 0x3f) << 24; val = (((((s[5] & 0x3f) | (s[4] & 0x3f) << 6) |
break; (s[3] & 0x3f) << 12) | (s[2] & 0x3f) << 18) |
case 6: (s[1] & 0x3f) << 24) | (s[0] & 0x3f) << 30;
val = (((((s[5] & 0x3f) | (s[4] & 0x3f) << 6) | break;
(s[3] & 0x3f) << 12) | (s[2] & 0x3f) << 18) | default:
(s[1] & 0x3f) << 24) | (s[0] & 0x3f) << 30; return 0;
break; }
default:
return 0;
}
low = 0; low = 0;
high = sizeof(utf8_widthtab) / sizeof(utf8_widthtab[0]); high = sizeof(utf8_widthtab) / sizeof(utf8_widthtab[0]);
do do {
{ cur = (low + high) / 2;
cur = (low + high) / 2; if (val >= utf8_widthtab[cur].min) {
if (val >= utf8_widthtab[cur].min) if (val <= utf8_widthtab[cur].max)
{ return utf8_widthtab[cur].width;
if (val <= utf8_widthtab[cur].max)
return utf8_widthtab[cur].width;
else
low = cur + 1;
}
else else
high = cur - 1; low = cur + 1;
} } else
high = cur - 1;
}
while (low <= high); while (low <= high);
return 1; return 1;
} }
/* Get the width of a UTF-8 string. */ /* Get the width of a UTF-8 string. */
int int utf8_strwidth(char *s)
utf8_strwidth (char *s)
{ {
int width = 0; int width = 0;
for (; s && *s; s++) for (; s && *s; s++) {
{ if (!UTF8_ISCONT(*s))
if (!UTF8_ISCONT (*s)) width += utf8_width(s);
width += utf8_width (s); }
}
return width; return width;
} }

1442
src/utils.c
View File

File diff suppressed because it is too large Load Diff

20
src/vars.c
View File

@ -65,6 +65,7 @@ int read_only = 0;
* variables to store calendar names * variables to store calendar names
*/ */
int days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; int days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
const char *monthnames[12] = { const char *monthnames[12] = {
N_("January"), N_("January"),
N_("February"), N_("February"),
@ -120,8 +121,7 @@ struct dmon_conf dmon;
/* /*
* Variables init * Variables init
*/ */
void void vars_init(void)
vars_init (void)
{ {
const char *ed, *pg; const char *ed, *pg;
@ -133,33 +133,33 @@ vars_init (void)
conf.periodic_save = 0; conf.periodic_save = 0;
conf.system_dialogs = 1; conf.system_dialogs = 1;
conf.progress_bar = 1; conf.progress_bar = 1;
strncpy (conf.output_datefmt, "%D", 3); strncpy(conf.output_datefmt, "%D", 3);
conf.input_datefmt = 1; conf.input_datefmt = 1;
/* Default external editor and pager */ /* Default external editor and pager */
ed = getenv ("VISUAL"); ed = getenv("VISUAL");
if (ed == NULL || ed[0] == '\0') if (ed == NULL || ed[0] == '\0')
ed = getenv ("EDITOR"); ed = getenv("EDITOR");
if (ed == NULL || ed[0] == '\0') if (ed == NULL || ed[0] == '\0')
ed = DEFAULT_EDITOR; ed = DEFAULT_EDITOR;
conf.editor = ed; conf.editor = ed;
pg = getenv ("PAGER"); pg = getenv("PAGER");
if (pg == NULL || pg[0] == '\0') if (pg == NULL || pg[0] == '\0')
pg = DEFAULT_PAGER; pg = DEFAULT_PAGER;
conf.pager = pg; conf.pager = pg;
wins_set_layout (1); wins_set_layout(1);
calendar_set_first_day_of_week (MONDAY); calendar_set_first_day_of_week(MONDAY);
/* Pad structure to scroll text inside the appointment panel */ /* Pad structure to scroll text inside the appointment panel */
apad.length = 1; apad.length = 1;
apad.first_onscreen = 0; apad.first_onscreen = 0;
/* Attribute definitions for color and non-color terminals */ /* Attribute definitions for color and non-color terminals */
custom_init_attr (); custom_init_attr();
/* Start at the current date */ /* Start at the current date */
calendar_init_slctd_day (); calendar_init_slctd_day();
} }

769
src/wins.c
View File

File diff suppressed because it is too large Load Diff

213
test/run-test.c
View File

@ -50,108 +50,94 @@
* appropriate file descriptors are written to pfdin/pfdout. * appropriate file descriptors are written to pfdin/pfdout.
*/ */
static int static int
fork_exec (int *pfdin, int *pfdout, const char *path, char *const *arg) fork_exec(int *pfdin, int *pfdout, const char *path, char *const *arg)
{ {
int pin[2], pout[2]; int pin[2], pout[2];
int pid; int pid;
if (pfdin && (pipe (pin) == -1)) if (pfdin && (pipe(pin) == -1))
return 0; return 0;
if (pfdout && (pipe (pout) == -1)) if (pfdout && (pipe(pout) == -1))
return 0; return 0;
if ((pid = fork ()) == 0) if ((pid = fork()) == 0) {
{ if (pfdout) {
if (pfdout) if (dup2(pout[0], STDIN_FILENO) < 0)
{ _exit(127);
if (dup2 (pout[0], STDIN_FILENO) < 0) close(pout[0]);
_exit (127); close(pout[1]);
close (pout[0]);
close (pout[1]);
}
if (pfdin)
{
if (dup2 (pin[1], STDOUT_FILENO) < 0)
_exit (127);
close (pin[0]);
close (pin[1]);
}
execvp (path, arg);
_exit (127);
} }
else
{
if (pfdin)
close (pin[1]);
if (pfdout)
close (pout[0]);
if (pid > 0) if (pfdin) {
{ if (dup2(pin[1], STDOUT_FILENO) < 0)
if (pfdin) _exit(127);
{ close(pin[0]);
fcntl (pin[0], F_SETFD, FD_CLOEXEC); close(pin[1]);
*pfdin = pin[0];
}
if (pfdout)
{
fcntl (pout[1], F_SETFD, FD_CLOEXEC);
*pfdout = pout[1];
}
}
else
{
if (pfdin)
close (pin[0]);
if (pfdout)
close (pout[1]);
return 0;
}
} }
execvp(path, arg);
_exit(127);
} else {
if (pfdin)
close(pin[1]);
if (pfdout)
close(pout[0]);
if (pid > 0) {
if (pfdin) {
fcntl(pin[0], F_SETFD, FD_CLOEXEC);
*pfdin = pin[0];
}
if (pfdout) {
fcntl(pout[1], F_SETFD, FD_CLOEXEC);
*pfdout = pout[1];
}
} else {
if (pfdin)
close(pin[0]);
if (pfdout)
close(pout[1]);
return 0;
}
}
return pid; return pid;
} }
/* Wait for a child process to terminate. */ /* Wait for a child process to terminate. */
static int static int child_wait(int *pfdin, int *pfdout, int pid)
child_wait (int *pfdin, int *pfdout, int pid)
{ {
int stat; int stat;
if (pfdin) if (pfdin)
close (*pfdin); close(*pfdin);
if (pfdout) if (pfdout)
close (*pfdout); close(*pfdout);
waitpid (pid, &stat, 0); waitpid(pid, &stat, 0);
return stat; return stat;
} }
/* Print error message and bail out. */ /* Print error message and bail out. */
static void static void die(const char *format, ...)
die (const char *format, ...)
{ {
va_list arg; va_list arg;
va_start (arg, format); va_start(arg, format);
fprintf (stderr, "error: "); fprintf(stderr, "error: ");
vfprintf (stderr, format, arg); vfprintf(stderr, format, arg);
va_end (arg); va_end(arg);
exit (1); exit(1);
} }
/* Print usage message. */ /* Print usage message. */
static void static void usage(void)
usage (void)
{ {
printf ("usage: run-test [-h|--help] <test>...\n"); printf("usage: run-test [-h|--help] <test>...\n");
} }
/* Run test with a specific name. */ /* Run test with a specific name. */
static int static int run_test(const char *name, int expect_failure)
run_test (const char *name, int expect_failure)
{ {
char filename[BUFSIZ]; char filename[BUFSIZ];
char *arg1[3], *arg2[3]; char *arg1[3], *arg2[3];
@ -160,93 +146,84 @@ run_test (const char *name, int expect_failure)
char buf1[BUFSIZ], buf2[BUFSIZ]; char buf1[BUFSIZ], buf2[BUFSIZ];
int ret = 1; int ret = 1;
if (snprintf (filename, BUFSIZ, "./%s", name) >= BUFSIZ) if (snprintf(filename, BUFSIZ, "./%s", name) >= BUFSIZ)
die ("file name too long\n"); die("file name too long\n");
if (access (filename, F_OK) != 0) if (access(filename, F_OK) != 0) {
{ if (snprintf(filename, BUFSIZ, "./%s.sh", name) >= BUFSIZ)
if (snprintf (filename, BUFSIZ, "./%s.sh", name) >= BUFSIZ) die("file name too long\n");
die ("file name too long\n");
if (access (filename, F_OK) != 0) if (access(filename, F_OK) != 0)
die ("test not found: %s\n", name); die("test not found: %s\n", name);
} }
if (access (filename, X_OK) != 0) if (access(filename, X_OK) != 0)
die ("script is not executable: %s\n", filename); die("script is not executable: %s\n", filename);
arg1[0] = arg2[0] = filename; arg1[0] = arg2[0] = filename;
arg1[1] = "expected"; arg1[1] = "expected";
arg2[1] = "actual"; arg2[1] = "actual";
arg1[2] = arg2[2] = NULL; arg1[2] = arg2[2] = NULL;
printf ("Running %s...", name); printf("Running %s...", name);
if ((pid1 = fork_exec (&pin1, NULL, *arg1, arg1)) < 0) if ((pid1 = fork_exec(&pin1, NULL, *arg1, arg1)) < 0)
die("failed to execute %s: %s\n", filename, strerror (errno)); die("failed to execute %s: %s\n", filename, strerror(errno));
if ((pid2 = fork_exec (&pin2, NULL, *arg2, arg2)) < 0) if ((pid2 = fork_exec(&pin2, NULL, *arg2, arg2)) < 0)
die("failed to execute %s: %s\n", filename, strerror (errno)); die("failed to execute %s: %s\n", filename, strerror(errno));
fpin1 = fdopen (pin1, "r"); fpin1 = fdopen(pin1, "r");
fpin2 = fdopen (pin2, "r"); fpin2 = fdopen(pin2, "r");
while (fgets (buf1, BUFSIZ, fpin1)) while (fgets(buf1, BUFSIZ, fpin1)) {
{ if (!fgets(buf2, BUFSIZ, fpin2) || strcmp(buf1, buf2) != 0) {
if (!fgets (buf2, BUFSIZ, fpin2) || strcmp (buf1, buf2) != 0) ret = 0;
{ break;
ret = 0;
break;
}
} }
}
if (fpin1) if (fpin1)
fclose (fpin1); fclose(fpin1);
if (fpin2) if (fpin2)
fclose (fpin2); fclose(fpin2);
if (child_wait (&pin1, NULL, pid1) != 0) if (child_wait(&pin1, NULL, pid1) != 0)
ret = 0; ret = 0;
if (child_wait (&pin2, NULL, pid2) != 0) if (child_wait(&pin2, NULL, pid2) != 0)
ret = 0; ret = 0;
if (expect_failure) if (expect_failure)
ret = 1 - ret; ret = 1 - ret;
if (ret == 1) if (ret == 1)
printf (" ok\n"); printf(" ok\n");
else else
printf (" FAIL\n"); printf(" FAIL\n");
return ret; return ret;
} }
int int main(int argc, char **argv)
main (int argc, char **argv)
{ {
int i; int i;
if (!argv[1]) if (!argv[1])
die ("no tests specified, bailing out\n"); die("no tests specified, bailing out\n");
else if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) else if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
{ usage();
usage(); return 0;
return 0; }
}
for (i = 1; i < argc; i++) for (i = 1; i < argc; i++) {
{ if (*argv[i] == '!') {
if (*argv[i] == '!') if (!run_test(argv[i] + 1, 1))
{ return 1;
if (!run_test (argv[i] + 1, 1)) } else {
return 1; if (!run_test(argv[i], 0))
} return 1;
else
{
if (!run_test (argv[i], 0))
return 1;
}
} }
}
return 0; return 0;
} }