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"
llist_ts_t alist_p;
static struct apoint bkp_cut_apoint;
static int hilt;
llist_ts_t alist_p;
static struct apoint bkp_cut_apoint;
static int hilt;
void
apoint_free_bkp (void)
void apoint_free_bkp(void)
{
if (bkp_cut_apoint.mesg)
{
mem_free (bkp_cut_apoint.mesg);
bkp_cut_apoint.mesg = 0;
}
erase_note (&bkp_cut_apoint.note);
if (bkp_cut_apoint.mesg) {
mem_free(bkp_cut_apoint.mesg);
bkp_cut_apoint.mesg = 0;
}
erase_note(&bkp_cut_apoint.note);
}
static void
apoint_free (struct apoint *apt)
static void apoint_free(struct apoint *apt)
{
mem_free (apt->mesg);
erase_note (&apt->note);
mem_free (apt);
mem_free(apt->mesg);
erase_note(&apt->note);
mem_free(apt);
}
static void
apoint_dup (struct apoint *in, struct apoint *bkp)
static void 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->dur = in->dur;
bkp->state = in->state;
bkp->mesg = mem_strdup (in->mesg);
bkp->mesg = mem_strdup(in->mesg);
if (in->note)
bkp->note = mem_strdup (in->note);
bkp->note = mem_strdup(in->note);
}
void
apoint_llist_init (void)
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
* calling this function.
*/
void
apoint_llist_free (void)
void apoint_llist_free(void)
{
LLIST_TS_FREE_INNER (&alist_p, apoint_free);
LLIST_TS_FREE (&alist_p);
LLIST_TS_FREE_INNER(&alist_p, apoint_free);
LLIST_TS_FREE(&alist_p);
}
/* Sets which appointment is highlighted. */
void
apoint_hilt_set (int highlighted)
void apoint_hilt_set(int highlighted)
{
hilt = highlighted;
}
void
apoint_hilt_decrease (int n)
void apoint_hilt_decrease(int n)
{
hilt -= n;
}
void
apoint_hilt_increase (int n)
void apoint_hilt_increase(int n)
{
hilt += n;
}
/* Return which appointment is highlighted. */
int
apoint_hilt (void)
int apoint_hilt(void)
{
return hilt;
}
static int
apoint_cmp_start (struct apoint *a, struct apoint *b)
static int apoint_cmp_start(struct apoint *a, struct apoint *b)
{
return a->start < b->start ? -1 : (a->start == b->start ? 0 : 1);
}
struct apoint *
apoint_new (char *mesg, char *note, long start, long dur, char state)
struct apoint *apoint_new(char *mesg, char *note, long start, long dur,
char state)
{
struct apoint *apt;
apt = mem_malloc (sizeof (struct apoint));
apt->mesg = mem_strdup (mesg);
apt->note = (note != NULL) ? mem_strdup (note) : NULL;
apt = mem_malloc(sizeof(struct apoint));
apt->mesg = mem_strdup(mesg);
apt->note = (note != NULL) ? mem_strdup(note) : NULL;
apt->state = state;
apt->start = start;
apt->dur = dur;
LLIST_TS_LOCK (&alist_p);
LLIST_TS_ADD_SORTED (&alist_p, apt, apoint_cmp_start);
LLIST_TS_UNLOCK (&alist_p);
LLIST_TS_LOCK(&alist_p);
LLIST_TS_ADD_SORTED(&alist_p, apt, apoint_cmp_start);
LLIST_TS_UNLOCK(&alist_p);
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,
* depending if the start time is entered or not.
*/
void
apoint_add (void)
void apoint_add(void)
{
#define LTIME 6
#define LDUR 12
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 =
_("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 *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 =
_("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");
int Id = 1;
char item_time[LDUR] = "";
@ -175,147 +165,122 @@ apoint_add (void)
int is_appointment = 1;
/* Get the starting time */
for (;;)
{
status_mesg (mesg_1, "");
if (getstring (win[STA].p, item_time, LTIME, 0, 1) != GETSTRING_ESC)
{
if (strlen (item_time) == 0)
{
is_appointment = 0;
break;
}
for (;;) {
status_mesg(mesg_1, "");
if (getstring(win[STA].p, item_time, LTIME, 0, 1) != GETSTRING_ESC) {
if (strlen(item_time) == 0) {
is_appointment = 0;
break;
}
if (parse_time (item_time, &heures, &minutes) == 1)
break;
else
{
status_mesg (format_message_1, enter_str);
wgetch (win[STA].p);
}
}
else
return;
}
if (parse_time(item_time, &heures, &minutes) == 1)
break;
else {
status_mesg(format_message_1, enter_str);
wgetch(win[STA].p);
}
} else
return;
}
/*
* Check if an event or appointment is entered,
* depending on the starting time, and record the
* corresponding item.
*/
if (is_appointment)
{ /* Get the appointment duration */
item_time[0] = '\0';
for (;;)
{
status_mesg (mesg_2, "");
if (getstring (win[STA].p, item_time, LDUR, 0, 1) != GETSTRING_ESC)
{
if (*item_time == '+' && parse_duration (item_time + 1,
&apoint_duration) == 1)
break;
else if (parse_time (item_time, &end_h, &end_m) == 1)
{
if (end_h < heures || ((end_h == heures) && (end_m < minutes)))
{
apoint_duration = MININSEC - minutes + end_m
+ (24 + end_h - (heures + 1)) * MININSEC;
}
else
{
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;
if (is_appointment) { /* Get the appointment duration */
item_time[0] = '\0';
for (;;) {
status_mesg(mesg_2, "");
if (getstring(win[STA].p, item_time, LDUR, 0, 1) != GETSTRING_ESC) {
if (*item_time == '+' && parse_duration(item_time + 1,
&apoint_duration) == 1)
break;
else if (parse_time(item_time, &end_h, &end_m) == 1) {
if (end_h < heures || ((end_h == heures) && (end_m < minutes))) {
apoint_duration = MININSEC - minutes + end_m
+ (24 + end_h - (heures + 1)) * MININSEC;
} else {
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 /* Insert the event Id */
} else /* Insert the event Id */
Id = 1;
status_mesg (mesg_3, "");
if (getstring (win[STA].p, item_mesg, BUFSIZ, 0, 1) == GETSTRING_VALID)
{
if (is_appointment)
{
apoint_start = date2sec (*calendar_get_slctd_day (), heures, minutes);
apoint_new (item_mesg, 0L, apoint_start, min2sec (apoint_duration), 0L);
if (notify_bar ())
notify_check_added (item_mesg, apoint_start, 0L);
}
else
event_new (item_mesg, 0L, date2sec (*calendar_get_slctd_day (), 0, 0), Id);
status_mesg(mesg_3, "");
if (getstring(win[STA].p, item_mesg, BUFSIZ, 0, 1) == GETSTRING_VALID) {
if (is_appointment) {
apoint_start = date2sec(*calendar_get_slctd_day(), heures, minutes);
apoint_new(item_mesg, 0L, apoint_start, min2sec(apoint_duration), 0L);
if (notify_bar())
notify_check_added(item_mesg, apoint_start, 0L);
} else
event_new(item_mesg, 0L, date2sec(*calendar_get_slctd_day(), 0, 0), Id);
if (hilt == 0)
hilt++;
}
wins_erase_status_bar ();
if (hilt == 0)
hilt++;
}
wins_erase_status_bar();
}
/* Delete an item from the appointment list. */
void
apoint_delete (unsigned *nb_events, unsigned *nb_apoints)
void apoint_delete(unsigned *nb_events, unsigned *nb_apoints)
{
const char *del_app_str = _("Do you really want to delete this item ?");
long date;
int nb_items = *nb_apoints + *nb_events;
int to_be_removed = 0;
date = calendar_get_slctd_day_sec ();
date = calendar_get_slctd_day_sec();
if (nb_items == 0)
return;
if (conf.confirm_delete)
{
if (status_ask_bool (del_app_str) != 1)
{
wins_erase_status_bar ();
return;
}
if (conf.confirm_delete) {
if (status_ask_bool(del_app_str) != 1) {
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)
{
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 (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;
}
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. */
int
apoint_cut (unsigned *nb_events, unsigned *nb_apoints)
int apoint_cut(unsigned *nb_events, unsigned *nb_apoints)
{
const int NBITEMS = *nb_apoints + *nb_events;
int item_type, to_be_removed;
@ -324,20 +289,16 @@ apoint_cut (unsigned *nb_events, unsigned *nb_apoints)
if (NBITEMS == 0)
return 0;
date = calendar_get_slctd_day_sec ();
item_type = day_cut_item (date, hilt);
if (item_type == EVNT || item_type == RECUR_EVNT)
{
(*nb_events)--;
to_be_removed = 1;
}
else if (item_type == APPT || item_type == RECUR_APPT)
{
(*nb_apoints)--;
to_be_removed = 3;
}
else
EXIT (_("no such type"));
date = calendar_get_slctd_day_sec();
item_type = day_cut_item(date, hilt);
if (item_type == EVNT || item_type == RECUR_EVNT) {
(*nb_events)--;
to_be_removed = 1;
} else if (item_type == APPT || item_type == RECUR_APPT) {
(*nb_apoints)--;
to_be_removed = 3;
} else
EXIT(_("no such type"));
/* NOTREACHED */
if (hilt > 1)
@ -351,14 +312,13 @@ apoint_cut (unsigned *nb_events, unsigned *nb_apoints)
}
/* Paste a previously cut item. */
void
apoint_paste (unsigned *nb_events, unsigned *nb_apoints, int cut_item_type)
void apoint_paste(unsigned *nb_events, unsigned *nb_apoints, int cut_item_type)
{
int item_type;
long date;
date = calendar_get_slctd_day_sec ();
item_type = day_paste_item (date, cut_item_type);
date = calendar_get_slctd_day_sec();
item_type = day_paste_item(date, cut_item_type);
if (item_type == EVNT || item_type == RECUR_EVNT)
(*nb_events)++;
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++;
}
unsigned
apoint_inday (struct apoint *i, long start)
unsigned apoint_inday(struct apoint *i, long start)
{
return (i->start <= start + DAYINSEC && i->start + i->dur > start);
}
void
apoint_sec2str (struct apoint *o, long day, char *start, char *end)
void apoint_sec2str(struct apoint *o, long day, char *start, char *end)
{
struct tm *lt;
time_t t;
if (o->start < day)
strncpy (start, "..:..", 6);
else
{
t = o->start;
lt = localtime (&t);
snprintf (start, HRMIN_SIZE, "%02u:%02u", lt->tm_hour, lt->tm_min);
}
strncpy(start, "..:..", 6);
else {
t = o->start;
lt = localtime(&t);
snprintf(start, HRMIN_SIZE, "%02u:%02u", lt->tm_hour, lt->tm_min);
}
if (o->start + o->dur > day + DAYINSEC)
strncpy (end, "..:..", 6);
else
{
t = o->start + o->dur;
lt = localtime (&t);
snprintf (end, HRMIN_SIZE, "%02u:%02u", lt->tm_hour, lt->tm_min);
}
strncpy(end, "..:..", 6);
else {
t = o->start + o->dur;
lt = localtime(&t);
snprintf(end, HRMIN_SIZE, "%02u:%02u", lt->tm_hour, lt->tm_min);
}
}
void
apoint_write (struct apoint *o, FILE *f)
void apoint_write(struct apoint *o, FILE * f)
{
struct tm *lt;
time_t t;
t = o->start;
lt = localtime (&t);
fprintf (f, "%02u/%02u/%04u @ %02u:%02u", lt->tm_mon + 1, lt->tm_mday,
1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
lt = localtime(&t);
fprintf(f, "%02u/%02u/%04u @ %02u:%02u", lt->tm_mon + 1, lt->tm_mday,
1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
t = o->start + o->dur;
lt = localtime (&t);
fprintf (f, " -> %02u/%02u/%04u @ %02u:%02u ", lt->tm_mon + 1, lt->tm_mday,
1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
lt = localtime(&t);
fprintf(f, " -> %02u/%02u/%04u @ %02u:%02u ", lt->tm_mon + 1, lt->tm_mday,
1900 + lt->tm_year, lt->tm_hour, lt->tm_min);
if (o->note != NULL)
fprintf (f, ">%s ", o->note);
fprintf(f, ">%s ", o->note);
if (o->state & APOINT_NOTIFY)
fputc ('!', f);
fputc('!', f);
else
fputc ('|', f);
fputc('|', f);
fprintf (f, "%s\n", o->mesg);
fprintf(f, "%s\n", o->mesg);
}
struct apoint *
apoint_scan (FILE *f, struct tm start, struct tm end, char state, char *note)
struct apoint *apoint_scan(FILE * f, struct tm start, struct tm end, char state,
char *note)
{
char buf[BUFSIZ], *newline;
time_t tstart, tend, t;
t = time (NULL);
localtime (&t);
t = time(NULL);
localtime(&t);
/* Read the appointment description */
if (!fgets (buf, sizeof buf, f))
if (!fgets(buf, sizeof buf, f))
return NULL;
newline = strchr (buf, '\n');
newline = strchr(buf, '\n');
if (newline)
*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_mon--;
tstart = mktime (&start);
tend = mktime (&end);
EXIT_IF (tstart == -1 || tend == -1 || tstart > tend,
_("date error in appointment"));
return apoint_new (buf, note, tstart, tend - tstart, state);
tstart = mktime(&start);
tend = mktime(&end);
EXIT_IF(tstart == -1 || tend == -1 || tstart > tend,
_("date error in appointment"));
return apoint_new(buf, note, tstart, tend - tstart, state);
}
/* Retrieve an appointment from the list, given the day and item position. */
struct apoint *
apoint_get (long day, int pos)
struct apoint *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)
return LLIST_TS_GET_DATA (i);
return LLIST_TS_GET_DATA(i);
EXIT (_("item not found"));
EXIT(_("item not found"));
/* NOTREACHED */
}
void
apoint_delete_bynum (long start, unsigned num, enum eraseflg flag)
void apoint_delete_bynum(long start, unsigned num, enum eraseflg flag)
{
llist_item_t *i;
int need_check_notify = 0;
LLIST_TS_LOCK (&alist_p);
i = LLIST_TS_FIND_NTH (&alist_p, num, start, apoint_inday);
LLIST_TS_LOCK(&alist_p);
i = LLIST_TS_FIND_NTH(&alist_p, num, start, apoint_inday);
if (!i)
EXIT (_("no such appointment"));
struct apoint *apt = LLIST_TS_GET_DATA (i);
EXIT(_("no such appointment"));
struct apoint *apt = LLIST_TS_GET_DATA(i);
switch (flag)
{
case ERASE_FORCE_ONLY_NOTE:
erase_note (&apt->note);
break;
case ERASE_CUT:
apoint_free_bkp ();
apoint_dup (apt, &bkp_cut_apoint);
erase_note (&apt->note);
/* FALLTHROUGH */
default:
if (notify_bar ())
need_check_notify = notify_same_item (apt->start);
LLIST_TS_REMOVE (&alist_p, i);
mem_free (apt->mesg);
mem_free (apt);
if (need_check_notify)
notify_check_next_app (0);
break;
}
switch (flag) {
case ERASE_FORCE_ONLY_NOTE:
erase_note(&apt->note);
break;
case ERASE_CUT:
apoint_free_bkp();
apoint_dup(apt, &bkp_cut_apoint);
erase_note(&apt->note);
/* FALLTHROUGH */
default:
if (notify_bar())
need_check_notify = notify_same_item(apt->start);
LLIST_TS_REMOVE(&alist_p, i);
mem_free(apt->mesg);
mem_free(apt);
if (need_check_notify)
notify_check_next_app(0);
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
* to place beggining of the pad correctly.
*/
static int
get_item_line (int item_nb, int nb_events_inday)
static int get_item_line(int item_nb, int nb_events_inday)
{
int separator = 2;
int line = 0;
@ -523,7 +474,7 @@ get_item_line (int item_nb, int nb_events_inday)
line = item_nb - 1;
else
line = nb_events_inday + separator
+ (item_nb - (nb_events_inday + 1)) * 3 - 1;
+ (item_nb - (nb_events_inday + 1)) * 3 - 1;
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
* appointment panel scroll down next time pnoutrefresh is called.
*/
void
apoint_scroll_pad_down (int nb_events_inday, int win_length)
void apoint_scroll_pad_down(int nb_events_inday, int win_length)
{
int pad_last_line = 0;
int item_first_line = 0, item_last_line = 0;
int borders = 6;
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)
item_last_line = item_first_line;
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
* appointment panel scroll up next time pnoutrefresh is called.
*/
void
apoint_scroll_pad_up (int nb_events_inday)
void apoint_scroll_pad_up(int nb_events_inday)
{
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)
apad.first_onscreen = item_first_line;
}
static int
apoint_starts_after (struct apoint *apt, long time)
static int apoint_starts_after(struct apoint *apt, long 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
* stored in the notify_app structure (which is the next item to be notified).
*/
struct notify_app *
apoint_check_next (struct notify_app *app, long start)
struct notify_app *apoint_check_next(struct notify_app *app, long start)
{
llist_item_t *i;
LLIST_TS_LOCK (&alist_p);
i = LLIST_TS_FIND_FIRST (&alist_p, start, apoint_starts_after);
LLIST_TS_LOCK(&alist_p);
i = LLIST_TS_FIND_FIRST(&alist_p, start, apoint_starts_after);
if (i)
{
struct apoint *apt = LLIST_TS_GET_DATA (i);
if (i) {
struct apoint *apt = LLIST_TS_GET_DATA(i);
if (apt->start <= app->time)
{
app->time = apt->start;
app->txt = mem_strdup (apt->mesg);
app->state = apt->state;
app->got_app = 1;
}
if (apt->start <= app->time) {
app->time = apt->start;
app->txt = mem_strdup(apt->mesg);
app->state = apt->state;
app->got_app = 1;
}
}
LLIST_TS_UNLOCK (&alist_p);
LLIST_TS_UNLOCK(&alist_p);
return app;
}
@ -602,44 +547,40 @@ apoint_check_next (struct notify_app *app, long start)
/*
* Switch notification state.
*/
void
apoint_switch_notify (void)
void apoint_switch_notify(void)
{
struct day_item *p;
long date;
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)
return;
date = calendar_get_slctd_day_sec ();
date = calendar_get_slctd_day_sec();
if (p->type == RECUR_APPT)
{
recur_apoint_switch_notify (date, p->appt_pos);
return;
}
else if (p->type == APPT)
apoint_nb = day_item_nb (date, hilt, APPT);
if (p->type == RECUR_APPT) {
recur_apoint_switch_notify(date, p->appt_pos);
return;
} else if (p->type == APPT)
apoint_nb = day_item_nb(date, hilt, APPT);
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;
if (notify_bar ())
notify_check_added (apt->mesg, apt->start, apt->state);
if (notify_bar())
notify_check_added(apt->mesg, apt->start, apt->state);
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 */
void
apoint_update_panel (int which_pan)
void apoint_update_panel(int which_pan)
{
int title_xpos;
int bordr = 1;
@ -650,56 +591,53 @@ apoint_update_panel (int which_pan)
struct date slctd_date;
/* variable inits */
slctd_date = *calendar_get_slctd_day ();
title_xpos = win[APP].w - (strlen (_(monthnames[slctd_date.mm - 1])) + 16);
slctd_date = *calendar_get_slctd_day();
title_xpos = win[APP].w - (strlen(_(monthnames[slctd_date.mm - 1])) + 16);
if (slctd_date.dd < 10)
title_xpos++;
date = date2sec (slctd_date, 0, 0);
day_write_pad (date, app_width, app_length, (which_pan == APP) ? hilt : 0);
date = date2sec(slctd_date, 0, 0);
day_write_pad(date, app_width, app_length, (which_pan == APP) ? hilt : 0);
/* Print current date in the top right window corner. */
erase_window_part (win[APP].p, 1, title_lines, win[APP].w - 2,
win[APP].h - 2);
custom_apply_attr (win[APP].p, ATTR_HIGHEST);
mvwprintw (win[APP].p, title_lines, title_xpos, "%s %s %d, %d",
calendar_get_pom (date), _(monthnames[slctd_date.mm - 1]),
slctd_date.dd, slctd_date.yyyy);
custom_remove_attr (win[APP].p, ATTR_HIGHEST);
erase_window_part(win[APP].p, 1, title_lines, win[APP].w - 2, win[APP].h - 2);
custom_apply_attr(win[APP].p, ATTR_HIGHEST);
mvwprintw(win[APP].p, title_lines, title_xpos, "%s %s %d, %d",
calendar_get_pom(date), _(monthnames[slctd_date.mm - 1]),
slctd_date.dd, slctd_date.yyyy);
custom_remove_attr(win[APP].p, ATTR_HIGHEST);
/* Draw the scrollbar if necessary. */
if ((apad.length >= app_length) || (apad.first_onscreen > 0))
{
float ratio = ((float) app_length) / ((float) apad.length);
int sbar_length = (int) (ratio * app_length);
int highend = (int) (ratio * apad.first_onscreen);
unsigned hilt_bar = (which_pan == APP) ? 1 : 0;
int sbar_top = highend + title_lines + 1;
if ((apad.length >= app_length) || (apad.first_onscreen > 0)) {
float ratio = ((float)app_length) / ((float)apad.length);
int sbar_length = (int)(ratio * app_length);
int highend = (int)(ratio * apad.first_onscreen);
unsigned hilt_bar = (which_pan == APP) ? 1 : 0;
int sbar_top = highend + title_lines + 1;
if ((sbar_top + sbar_length) > win[APP].h - 1)
sbar_length = win[APP].h - 1 - sbar_top;
draw_scrollbar (win[APP].p, sbar_top, win[APP].w - 2, sbar_length,
title_lines + 1, win[APP].h - 1, hilt_bar);
}
if ((sbar_top + sbar_length) > win[APP].h - 1)
sbar_length = win[APP].h - 1 - sbar_top;
draw_scrollbar(win[APP].p, sbar_top, win[APP].w - 2, sbar_length,
title_lines + 1, win[APP].h - 1, hilt_bar);
}
wnoutrefresh (win[APP].p);
pnoutrefresh (apad.ptrwin, apad.first_onscreen, 0,
win[APP].y + title_lines + 1, win[APP].x + bordr,
win[APP].y + win[APP].h - 2 * bordr,
win[APP].x + win[APP].w - 3 * bordr);
wnoutrefresh(win[APP].p);
pnoutrefresh(apad.ptrwin, apad.first_onscreen, 0,
win[APP].y + title_lines + 1, win[APP].x + bordr,
win[APP].y + win[APP].h - 2 * bordr,
win[APP].x + win[APP].w - 3 * bordr);
}
void
apoint_paste_item (void)
void apoint_paste_item(void)
{
long bkp_time, bkp_start;
bkp_time = get_item_time (bkp_cut_apoint.start);
bkp_start = calendar_get_slctd_day_sec () + bkp_time;
apoint_new (bkp_cut_apoint.mesg, bkp_cut_apoint.note, bkp_start,
bkp_cut_apoint.dur, bkp_cut_apoint.state);
bkp_time = get_item_time(bkp_cut_apoint.start);
bkp_start = calendar_get_slctd_day_sec() + bkp_time;
apoint_new(bkp_cut_apoint.mesg, bkp_cut_apoint.note, bkp_start,
bkp_cut_apoint.dur, bkp_cut_apoint.state);
if (notify_bar ())
notify_check_added (bkp_cut_apoint.mesg, bkp_start, bkp_cut_apoint.state);
if (notify_bar())
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
* appointment highlight pointer if a new day was selected.
*/
static struct day_items_nb
do_storage (int day_changed)
static struct day_items_nb do_storage(int day_changed)
{
struct day_items_nb inday = *day_process_storage (calendar_get_slctd_day (),
day_changed, &inday);
struct day_items_nb inday = *day_process_storage(calendar_get_slctd_day(),
day_changed, &inday);
if (day_changed)
apoint_hilt_set (1);
apoint_hilt_set(1);
return inday;
}
@ -61,8 +60,7 @@ do_storage (int day_changed)
* and one can choose between different color schemes and layouts.
* All of the commands are documented within an online help system.
*/
int
main (int argc, char **argv)
int main(int argc, char **argv)
{
struct day_items_nb inday;
int no_data_file = 1;
@ -70,504 +68,455 @@ main (int argc, char **argv)
int count;
#if ENABLE_NLS
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif /* ENABLE_NLS */
/* Thread-safe data structure init */
apoint_llist_init ();
recur_apoint_llist_init ();
apoint_llist_init();
recur_apoint_llist_init();
/* Initialize non-thread-safe data structures. */
event_llist_init ();
todo_init_list ();
event_llist_init();
todo_init_list();
/*
* Begin by parsing and handling command line arguments.
* The data path is also initialized here.
*/
if (parse_args (argc, argv))
{
/* Non-interactive mode. */
exit_calcurse (EXIT_SUCCESS);
}
else
{
no_data_file = io_check_data_files ();
dmon_stop ();
io_set_lock ();
}
if (parse_args(argc, argv)) {
/* Non-interactive mode. */
exit_calcurse(EXIT_SUCCESS);
} else {
no_data_file = io_check_data_files();
dmon_stop();
io_set_lock();
}
/* Begin of interactive mode with ncurses interface. */
sigs_init (); /* signal handling init */
initscr (); /* start the curses mode */
cbreak (); /* control chars generate a signal */
noecho (); /* controls echoing of typed chars */
curs_set (0); /* make cursor invisible */
calendar_set_current_date ();
notify_init_vars ();
wins_get_config ();
sigs_init(); /* signal handling init */
initscr(); /* start the curses mode */
cbreak(); /* control chars generate a signal */
noecho(); /* controls echoing of typed chars */
curs_set(0); /* make cursor invisible */
calendar_set_current_date();
notify_init_vars();
wins_get_config();
/* Check if terminal supports color. */
if (has_colors ())
{
colorize = 1;
background = COLOR_BLACK;
foreground = COLOR_WHITE;
start_color ();
if (has_colors()) {
colorize = 1;
background = COLOR_BLACK;
foreground = COLOR_WHITE;
start_color();
#ifdef NCURSES_VERSION
if (use_default_colors () != ERR)
{
background = -1;
foreground = -1;
}
if (use_default_colors() != ERR) {
background = -1;
foreground = -1;
}
#endif /* NCURSES_VERSION */
/* Color assignment */
init_pair (COLR_RED, COLOR_RED, background);
init_pair (COLR_GREEN, COLOR_GREEN, background);
init_pair (COLR_YELLOW, COLOR_YELLOW, background);
init_pair (COLR_BLUE, COLOR_BLUE, background);
init_pair (COLR_MAGENTA, COLOR_MAGENTA, background);
init_pair (COLR_CYAN, COLOR_CYAN, background);
init_pair (COLR_DEFAULT, foreground, background);
init_pair (COLR_HIGH, COLOR_BLACK, COLOR_GREEN);
init_pair (COLR_CUSTOM, COLOR_RED, background);
}
else
{
colorize = 0;
background = COLOR_BLACK;
}
/* Color assignment */
init_pair(COLR_RED, COLOR_RED, background);
init_pair(COLR_GREEN, COLOR_GREEN, background);
init_pair(COLR_YELLOW, COLOR_YELLOW, background);
init_pair(COLR_BLUE, COLOR_BLUE, background);
init_pair(COLR_MAGENTA, COLOR_MAGENTA, background);
init_pair(COLR_CYAN, COLOR_CYAN, background);
init_pair(COLR_DEFAULT, foreground, background);
init_pair(COLR_HIGH, COLOR_BLACK, COLOR_GREEN);
init_pair(COLR_CUSTOM, COLOR_RED, background);
} else {
colorize = 0;
background = COLOR_BLACK;
}
vars_init ();
wins_init ();
wins_slctd_init ();
notify_init_bar ();
wins_reset_status_page ();
vars_init();
wins_init();
wins_slctd_init();
notify_init_bar();
wins_reset_status_page();
/*
* Read the data from files : first the user
* configuration (the display is then updated), and then
* the todo list, appointments and events.
*/
config_load ();
wins_erase_status_bar ();
io_load_keys (conf.pager);
io_load_todo ();
io_load_app ();
wins_reinit ();
if (conf.system_dialogs)
{
wins_update (FLAG_ALL);
io_startup_screen (no_data_file);
}
inday = *day_process_storage (0, 0, &inday);
wins_slctd_set (CAL);
wins_update (FLAG_ALL);
config_load();
wins_erase_status_bar();
io_load_keys(conf.pager);
io_load_todo();
io_load_app();
wins_reinit();
if (conf.system_dialogs) {
wins_update(FLAG_ALL);
io_startup_screen(no_data_file);
}
inday = *day_process_storage(0, 0, &inday);
wins_slctd_set(CAL);
wins_update(FLAG_ALL);
/* Start miscellaneous threads. */
if (notify_bar ())
notify_start_main_thread ();
calendar_start_date_thread ();
if (notify_bar())
notify_start_main_thread();
calendar_start_date_thread();
if (conf.periodic_save > 0)
io_start_psave_thread ();
io_start_psave_thread();
/* User input */
for (;;)
{
int key;
for (;;) {
int key;
if (resize)
{
resize = 0;
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;
if (resize) {
resize = 0;
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;
}
}

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;
};
static int config_parse_bool (unsigned *, const char *);
static int config_serialize_bool (char *, unsigned *);
static int config_parse_int (int *, const char *);
static int config_serialize_int (char *, int *);
static int config_parse_unsigned (unsigned *, const char *);
static int config_serialize_unsigned (char *, unsigned *);
static int config_parse_str (char *, const char *);
static int config_serialize_str (char *, const char *);
static int config_parse_calendar_view (void *, const char *);
static int config_serialize_calendar_view (char *, void *);
static int config_parse_first_day_of_week (void *, const char *);
static int config_serialize_first_day_of_week (char *, void *);
static int config_parse_color_theme (void *, const char *);
static int config_serialize_color_theme (char *, void *);
static int config_parse_layout (void *, const char *);
static int config_serialize_layout (char *, void *);
static int config_parse_sidebar_width (void *, const char *);
static int config_serialize_sidebar_width (char *, void *);
static int config_parse_output_datefmt (void *, const char *);
static int config_serialize_output_datefmt (char *, void *);
static int config_parse_input_datefmt (void *, const char *);
static int config_serialize_input_datefmt (char *, void *);
static int config_parse_bool(unsigned *, const char *);
static int config_serialize_bool(char *, unsigned *);
static int config_parse_int(int *, const char *);
static int config_serialize_int(char *, int *);
static int config_parse_unsigned(unsigned *, const char *);
static int config_serialize_unsigned(char *, unsigned *);
static int config_parse_str(char *, const char *);
static int config_serialize_str(char *, const char *);
static int config_parse_calendar_view(void *, const char *);
static int config_serialize_calendar_view(char *, void *);
static int config_parse_first_day_of_week(void *, const char *);
static int config_serialize_first_day_of_week(char *, void *);
static int config_parse_color_theme(void *, const char *);
static int config_serialize_color_theme(char *, void *);
static int config_parse_layout(void *, const char *);
static int config_serialize_layout(char *, void *);
static int config_parse_sidebar_width(void *, const char *);
static int config_serialize_sidebar_width(char *, void *);
static int config_parse_output_datefmt(void *, const char *);
static int config_serialize_output_datefmt(char *, void *);
static int config_parse_input_datefmt(void *, const char *);
static int config_serialize_input_datefmt(char *, void *);
#define CONFIG_HANDLER_BOOL(var) (config_fn_parse_t) config_parse_bool, \
(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)
static const struct confvar confmap[] = {
{ "appearance.calendarview", config_parse_calendar_view, config_serialize_calendar_view, NULL },
{ "appearance.layout", config_parse_layout, config_serialize_layout, NULL },
{ "appearance.notifybar", CONFIG_HANDLER_BOOL (nbar.show) },
{ "appearance.sidebarwidth", config_parse_sidebar_width, config_serialize_sidebar_width, NULL },
{ "appearance.theme", config_parse_color_theme, config_serialize_color_theme, NULL },
{ "daemon.enable", CONFIG_HANDLER_BOOL (dmon.enable) },
{ "daemon.log", CONFIG_HANDLER_BOOL (dmon.log) },
{ "format.inputdate", config_parse_input_datefmt, config_serialize_input_datefmt, NULL },
{ "format.notifydate", CONFIG_HANDLER_STR (nbar.datefmt) },
{ "format.notifytime", CONFIG_HANDLER_STR (nbar.timefmt) },
{ "format.outputdate", config_parse_output_datefmt, config_serialize_output_datefmt, NULL },
{ "general.autogc", CONFIG_HANDLER_BOOL (conf.auto_gc) },
{ "general.autosave", CONFIG_HANDLER_BOOL (conf.auto_save) },
{ "general.confirmdelete", CONFIG_HANDLER_BOOL (conf.confirm_delete) },
{ "general.confirmquit", CONFIG_HANDLER_BOOL (conf.confirm_quit) },
{ "general.firstdayofweek", config_parse_first_day_of_week, 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) }
{"appearance.calendarview", config_parse_calendar_view,
config_serialize_calendar_view, NULL},
{"appearance.layout", config_parse_layout, config_serialize_layout, NULL},
{"appearance.notifybar", CONFIG_HANDLER_BOOL(nbar.show)},
{"appearance.sidebarwidth", config_parse_sidebar_width,
config_serialize_sidebar_width, NULL},
{"appearance.theme", config_parse_color_theme, config_serialize_color_theme,
NULL},
{"daemon.enable", CONFIG_HANDLER_BOOL(dmon.enable)},
{"daemon.log", CONFIG_HANDLER_BOOL(dmon.log)},
{"format.inputdate", config_parse_input_datefmt,
config_serialize_input_datefmt, NULL},
{"format.notifydate", CONFIG_HANDLER_STR(nbar.datefmt)},
{"format.notifytime", CONFIG_HANDLER_STR(nbar.timefmt)},
{"format.outputdate", config_parse_output_datefmt,
config_serialize_output_datefmt, NULL},
{"general.autogc", CONFIG_HANDLER_BOOL(conf.auto_gc)},
{"general.autosave", CONFIG_HANDLER_BOOL(conf.auto_save)},
{"general.confirmdelete", CONFIG_HANDLER_BOOL(conf.confirm_delete)},
{"general.confirmquit", CONFIG_HANDLER_BOOL(conf.confirm_quit)},
{"general.firstdayofweek", config_parse_first_day_of_week,
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 {
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_junk_cb_t) (const char *, void *);
static int
config_parse_bool (unsigned *dest, const char *val)
static int config_parse_bool(unsigned *dest, const char *val)
{
if (strcmp (val, "yes") == 0)
if (strcmp(val, "yes") == 0)
*dest = 1;
else if (strcmp (val, "no") == 0)
else if (strcmp(val, "no") == 0)
*dest = 0;
else
return 0;
@ -127,55 +132,51 @@ config_parse_bool (unsigned *dest, const char *val)
return 1;
}
static int
config_parse_unsigned (unsigned *dest, const char *val)
static int config_parse_unsigned(unsigned *dest, const char *val)
{
if (is_all_digit (val))
*dest = atoi (val);
if (is_all_digit(val))
*dest = atoi(val);
else
return 0;
return 1;
}
static int
config_parse_int (int *dest, const char *val)
static int config_parse_int(int *dest, const char *val)
{
if ((*val == '+' || *val == '-' || isdigit (*val)) && is_all_digit (val + 1))
*dest = atoi (val);
if ((*val == '+' || *val == '-' || isdigit(*val)) && is_all_digit(val + 1))
*dest = atoi(val);
else
return 0;
return 1;
}
static int
config_parse_str (char *dest, const char *val)
static int config_parse_str(char *dest, const char *val)
{
strncpy (dest, val, BUFSIZ);
strncpy(dest, val, BUFSIZ);
return 1;
}
static int
config_parse_color (int *dest, const char *val)
static int config_parse_color(int *dest, const char *val)
{
if (!strcmp (val, "black"))
if (!strcmp(val, "black"))
*dest = COLOR_BLACK;
else if (!strcmp (val, "red"))
else if (!strcmp(val, "red"))
*dest = COLOR_RED;
else if (!strcmp (val, "green"))
else if (!strcmp(val, "green"))
*dest = COLOR_GREEN;
else if (!strcmp (val, "yellow"))
else if (!strcmp(val, "yellow"))
*dest = COLOR_YELLOW;
else if (!strcmp (val, "blue"))
else if (!strcmp(val, "blue"))
*dest = COLOR_BLUE;
else if (!strcmp (val, "magenta"))
else if (!strcmp(val, "magenta"))
*dest = COLOR_MAGENTA;
else if (!strcmp (val, "cyan"))
else if (!strcmp(val, "cyan"))
*dest = COLOR_CYAN;
else if (!strcmp (val, "white"))
else if (!strcmp(val, "white"))
*dest = COLOR_WHITE;
else if (!strcmp (val, "default"))
else if (!strcmp(val, "default"))
*dest = background;
else
return 0;
@ -183,137 +184,119 @@ config_parse_color (int *dest, const char *val)
return 1;
}
static int
config_parse_color_pair (int *dest1, int *dest2, const char *val)
static int config_parse_color_pair(int *dest1, int *dest2, const char *val)
{
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 (config_parse_color (dest1, s1) && config_parse_color (dest2, s2));
return (config_parse_color(dest1, s1) && config_parse_color(dest2, s2));
}
static int
config_parse_calendar_view (void *dummy, const char *val)
static int config_parse_calendar_view(void *dummy, const char *val)
{
calendar_set_view (atoi (val));
calendar_set_view(atoi(val));
return 1;
}
static int
config_parse_first_day_of_week (void *dummy, const char *val)
static int config_parse_first_day_of_week(void *dummy, const char *val)
{
if (!strcmp (val, "monday"))
calendar_set_first_day_of_week (MONDAY);
else if (!strcmp (val, "sunday"))
calendar_set_first_day_of_week (SUNDAY);
if (!strcmp(val, "monday"))
calendar_set_first_day_of_week(MONDAY);
else if (!strcmp(val, "sunday"))
calendar_set_first_day_of_week(SUNDAY);
else
return 0;
return 1;
}
static int
config_parse_color_theme (void *dummy, const char *val)
static int config_parse_color_theme(void *dummy, const char *val)
{
int color1, color2;
if (!config_parse_color_pair (&color1, &color2, val))
if (!config_parse_color_pair(&color1, &color2, val))
return 0;
init_pair (COLR_CUSTOM, color1, color2);
init_pair(COLR_CUSTOM, color1, color2);
return 1;
}
static int
config_parse_layout (void *dummy, const char *val)
static int config_parse_layout(void *dummy, const char *val)
{
wins_set_layout (atoi (val));
wins_set_layout(atoi(val));
return 1;
}
static int
config_parse_sidebar_width (void *dummy, const char *val)
static int config_parse_sidebar_width(void *dummy, const char *val)
{
wins_set_sbar_width (atoi (val));
wins_set_sbar_width(atoi(val));
return 1;
}
static int
config_parse_output_datefmt (void *dummy, const char *val)
static int config_parse_output_datefmt(void *dummy, const char *val)
{
if (val[0] != '\0')
return config_parse_str (conf.output_datefmt, val);
return config_parse_str(conf.output_datefmt, val);
return 1;
}
static int
config_parse_input_datefmt (void *dummy, const char *val)
static int 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)
conf.input_datefmt = 1;
return 1;
}
else
} else
return 0;
}
/* Set a configuration variable. */
static int
config_set_conf (const char *key, const char *value)
static int config_set_conf(const char *key, const char *value)
{
int i;
if (!key)
return -1;
for (i = 0; i < sizeof (confmap) / sizeof (confmap[0]); i++)
{
if (!strcmp (confmap[i].key, key))
return confmap[i].fn_parse (confmap[i].target, value);
}
for (i = 0; i < sizeof(confmap) / sizeof(confmap[0]); i++) {
if (!strcmp(confmap[i].key, key))
return confmap[i].fn_parse(confmap[i].target, value);
}
return -1;
}
static int
config_serialize_bool (char *dest, unsigned *val)
static int config_serialize_bool(char *dest, unsigned *val)
{
if (*val)
{
dest[0] = 'y';
dest[1] = 'e';
dest[2] = 's';
dest[3] = '\0';
}
else
{
dest[0] = 'n';
dest[1] = 'o';
dest[2] = '\0';
}
if (*val) {
dest[0] = 'y';
dest[1] = 'e';
dest[2] = 's';
dest[3] = '\0';
} else {
dest[0] = 'n';
dest[1] = 'o';
dest[2] = '\0';
}
return 1;
}
static int
config_serialize_unsigned (char *dest, unsigned *val)
static int config_serialize_unsigned(char *dest, unsigned *val)
{
snprintf (dest, BUFSIZ, "%u", *val);
snprintf(dest, BUFSIZ, "%u", *val);
return 1;
}
static int
config_serialize_int (char *dest, int *val)
static int config_serialize_int(char *dest, int *val)
{
snprintf (dest, BUFSIZ, "%d", *val);
snprintf(dest, BUFSIZ, "%d", *val);
return 1;
}
static int
config_serialize_str (char *dest, const char *val)
static int config_serialize_str(char *dest, const char *val)
{
strncpy (dest, val, BUFSIZ);
strncpy(dest, val, BUFSIZ);
return 1;
}
@ -325,8 +308,7 @@ config_serialize_str (char *dest, const char *val)
* If ncurses library was compiled with --enable-ext-funcs,
* then default color is -1.
*/
static void
config_color_theme_name (char *theme_name)
static void config_color_theme_name(char *theme_name)
{
#define MAXCOLORS 8
#define NBCOLORS 2
@ -349,37 +331,32 @@ config_color_theme_name (char *theme_name)
};
if (!colorize)
strncpy (theme_name, "0", BUFSIZ);
else
{
pair_content (COLR_CUSTOM, &color[0], &color[1]);
for (i = 0; i < NBCOLORS; i++)
{
if ((color[i] == DEFAULTCOLOR) || (color[i] == DEFAULTCOLOR_EXT))
color_name[i] = default_color;
else if (color[i] >= 0 && color[i] <= MAXCOLORS)
color_name[i] = name[color[i]];
else
{
EXIT (_("unknown color"));
/* NOTREACHED */
}
}
snprintf (theme_name, BUFSIZ, "%s on %s", color_name[0], color_name[1]);
strncpy(theme_name, "0", BUFSIZ);
else {
pair_content(COLR_CUSTOM, &color[0], &color[1]);
for (i = 0; i < NBCOLORS; i++) {
if ((color[i] == DEFAULTCOLOR) || (color[i] == DEFAULTCOLOR_EXT))
color_name[i] = default_color;
else if (color[i] >= 0 && color[i] <= MAXCOLORS)
color_name[i] = name[color[i]];
else {
EXIT(_("unknown color"));
/* NOTREACHED */
}
}
snprintf(theme_name, BUFSIZ, "%s on %s", color_name[0], color_name[1]);
}
}
static int
config_serialize_calendar_view (char *buf, void *dummy)
static int config_serialize_calendar_view(char *buf, void *dummy)
{
int tmp = calendar_get_view ();
return config_serialize_int (buf, &tmp);
int tmp = calendar_get_view();
return config_serialize_int(buf, &tmp);
}
static int
config_serialize_first_day_of_week (char *buf, void *dummy)
static int 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");
else
strcpy(buf, "sunday");
@ -387,195 +364,177 @@ config_serialize_first_day_of_week (char *buf, void *dummy)
return 1;
}
static int
config_serialize_color_theme (char *buf, void *dummy)
static int config_serialize_color_theme(char *buf, void *dummy)
{
config_color_theme_name (buf);
config_color_theme_name(buf);
return 1;
}
static int
config_serialize_layout (char *buf, void *dummy)
static int config_serialize_layout(char *buf, void *dummy)
{
int tmp = wins_layout ();
return config_serialize_int (buf, &tmp);
int tmp = wins_layout();
return config_serialize_int(buf, &tmp);
}
static int
config_serialize_sidebar_width (char *buf, void *dummy)
static int config_serialize_sidebar_width(char *buf, void *dummy)
{
int tmp = wins_sbar_wperc ();
return config_serialize_int (buf, &tmp);
int tmp = wins_sbar_wperc();
return config_serialize_int(buf, &tmp);
}
static int
config_serialize_output_datefmt (char *buf, void *dummy)
static int 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
config_serialize_input_datefmt (char *buf, void *dummy)
static int 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. */
static int
config_serialize_conf (char *buf, const char *key,
struct config_save_status *status)
config_serialize_conf(char *buf, const char *key,
struct config_save_status *status)
{
int i;
if (!key)
return -1;
for (i = 0; i < sizeof (confmap) / sizeof (confmap[0]); i++)
{
if (!strcmp (confmap[i].key, key))
{
if (confmap[i].fn_serialize (buf, confmap[i].target))
{
if (status)
status->done[i] = 1;
return 1;
}
else
return 0;
}
for (i = 0; i < sizeof(confmap) / sizeof(confmap[0]); i++) {
if (!strcmp(confmap[i].key, key)) {
if (confmap[i].fn_serialize(buf, confmap[i].target)) {
if (status)
status->done[i] = 1;
return 1;
} else
return 0;
}
}
return -1;
}
static void
config_file_walk (config_fn_walk_cb_t fn_cb,
config_fn_walk_junk_cb_t fn_junk_cb, void *data)
config_file_walk(config_fn_walk_cb_t fn_cb,
config_fn_walk_junk_cb_t fn_junk_cb, void *data)
{
FILE *data_file;
char buf[BUFSIZ], e_conf[BUFSIZ];
char *key, *value;
data_file = fopen (path_conf, "r");
EXIT_IF (data_file == NULL, _("failed to open configuration file"));
data_file = fopen(path_conf, "r");
EXIT_IF(data_file == NULL, _("failed to open configuration file"));
pthread_mutex_lock (&nbar.mutex);
for (;;)
{
if (fgets (buf, sizeof buf, data_file) == NULL)
break;
io_extract_data (e_conf, buf, sizeof buf);
pthread_mutex_lock(&nbar.mutex);
for (;;) {
if (fgets(buf, sizeof buf, data_file) == NULL)
break;
io_extract_data(e_conf, buf, sizeof buf);
if (*e_conf == '\0')
{
if (fn_junk_cb)
fn_junk_cb (buf, data);
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);
if (*e_conf == '\0') {
if (fn_junk_cb)
fn_junk_cb(buf, data);
continue;
}
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
config_load_cb (const char *key, const char *value, void *dummy)
static int 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)
EXIT (_("configuration variable unknown: \"%s\""), key);
/* NOTREACHED */
EXIT(_("configuration variable unknown: \"%s\""), key);
/* NOTREACHED */
else if (result == 0)
EXIT (_("wrong configuration variable format for \"%s\""), key);
/* NOTREACHED */
EXIT(_("wrong configuration variable format for \"%s\""), key);
/* NOTREACHED */
return 1;
}
/* Load the user configuration. */
void
config_load (void)
void config_load(void)
{
config_file_walk (config_load_cb, NULL, NULL);
config_file_walk(config_load_cb, NULL, NULL);
}
static int
config_save_cb (const char *key, const char *value, void *status)
static int config_save_cb(const char *key, const char *value, void *status)
{
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)
EXIT (_("configuration variable unknown: \"%s\""), key);
/* NOTREACHED */
EXIT(_("configuration variable unknown: \"%s\""), key);
/* NOTREACHED */
else if (result == 0)
EXIT (_("wrong configuration variable format for \"%s\""), key);
/* NOTREACHED */
EXIT(_("wrong configuration variable format for \"%s\""), key);
/* NOTREACHED */
fputs (key, ((struct config_save_status *) status)->fp);
fputc ('=', ((struct config_save_status *) status)->fp);
fputs (buf, ((struct config_save_status *) status)->fp);
fputc ('\n', ((struct config_save_status *) status)->fp);
fputs(key, ((struct config_save_status *)status)->fp);
fputc('=', ((struct config_save_status *)status)->fp);
fputs(buf, ((struct config_save_status *)status)->fp);
fputc('\n', ((struct config_save_status *)status)->fp);
return 1;
}
static int
config_save_junk_cb (const char *data, void *status)
static int 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;
}
/* Save the user configuration. */
unsigned
config_save (void)
unsigned config_save(void)
{
char tmppath[BUFSIZ];
char *tmpext;
@ -585,32 +544,31 @@ config_save (void)
if (read_only)
return 1;
strncpy (tmppath, get_tempdir (), BUFSIZ);
strncat (tmppath, "/" CONF_PATH_NAME ".", BUFSIZ - strlen (tmppath) - 1);
if ((tmpext = new_tempfile (tmppath, TMPEXTSIZ)) == NULL)
strncpy(tmppath, get_tempdir(), BUFSIZ);
strncat(tmppath, "/" CONF_PATH_NAME ".", BUFSIZ - strlen(tmppath) - 1);
if ((tmpext = new_tempfile(tmppath, TMPEXTSIZ)) == NULL)
return 0;
strncat (tmppath, tmpext, BUFSIZ - strlen (tmppath) - 1);
mem_free (tmpext);
strncat(tmppath, tmpext, BUFSIZ - strlen(tmppath) - 1);
mem_free(tmpext);
status.fp = fopen (tmppath, "w");
status.fp = fopen(tmppath, "w");
if (!status.fp)
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. */
for (i = 0; i < sizeof (confmap) / sizeof (confmap[0]); i++)
{
if (!status.done[i])
config_save_cb (confmap[i].key, NULL, &status);
}
for (i = 0; i < sizeof(confmap) / sizeof(confmap[0]); i++) {
if (!status.done[i])
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))
unlink (tmppath);
if (io_file_cp(tmppath, path_conf))
unlink(tmppath);
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 void
dmon_sigs_hdlr (int sig)
static void dmon_sigs_hdlr(int sig)
{
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)
{
DMON_LOG (_("Could not remove daemon lock file: %s\n"),
strerror (errno));
exit (EXIT_FAILURE);
}
if (unlink(path_dpid) != 0) {
DMON_LOG(_("Could not remove daemon lock file: %s\n"), strerror(errno));
exit(EXIT_FAILURE);
}
exit (EXIT_SUCCESS);
exit(EXIT_SUCCESS);
}
static unsigned
daemonize (int status)
static unsigned daemonize(int status)
{
int fd;
@ -93,16 +89,15 @@ daemonize (int status)
* First need to fork in order to become a child of the init process,
* once the father exits.
*/
switch (fork ())
{
case -1: /* fork error */
EXIT (_("Could not fork: %s\n"), strerror (errno));
break;
case 0: /* child */
break;
default: /* parent */
exit (status);
}
switch (fork()) {
case -1: /* fork error */
EXIT(_("Could not fork: %s\n"), strerror(errno));
break;
case 0: /* child */
break;
default: /* parent */
exit(status);
}
/*
* Process independency.
@ -110,109 +105,99 @@ daemonize (int status)
* Obtain a new process group and session in order to get detached from the
* controlling terminal.
*/
if (setsid () == -1)
{
DMON_LOG (_("Could not detach from the controlling terminal: %s\n"),
strerror (errno));
return 0;
}
if (setsid() == -1) {
DMON_LOG(_("Could not detach from the controlling terminal: %s\n"),
strerror(errno));
return 0;
}
/*
* Change working directory to root directory,
* to prevent filesystem unmounts.
*/
if (chdir ("/") == -1)
{
DMON_LOG (_("Could not change working directory: %s\n"),
strerror (errno));
return 0;
}
if (chdir("/") == -1) {
DMON_LOG(_("Could not change working directory: %s\n"), strerror(errno));
return 0;
}
/* Redirect standard file descriptors to /dev/null. */
if ((fd = open (_PATH_DEVNULL, O_RDWR, 0)) != -1)
{
dup2 (fd, STDIN_FILENO);
dup2 (fd, STDOUT_FILENO);
dup2 (fd, STDERR_FILENO);
if (fd > 2)
close (fd);
}
if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
if (fd > 2)
close(fd);
}
/* Write access for the owner only. */
umask (0022);
umask(0022);
if (!sigs_set_hdlr (SIGINT, dmon_sigs_hdlr)
|| !sigs_set_hdlr (SIGTERM, dmon_sigs_hdlr)
|| !sigs_set_hdlr (SIGALRM, dmon_sigs_hdlr)
|| !sigs_set_hdlr (SIGQUIT, dmon_sigs_hdlr)
|| !sigs_set_hdlr (SIGCHLD, SIG_IGN))
if (!sigs_set_hdlr(SIGINT, dmon_sigs_hdlr)
|| !sigs_set_hdlr(SIGTERM, dmon_sigs_hdlr)
|| !sigs_set_hdlr(SIGALRM, dmon_sigs_hdlr)
|| !sigs_set_hdlr(SIGQUIT, dmon_sigs_hdlr)
|| !sigs_set_hdlr(SIGCHLD, SIG_IGN))
return 0;
return 1;
}
void
dmon_start (int parent_exit_status)
void dmon_start(int parent_exit_status)
{
if (!daemonize (parent_exit_status))
DMON_ABRT (_("Cannot daemonize, aborting\n"));
if (!daemonize(parent_exit_status))
DMON_ABRT(_("Cannot daemonize, aborting\n"));
if (!io_dump_pid (path_dpid))
DMON_ABRT (_("Could not set lock file\n"));
if (!io_dump_pid(path_dpid))
DMON_ABRT(_("Could not set lock file\n"));
if (!io_file_exist (path_conf))
DMON_ABRT (_("Could not access \"%s\": %s\n"),
path_conf, strerror (errno));
config_load ();
if (!io_file_exist(path_conf))
DMON_ABRT(_("Could not access \"%s\": %s\n"), path_conf, strerror(errno));
config_load();
if (!io_file_exist (path_apts))
DMON_ABRT (_("Could not access \"%s\": %s\n"),
path_apts, strerror (errno));
apoint_llist_init ();
recur_apoint_llist_init ();
event_llist_init ();
todo_init_list ();
io_load_app ();
if (!io_file_exist(path_apts))
DMON_ABRT(_("Could not access \"%s\": %s\n"), path_apts, strerror(errno));
apoint_llist_init();
recur_apoint_llist_init();
event_llist_init();
todo_init_list();
io_load_app();
data_loaded = 1;
DMON_LOG (_("started at %s\n"), nowstr ());
for (;;)
{
int left;
DMON_LOG(_("started at %s\n"), nowstr());
for (;;) {
int left;
if (!notify_get_next_bkgd ())
DMON_ABRT (_("error loading next appointment\n"));
if (!notify_get_next_bkgd())
DMON_ABRT(_("error loading next appointment\n"));
left = notify_time_left ();
if (left > 0 && left < nbar.cntdwn && notify_needs_reminder ())
{
DMON_LOG (_("launching notification at %s for: \"%s\"\n"),
nowstr (), notify_app_txt ());
if (!notify_launch_cmd ())
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 ());
left = notify_time_left();
if (left > 0 && left < nbar.cntdwn && notify_needs_reminder()) {
DMON_LOG(_("launching notification at %s for: \"%s\"\n"),
nowstr(), notify_app_txt());
if (!notify_launch_cmd())
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());
}
}
/*
* Check if calcurse is running in background, and if yes, send a SIGINT
* signal to stop it.
*/
void
dmon_stop (void)
void dmon_stop(void)
{
int dpid;
dpid = io_get_pid (path_dpid);
dpid = io_get_pid(path_dpid);
if (!dpid)
return;
if (kill ((pid_t)dpid, SIGINT) < 0 && errno != ESRCH)
EXIT (_("Could not stop calcurse daemon: %s\n"), strerror (errno));
if (kill((pid_t) dpid, SIGINT) < 0 && errno != ESRCH)
EXIT(_("Could not stop calcurse daemon: %s\n"), strerror(errno));
}

160
src/event.c
View File

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

271
src/getstring.c
View File

@ -48,14 +48,13 @@ struct getstr_status {
};
/* Print the string at the desired position. */
static void
getstr_print (WINDOW *win, int x, int y, struct getstr_status *st)
static void getstr_print(WINDOW * win, int x, int y, struct getstr_status *st)
{
char c = 0;
/* print string */
mvwaddnstr (win, y, x, &st->s[st->ci[st->scrpos].offset], -1);
wclrtoeol (win);
mvwaddnstr(win, y, x, &st->s[st->ci[st->scrpos].offset], -1);
wclrtoeol(win);
/* print scrolling indicator */
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 = '<';
else if (st->ci[st->len].dpyoff - st->ci[st->scrpos].dpyoff > col - 2)
c = '>';
mvwprintw (win, y, col - 2, " %c", c);
mvwprintw(win, y, col - 2, " %c", c);
/* print cursor */
wmove (win, y, st->ci[st->pos].dpyoff - st->ci[st->scrpos].dpyoff);
wchgat (win, 1, A_REVERSE, COLR_CUSTOM, NULL);
wmove(win, y, st->ci[st->pos].dpyoff - st->ci[st->scrpos].dpyoff);
wchgat(win, 1, A_REVERSE, COLR_CUSTOM, NULL);
}
/* Delete a character at the given position in string. */
static void
getstr_del_char (struct getstr_status *st)
static void getstr_del_char(struct getstr_status *st)
{
char *str = st->s + 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 i;
memmove (str, str + cl, strlen (str) + 1);
memmove(str, str + cl, strlen(str) + 1);
st->len--;
for (i = st->pos; i <= st->len; i++)
{
st->ci[i].offset = st->ci[i + 1].offset - cl;
st->ci[i].dpyoff = st->ci[i + 1].dpyoff - cw;
}
for (i = st->pos; i <= st->len; i++) {
st->ci[i].offset = st->ci[i + 1].offset - cl;
st->ci[i].dpyoff = st->ci[i + 1].dpyoff - cw;
}
}
/* Add a character at the given position in string. */
static void
getstr_ins_char (struct getstr_status *st, char *c)
static void getstr_ins_char(struct getstr_status *st, char *c)
{
char *str = st->s + st->ci[st->pos].offset;
int cl = UTF8_LENGTH (c[0]);
int cw = utf8_width (c);
int cl = UTF8_LENGTH(c[0]);
int cw = utf8_width(c);
int i;
memmove (str + cl, str, strlen (str) + 1);
memmove(str + cl, str, strlen(str) + 1);
for (i = 0; i < cl; i++, str++)
*str = c[i];
for (i = st->len; i >= st->pos; i--)
{
st->ci[i + 1].offset = st->ci[i].offset + cl;
st->ci[i + 1].dpyoff = st->ci[i].dpyoff + cw;
}
for (i = st->len; i >= st->pos; i--) {
st->ci[i + 1].offset = st->ci[i].offset + cl;
st->ci[i + 1].dpyoff = st->ci[i].dpyoff + cw;
}
st->len++;
}
static void
bell (void)
static void bell(void)
{
putchar ('\a');
putchar('\a');
}
/* Initialize getstring data structure. */
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;
@ -128,15 +122,14 @@ getstr_init (struct getstr_status *st, char *str, struct getstr_charinfo *ci)
st->ci = ci;
st->len = width = 0;
while (*str)
{
st->ci[st->len].offset = str - st->s;
st->ci[st->len].dpyoff = width;
while (*str) {
st->ci[st->len].offset = str - st->s;
st->ci[st->len].dpyoff = width;
st->len++;
width += utf8_width (str);
str += UTF8_LENGTH (*str);
}
st->len++;
width += utf8_width(str);
str += UTF8_LENGTH(*str);
}
st->ci[st->len].offset = str - st->s;
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. */
static void
getstr_fixscr (struct getstr_status *st)
static void getstr_fixscr(struct getstr_status *st)
{
const int pgsize = col / 3;
int pgskip;
while (st->pos < st->scrpos)
{
pgskip = 0;
while (pgskip < pgsize && st->scrpos > 0)
{
st->scrpos--;
pgskip += st->ci[st->scrpos + 1].dpyoff - st->ci[st->scrpos].dpyoff;
}
while (st->pos < st->scrpos) {
pgskip = 0;
while (pgskip < pgsize && st->scrpos > 0) {
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)
{
pgskip = 0;
while (pgskip < pgsize && st->scrpos < st->len)
{
pgskip += st->ci[st->scrpos + 1].dpyoff - st->ci[st->scrpos].dpyoff;
st->scrpos++;
}
}
while (st->ci[st->pos].dpyoff - st->ci[st->scrpos].dpyoff > col - 2) {
pgskip = 0;
while (pgskip < pgsize && st->scrpos < st->len) {
pgskip += st->ci[st->scrpos + 1].dpyoff - st->ci[st->scrpos].dpyoff;
st->scrpos++;
}
}
}
/*
@ -179,8 +167,7 @@ getstr_fixscr (struct getstr_status *st)
* environment, otherwise the cursor would move from place to place without
* control.
*/
enum getstr
getstring (WINDOW *win, char *str, int l, int x, int y)
enum getstr getstring(WINDOW * win, char *str, int l, int x, int y)
{
struct getstr_status st;
struct getstr_charinfo ci[l + 1];
@ -188,112 +175,106 @@ getstring (WINDOW *win, char *str, int l, int x, int y)
int ch, k;
char c[UTF8_MAXLEN];
getstr_init (&st, str, ci);
custom_apply_attr (win, ATTR_HIGHEST);
getstr_init(&st, str, ci);
custom_apply_attr(win, ATTR_HIGHEST);
for (;;) {
getstr_fixscr (&st);
getstr_print (win, x, y, &st);
wins_doupdate ();
getstr_fixscr(&st);
getstr_print(win, x, y, &st);
wins_doupdate();
if ((ch = wgetch (win)) == '\n') break;
switch (ch)
{
case KEY_BACKSPACE: /* delete one character */
case 330:
case 127:
case CTRL ('H'):
if (st.pos > 0)
{
st.pos--;
getstr_del_char (&st);
}
else
bell ();
break;
case CTRL ('D'): /* delete next character */
if (st.pos < st.len)
getstr_del_char (&st);
else
bell ();
break;
case CTRL ('W'): /* delete a word */
if (st.pos > 0) {
while (st.pos && st.s[st.ci[st.pos - 1].offset] == ' ')
{
st.pos--;
getstr_del_char (&st);
}
while (st.pos && st.s[st.ci[st.pos - 1].offset] != ' ')
{
st.pos--;
getstr_del_char (&st);
}
}
else
bell ();
break;
case CTRL ('K'): /* delete to end-of-line */
st.s[st.ci[st.pos].offset] = 0;
st.len = st.pos;
break;
case CTRL ('A'): /* go to begginning of string */
st.pos = 0;
break;
case CTRL ('E'): /* go to end of string */
st.pos = st.len;
break;
case KEY_LEFT: /* move one char backward */
case CTRL ('B'):
if (st.pos > 0) st.pos--;
break;
case KEY_RIGHT: /* move one char forward */
case CTRL ('F'):
if (st.pos < st.len) st.pos++;
break;
case ESCAPE: /* cancel editing */
return GETSTRING_ESC;
break;
default: /* insert one character */
c[0] = ch;
for (k = 1; k < MIN (UTF8_LENGTH (c[0]), UTF8_MAXLEN); k++)
c[k] = (unsigned char)wgetch (win);
if (st.ci[st.len].offset + k < l)
{
getstr_ins_char (&st, c);
st.pos++;
}
if ((ch = wgetch(win)) == '\n')
break;
switch (ch) {
case KEY_BACKSPACE: /* delete one character */
case 330:
case 127:
case CTRL('H'):
if (st.pos > 0) {
st.pos--;
getstr_del_char(&st);
} else
bell();
break;
case CTRL('D'): /* delete next character */
if (st.pos < st.len)
getstr_del_char(&st);
else
bell();
break;
case CTRL('W'): /* delete a word */
if (st.pos > 0) {
while (st.pos && st.s[st.ci[st.pos - 1].offset] == ' ') {
st.pos--;
getstr_del_char(&st);
}
while (st.pos && st.s[st.ci[st.pos - 1].offset] != ' ') {
st.pos--;
getstr_del_char(&st);
}
} else
bell();
break;
case CTRL('K'): /* delete to end-of-line */
st.s[st.ci[st.pos].offset] = 0;
st.len = st.pos;
break;
case CTRL('A'): /* go to begginning of string */
st.pos = 0;
break;
case CTRL('E'): /* go to end of string */
st.pos = st.len;
break;
case KEY_LEFT: /* move one char backward */
case CTRL('B'):
if (st.pos > 0)
st.pos--;
break;
case KEY_RIGHT: /* move one char forward */
case CTRL('F'):
if (st.pos < st.len)
st.pos++;
break;
case ESCAPE: /* cancel editing */
return GETSTRING_ESC;
break;
default: /* insert one character */
c[0] = ch;
for (k = 1; k < MIN(UTF8_LENGTH(c[0]), UTF8_MAXLEN); k++)
c[k] = (unsigned char)wgetch(win);
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;
}
/* Update an already existing string. */
int
updatestring (WINDOW *win, char **str, int x, int y)
int updatestring(WINDOW * win, char **str, int x, int y)
{
int len = strlen (*str);
int len = strlen(*str);
char *buf;
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);
memcpy (buf, *str, len + 1);
buf = mem_malloc(BUFSIZ);
memcpy(buf, *str, len + 1);
ret = getstring (win, buf, BUFSIZ, x, y);
ret = getstring(win, buf, BUFSIZ, x, y);
if (ret == GETSTRING_VALID)
{
len = strlen (buf);
*str = mem_realloc (*str, len + 1, 1);
EXIT_IF (*str == NULL, _("out of memory"));
memcpy (*str, buf, len + 1);
}
if (ret == GETSTRING_VALID) {
len = strlen(buf);
*str = mem_realloc(*str, len + 1, 1);
EXIT_IF(*str == NULL, _("out of memory"));
memcpy(*str, buf, len + 1);
}
mem_free (buf);
mem_free(buf);
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) \
struct type *next /* To build the bucket chain list. */
struct type *next /* To build the bucket chain list. */
#define HTABLE_SIZE(head) \
(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"
#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 {
const char *label;
@ -94,89 +94,80 @@ static struct keydef_s keydef[NBKEYS] = {
{"lower-priority", "-"},
};
static void
dump_intro (FILE *fd)
static void dump_intro(FILE * fd)
{
const char *intro =
_("#\n"
"# Calcurse keys configuration file\n#\n"
"# This file sets the keybindings used 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"
"# with the following syntax:\n#\n"
"# ACTION KEY1 KEY2 ... KEYn\n#\n"
"# Where ACTION is what will be performed when KEY1, KEY2, ..., or KEYn\n"
"# will be pressed.\n"
"#\n"
"# To define bindings which use the CONTROL key, prefix the key with "
"'C-'.\n"
"# The escape, space bar and horizontal Tab key can be specified using\n"
"# the 'ESC', 'SPC' and 'TAB' keyword, respectively.\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"
"# keywords."
"\n#\n"
"# A description of what each ACTION keyword is used for is available\n"
"# from calcurse online configuration menu.\n");
_("#\n"
"# Calcurse keys configuration file\n#\n"
"# This file sets the keybindings used 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"
"# with the following syntax:\n#\n"
"# ACTION KEY1 KEY2 ... KEYn\n#\n"
"# Where ACTION is what will be performed when KEY1, KEY2, ..., or KEYn\n"
"# will be pressed.\n"
"#\n"
"# To define bindings which use the CONTROL key, prefix the key with "
"'C-'.\n"
"# The escape, space bar and horizontal Tab key can be specified using\n"
"# the 'ESC', 'SPC' and 'TAB' keyword, respectively.\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"
"# keywords."
"\n#\n"
"# A description of what each ACTION keyword is used for is available\n"
"# from calcurse online configuration menu.\n");
fprintf (fd, "%s\n", intro);
fprintf(fd, "%s\n", intro);
}
void
keys_init (void)
void keys_init(void)
{
int i;
for (i = 0; i < MAXKEYVAL; i++)
actions[i] = KEY_UNDEF;
for (i = 0; i < NBKEYS; i++)
LLIST_INIT (&keys[i]);
LLIST_INIT(&keys[i]);
}
static void
key_free (char *s)
static void key_free(char *s)
{
mem_free (s);
mem_free(s);
}
void
keys_free (void)
void keys_free(void)
{
int i;
for (i = 0; i < NBKEYS; i++)
{
LLIST_FREE_INNER (&keys[i], key_free);
LLIST_FREE (&keys[i]);
}
for (i = 0; i < NBKEYS; i++) {
LLIST_FREE_INNER(&keys[i], key_free);
LLIST_FREE(&keys[i]);
}
}
void
keys_dump_defaults (char *file)
void keys_dump_defaults(char *file)
{
FILE *fd;
int i;
fd = fopen (file, "w");
EXIT_IF (fd == NULL, _("FATAL ERROR: could not create default keys file."));
fd = fopen(file, "w");
EXIT_IF(fd == NULL, _("FATAL ERROR: could not create default keys file."));
dump_intro (fd);
dump_intro(fd);
for (i = 0; i < NBKEYS; i++)
fprintf (fd, "%s %s\n", keydef[i].label, keydef[i].binding);
file_close (fd, __FILE_POS__);
fprintf(fd, "%s %s\n", keydef[i].label, keydef[i].binding);
file_close(fd, __FILE_POS__);
}
const char *
keys_get_label (enum key key)
const char *keys_get_label(enum key key)
{
EXIT_IF (key < 0 || key > NBKEYS,
_("FATAL ERROR: key value out of bounds"));
EXIT_IF(key < 0 || key > NBKEYS, _("FATAL ERROR: key value out of bounds"));
return keydef[key].label;
}
enum key
keys_get_action (int pressed)
enum key keys_get_action(int pressed)
{
if (pressed < 0 || pressed > MAXKEYVAL)
return -1;
@ -184,61 +175,52 @@ keys_get_action (int pressed)
return actions[pressed];
}
enum key
keys_getch (WINDOW *win, int *count)
enum key keys_getch(WINDOW * win, int *count)
{
int ch = '0';
if (count)
{
*count = 0;
do
{
*count = *count * 10 + ch - '0';
ch = wgetch (win);
}
while ((ch == '0' && *count > 0) || (ch >= '1' && ch <= '9'));
if (*count == 0)
*count = 1;
if (count) {
*count = 0;
do {
*count = *count * 10 + ch - '0';
ch = wgetch(win);
}
else
ch = wgetch (win);
while ((ch == '0' && *count > 0) || (ch >= '1' && ch <= '9'));
switch (ch)
{
case KEY_RESIZE:
return KEY_RESIZE;
default:
return keys_get_action (ch);
}
if (*count == 0)
*count = 1;
} else
ch = wgetch(win);
switch (ch) {
case KEY_RESIZE:
return KEY_RESIZE;
default:
return keys_get_action(ch);
}
}
static void
add_key_str (enum key action, int key)
static void add_key_str(enum key action, int key)
{
if (action < 0 || action > NBKEYS)
return;
LLIST_ADD (&keys[action], mem_strdup (keys_int2str (key)));
LLIST_ADD(&keys[action], mem_strdup(keys_int2str(key)));
}
int
keys_assign_binding (int key, enum key action)
int keys_assign_binding(int key, enum key action)
{
if (key < 0 || key > MAXKEYVAL || actions[key] != KEY_UNDEF)
return 1;
else
{
actions[key] = action;
add_key_str (action, key);
}
else {
actions[key] = action;
add_key_str(action, key);
}
return 0;
}
static void
del_key_str (enum key action, int key)
static void del_key_str(enum key action, int key)
{
llist_item_t *i;
char oldstr[BUFSIZ];
@ -246,30 +228,25 @@ del_key_str (enum key action, int key)
if (action < 0 || action > NBKEYS)
return;
strncpy (oldstr, keys_int2str (key), BUFSIZ);
strncpy(oldstr, keys_int2str(key), BUFSIZ);
LLIST_FOREACH (&keys[action], i)
{
if (strcmp (LLIST_GET_DATA (i), oldstr) == 0)
{
LLIST_REMOVE (&keys[action], i);
return;
}
LLIST_FOREACH(&keys[action], i) {
if (strcmp(LLIST_GET_DATA(i), oldstr) == 0) {
LLIST_REMOVE(&keys[action], i);
return;
}
}
}
void
keys_remove_binding (int key, enum key action)
void keys_remove_binding(int key, enum key action)
{
if (key >= 0 && key <= MAXKEYVAL)
{
actions[key] = KEY_UNDEF;
del_key_str (action, key);
}
if (key >= 0 && key <= MAXKEYVAL) {
actions[key] = KEY_UNDEF;
del_key_str(action, key);
}
}
int
keys_str2int (const char *key)
int keys_str2int(const char *key)
{
const char CONTROL_KEY[] = "C-";
const char TAB_KEY[] = "TAB";
@ -284,144 +261,132 @@ keys_str2int (const char *key)
if (!key)
return -1;
if (strlen (key) == 1)
if (strlen(key) == 1)
return (int)key[0];
else
{
if (key[0] == '^')
return CTRL ((int)key[1]);
else if (!strncmp (key, CONTROL_KEY, sizeof (CONTROL_KEY) - 1))
return CTRL ((int)key[sizeof (CONTROL_KEY) - 1]);
else if (!strcmp (key, TAB_KEY))
return TAB;
else if (!strcmp (key, ESCAPE_KEY))
return ESCAPE;
else if (!strcmp (key, SPACE_KEY))
return SPACE;
else if (!strcmp (key, CURSES_KEY_UP))
return KEY_UP;
else if (!strcmp (key, CURSES_KEY_DOWN))
return KEY_DOWN;
else if (!strcmp (key, CURSES_KEY_LEFT))
return KEY_LEFT;
else if (!strcmp (key, CURSES_KEY_RIGHT))
return KEY_RIGHT;
else if (!strcmp (key, CURSES_KEY_HOME))
return KEY_HOME;
else if (!strcmp (key, CURSES_KEY_END))
return KEY_END;
else
return -1;
}
else {
if (key[0] == '^')
return CTRL((int)key[1]);
else if (!strncmp(key, CONTROL_KEY, sizeof(CONTROL_KEY) - 1))
return CTRL((int)key[sizeof(CONTROL_KEY) - 1]);
else if (!strcmp(key, TAB_KEY))
return TAB;
else if (!strcmp(key, ESCAPE_KEY))
return ESCAPE;
else if (!strcmp(key, SPACE_KEY))
return SPACE;
else if (!strcmp(key, CURSES_KEY_UP))
return KEY_UP;
else if (!strcmp(key, CURSES_KEY_DOWN))
return KEY_DOWN;
else if (!strcmp(key, CURSES_KEY_LEFT))
return KEY_LEFT;
else if (!strcmp(key, CURSES_KEY_RIGHT))
return KEY_RIGHT;
else if (!strcmp(key, CURSES_KEY_HOME))
return KEY_HOME;
else if (!strcmp(key, CURSES_KEY_END))
return KEY_END;
else
return -1;
}
}
const char *
keys_int2str (int key)
const char *keys_int2str(int key)
{
switch (key)
{
case TAB:
return "TAB";
case SPACE:
return "SPC";
case ESCAPE:
return "ESC";
case KEY_UP:
return "UP";
case KEY_DOWN:
return "DWN";
case KEY_LEFT:
return "LFT";
case KEY_RIGHT:
return "RGT";
case KEY_HOME:
return "KEY_HOME";
case KEY_END:
return "KEY_END";
default:
return (char *)keyname (key);
}
switch (key) {
case TAB:
return "TAB";
case SPACE:
return "SPC";
case ESCAPE:
return "ESC";
case KEY_UP:
return "UP";
case KEY_DOWN:
return "DWN";
case KEY_LEFT:
return "LFT";
case KEY_RIGHT:
return "RGT";
case KEY_HOME:
return "KEY_HOME";
case KEY_END:
return "KEY_END";
default:
return (char *)keyname(key);
}
}
int
keys_action_count_keys (enum key action)
int keys_action_count_keys(enum key action)
{
llist_item_t *i;
int n = 0;
LLIST_FOREACH (&keys[action], i)
n++;
LLIST_FOREACH(&keys[action], i)
n++;
return n;
}
const char *
keys_action_firstkey (enum key action)
const char *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";
}
const char *
keys_action_nkey (enum key action, int keynum)
const char *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 *
keys_action_allkeys (enum key action)
char *keys_action_allkeys(enum key action)
{
llist_item_t *i;
static char keystr[BUFSIZ];
const char *CHAR_SPACE = " ";
if (!LLIST_FIRST (&keys[action]))
if (!LLIST_FIRST(&keys[action]))
return NULL;
keystr[0] = '\0';
LLIST_FOREACH (&keys[action], i)
{
const int MAXLEN = sizeof (keystr) - 1 - strlen (keystr);
strncat (keystr, LLIST_GET_DATA (i), MAXLEN - 1);
strncat (keystr, CHAR_SPACE, 1);
}
LLIST_FOREACH(&keys[action], i) {
const int MAXLEN = sizeof(keystr) - 1 - strlen(keystr);
strncat(keystr, LLIST_GET_DATA(i), MAXLEN - 1);
strncat(keystr, CHAR_SPACE, 1);
}
return keystr;
}
/* Need this to display keys properly inside status bar. */
static char *
keys_format_label (char *key, int keylen)
static char *keys_format_label(char *key, int keylen)
{
static char fmtkey[BUFSIZ];
const int len = strlen (key);
const int len = strlen(key);
const char dot = '.';
int i;
if (keylen > BUFSIZ)
return NULL;
memset (fmtkey, 0, sizeof(fmtkey));
memset(fmtkey, 0, sizeof(fmtkey));
if (len == 0)
strncpy (fmtkey, "?", sizeof (fmtkey));
else if (len <= keylen)
{
for (i = 0; i < keylen - len; i++)
fmtkey[i] = ' ';
strncat (fmtkey, key, keylen);
}
else
{
for (i = 0; i < keylen - 1; i++)
fmtkey[i] = key[i];
fmtkey[keylen - 1] = dot;
}
strncpy(fmtkey, "?", sizeof(fmtkey));
else if (len <= keylen) {
for (i = 0; i < keylen - len; i++)
fmtkey[i] = ' ';
strncat(fmtkey, key, keylen);
} else {
for (i = 0; i < keylen - 1; i++)
fmtkey[i] = key[i];
fmtkey[keylen - 1] = dot;
}
return fmtkey;
}
void
keys_display_bindings_bar (WINDOW *win, struct binding *bindings[], int count,
int page_base, int page_size, struct binding *more)
keys_display_bindings_bar(WINDOW * win, struct binding *bindings[], int count,
int page_base, int page_size, struct binding *more)
{
/* Padding between two key bindings. */
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;
wins_erase_status_bar ();
for (i = 0; i < page_size && page_base + i < count; i++)
{
/* Location of key and label. */
const int key_pos_x = (i / 2) * cmd_len;
const int key_pos_y = i % 2;
const int label_pos_x = key_pos_x + KEYS_KEYLEN + 1;
const int label_pos_y = key_pos_y;
wins_erase_status_bar();
for (i = 0; i < page_size && page_base + i < count; i++) {
/* Location of key and label. */
const int key_pos_x = (i / 2) * cmd_len;
const int key_pos_y = i % 2;
const int label_pos_x = key_pos_x + KEYS_KEYLEN + 1;
const int label_pos_y = key_pos_y;
struct binding *binding;
char key[KEYS_KEYLEN + 1], *fmtkey;
struct binding *binding;
char key[KEYS_KEYLEN + 1], *fmtkey;
if (!more || i < page_size - 1 || page_base + i == count - 1)
binding = bindings[page_base + i];
else
binding = more;
if (!more || i < page_size - 1 || page_base + i == count - 1)
binding = bindings[page_base + i];
else
binding = more;
strncpy (key, keys_action_firstkey (binding->action), KEYS_KEYLEN);
key[KEYS_KEYLEN] = '\0';
fmtkey = keys_format_label (key, KEYS_KEYLEN);
strncpy(key, keys_action_firstkey(binding->action), KEYS_KEYLEN);
key[KEYS_KEYLEN] = '\0';
fmtkey = keys_format_label(key, KEYS_KEYLEN);
custom_apply_attr (win, ATTR_HIGHEST);
mvwprintw (win, key_pos_y, key_pos_x, fmtkey);
custom_remove_attr (win, ATTR_HIGHEST);
mvwprintw (win, label_pos_y, label_pos_x, binding->label);
}
wnoutrefresh (win);
custom_apply_attr(win, ATTR_HIGHEST);
mvwprintw(win, key_pos_y, key_pos_x, fmtkey);
custom_remove_attr(win, ATTR_HIGHEST);
mvwprintw(win, label_pos_y, label_pos_x, binding->label);
}
wnoutrefresh(win);
}
/*
* Display information about the given key.
* (could not add the keys descriptions to keydef variable, because of i18n).
*/
void
keys_popup_info (enum key key)
void keys_popup_info(enum key key)
{
char *info[NBKEYS];
WINDOW *infowin;
info[KEY_GENERIC_CANCEL] =
_("Cancel the ongoing action.");
info[KEY_GENERIC_SELECT] =
_("Select the highlighted item.");
info[KEY_GENERIC_CANCEL] = _("Cancel the ongoing action.");
info[KEY_GENERIC_SELECT] = _("Select the highlighted item.");
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] =
_("Display hints whenever some help screens are available.");
info[KEY_GENERIC_QUIT] =
_("Exit from the current menu, or quit calcurse.");
info[KEY_GENERIC_SAVE] =
_("Save calcurse data.");
info[KEY_GENERIC_CUT] =
_("Help for `generic-cut`.");
info[KEY_GENERIC_PASTE] =
_("Help for `generic-paste`.");
_("Display hints whenever some help screens are available.");
info[KEY_GENERIC_QUIT] = _("Exit from the current menu, or quit calcurse.");
info[KEY_GENERIC_SAVE] = _("Save calcurse data.");
info[KEY_GENERIC_CUT] = _("Help for `generic-cut`.");
info[KEY_GENERIC_PASTE] = _("Help for `generic-paste`.");
info[KEY_GENERIC_CHANGE_VIEW] =
_("Select next panel in calcurse main screen.");
info[KEY_GENERIC_IMPORT] =
_("Import data from an external file.");
info[KEY_GENERIC_EXPORT] =
_("Export data to a new file format.");
info[KEY_GENERIC_GOTO] =
_("Select the day to go to.");
_("Select next panel in calcurse main screen.");
info[KEY_GENERIC_IMPORT] = _("Import data from an external file.");
info[KEY_GENERIC_EXPORT] = _("Export data to a new file format.");
info[KEY_GENERIC_GOTO] = _("Select the day to go to.");
info[KEY_GENERIC_OTHER_CMD] =
_("Show next possible actions inside status bar.");
info[KEY_GENERIC_CONFIG_MENU] =
_("Enter the configuration menu.");
info[KEY_GENERIC_REDRAW] =
_("Redraw calcurse's screen.");
_("Show next possible actions inside status bar.");
info[KEY_GENERIC_CONFIG_MENU] = _("Enter the configuration menu.");
info[KEY_GENERIC_REDRAW] = _("Redraw calcurse's screen.");
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] =
_("Add a todo item, whichever panel is currently selected.");
_("Add a todo item, whichever panel is currently selected.");
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] =
_("Move to previous day in calendar, whichever panel is currently "
"selected.");
_("Move to previous day in calendar, whichever panel is currently "
"selected.");
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] =
_("Move to previous week in calendar, whichever panel is currently "
"selected");
_("Move to previous week in calendar, whichever panel is currently "
"selected");
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] =
_("Scroll window up (e.g. when displaying text inside a popup window).");
info[KEY_GENERIC_GOTO_TODAY] =
_("Go to today, whichever panel is selected.");
info[KEY_MOVE_RIGHT] =
_("Move to the right.");
info[KEY_MOVE_LEFT] =
_("Move to the left.");
info[KEY_MOVE_DOWN] =
_("Move down.");
info[KEY_MOVE_UP] =
_("Move up.");
_("Scroll window up (e.g. when displaying text inside a popup window).");
info[KEY_GENERIC_GOTO_TODAY] = _("Go to today, whichever panel is selected.");
info[KEY_MOVE_RIGHT] = _("Move to the right.");
info[KEY_MOVE_LEFT] = _("Move to the left.");
info[KEY_MOVE_DOWN] = _("Move down.");
info[KEY_MOVE_UP] = _("Move up.");
info[KEY_START_OF_WEEK] =
_("Select the first day of the current week when inside the calendar "
"panel.");
_("Select the first day of the current week when inside the calendar "
"panel.");
info[KEY_END_OF_WEEK] =
_("Select the last day of the current week when inside the calendar "
"panel.");
info[KEY_ADD_ITEM] =
_("Add an item to the currently selected panel.");
info[KEY_DEL_ITEM] =
_("Delete the currently selected item.");
info[KEY_EDIT_ITEM] =
_("Edit the currently seleted item.");
_("Select the last day of the current week when inside the calendar "
"panel.");
info[KEY_ADD_ITEM] = _("Add an item to the currently selected panel.");
info[KEY_DEL_ITEM] = _("Delete the currently selected item.");
info[KEY_EDIT_ITEM] = _("Edit the currently seleted item.");
info[KEY_VIEW_ITEM] =
_("Display the currently selected item inside a popup window.");
info[KEY_FLAG_ITEM] =
_("Flag the currently selected item as important.");
info[KEY_REPEAT_ITEM] =
_("Repeat an item");
_("Display the currently selected item inside a popup window.");
info[KEY_FLAG_ITEM] = _("Flag the currently selected item as important.");
info[KEY_REPEAT_ITEM] = _("Repeat an 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] =
_("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] =
_("View the note attached to the currently selected item.");
info[KEY_RAISE_PRIORITY] =
_("Raise a task priority inside the todo panel.");
info[KEY_LOWER_PRIORITY] =
_("Lower a task priority inside the todo panel.");
_("View the note attached to the currently selected item.");
info[KEY_RAISE_PRIORITY] = _("Raise a task priority inside the todo panel.");
info[KEY_LOWER_PRIORITY] = _("Lower a task priority inside the todo panel.");
if (key < 0 || key > NBKEYS)
return;
#define WINROW 10
#define WINCOL (col - 4)
infowin = popup (WINROW, WINCOL, (row - WINROW) / 2, (col - WINCOL) / 2,
keydef[key].label, info[key], 1);
keys_getch (infowin, NULL);
delwin (infowin);
infowin = popup(WINROW, WINCOL, (row - WINROW) / 2, (col - WINCOL) / 2,
keydef[key].label, info[key], 1);
keys_getch(infowin, NULL);
delwin(infowin);
#undef WINROW
#undef WINCOL
}
void
keys_save_bindings (FILE *fd)
void keys_save_bindings(FILE * fd)
{
int i;
EXIT_IF (fd == NULL, _("FATAL ERROR: null file pointer."));
dump_intro (fd);
EXIT_IF(fd == NULL, _("FATAL ERROR: null file pointer."));
dump_intro(fd);
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
keys_check_missing_bindings (void)
int keys_check_missing_bindings(void)
{
int i;
for (i = 0; i < NBKEYS; i++)
{
if (!LLIST_FIRST (&keys[i]))
return 1;
}
for (i = 0; i < NBKEYS; i++) {
if (!LLIST_FIRST(&keys[i]))
return 1;
}
return 0;
}
void
keys_fill_missing (void)
void keys_fill_missing(void)
{
int i;
for (i = 0; i < NBKEYS; i++)
{
if (!LLIST_FIRST (&keys[i]))
{
char *p, tmpbuf[BUFSIZ];
for (i = 0; i < NBKEYS; i++) {
if (!LLIST_FIRST(&keys[i])) {
char *p, tmpbuf[BUFSIZ];
strncpy (tmpbuf, keydef[i].binding, BUFSIZ);
p = tmpbuf;
for (;;)
{
char key_ch[BUFSIZ];
strncpy(tmpbuf, keydef[i].binding, BUFSIZ);
p = tmpbuf;
for (;;) {
char key_ch[BUFSIZ];
while (*p == ' ')
p++;
if (sscanf (p, "%s", key_ch) == 1)
{
int ch, used;
while (*p == ' ')
p++;
if (sscanf(p, "%s", key_ch) == 1) {
int ch, used;
ch = keys_str2int (key_ch);
used = keys_assign_binding (ch, i);
if (used)
WARN_MSG (_("When adding default key for \"%s\", "
"\"%s\" was already assigned!"),
keydef[i].label, key_ch);
p += strlen (key_ch) + 1;
}
else
break;
}
}
ch = keys_str2int(key_ch);
used = keys_assign_binding(ch, i);
if (used)
WARN_MSG(_("When adding default key for \"%s\", "
"\"%s\" was already assigned!"),
keydef[i].label, key_ch);
p += strlen(key_ch) + 1;
} else
break;
}
}
}
}

190
src/llist.c
View File

@ -39,8 +39,7 @@
/*
* Initialize a list.
*/
void
llist_init (llist_t *l)
void llist_init(llist_t * l)
{
l->head = NULL;
l->tail = NULL;
@ -49,16 +48,14 @@ llist_init (llist_t *l)
/*
* Free a list, but not the contained data.
*/
void
llist_free (llist_t *l)
void llist_free(llist_t * l)
{
llist_item_t *i, *t;
for (i = l->head; i; i = t)
{
t = i->next;
mem_free (i);
}
for (i = l->head; i; i = t) {
t = i->next;
mem_free(i);
}
l->head = NULL;
l->tail = NULL;
@ -67,26 +64,22 @@ llist_free (llist_t *l)
/*
* Free the data contained in a list.
*/
void
llist_free_inner (llist_t *l, llist_fn_free_t fn_free)
void llist_free_inner(llist_t * l, llist_fn_free_t fn_free)
{
llist_item_t *i;
for (i = l->head; i; i = i->next)
{
if (i->data)
{
fn_free(i->data);
i->data = NULL;
}
for (i = l->head; i; i = i->next) {
if (i->data) {
fn_free(i->data);
i->data = NULL;
}
}
}
/*
* Get the first item of a list.
*/
llist_item_t *
llist_first (llist_t *l)
llist_item_t *llist_first(llist_t * l)
{
return l->head;
}
@ -94,8 +87,7 @@ llist_first (llist_t *l)
/*
* Get the nth item of a list.
*/
llist_item_t *
llist_nth (llist_t *l, int n)
llist_item_t *llist_nth(llist_t * l, int n)
{
llist_item_t *i;
@ -111,8 +103,7 @@ llist_nth (llist_t *l, int n)
/*
* Get the successor of a list item.
*/
llist_item_t *
llist_next (llist_item_t *i)
llist_item_t *llist_next(llist_item_t * i)
{
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
* callback. Return NULL otherwise.
*/
llist_item_t *
llist_next_filter (llist_item_t *i, long data, llist_fn_match_t fn_match)
llist_item_t *llist_next_filter(llist_item_t * i, long data,
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;
else
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.
*/
void *
llist_get_data (llist_item_t *i)
void *llist_get_data(llist_item_t * i)
{
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.
*/
void
llist_add (llist_t *l, void *data)
void 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)
{
o->data = data;
o->next = NULL;
if (o) {
o->data = data;
o->next = NULL;
if (!l->head)
l->head = l->tail = o;
else
{
l->tail->next = o;
l->tail = o;
}
if (!l->head)
l->head = l->tail = o;
else {
l->tail->next = o;
l->tail = o;
}
}
}
/*
* Add an item to a sorted list.
*/
void
llist_add_sorted (llist_t *l, void *data, llist_fn_cmp_t fn_cmp)
void 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;
if (o)
{
o->data = data;
o->next = NULL;
if (o) {
o->data = data;
o->next = NULL;
if (!l->head)
l->head = l->tail = o;
else if (fn_cmp(o->data, l->tail->data) >= 0)
{
l->tail->next = o;
l->tail = o;
}
else if (fn_cmp(o->data, l->head->data) < 0)
{
o->next = l->head;
l->head = o;
}
else
{
i = l->head;
while (i->next && fn_cmp(o->data, i->next->data) >= 0)
i = i->next;
o->next = i->next;
i->next = o;
}
if (!l->head)
l->head = l->tail = o;
else if (fn_cmp(o->data, l->tail->data) >= 0) {
l->tail->next = o;
l->tail = o;
} else if (fn_cmp(o->data, l->head->data) < 0) {
o->next = l->head;
l->head = o;
} else {
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.
*/
void
llist_remove (llist_t *l, llist_item_t *i)
void llist_remove(llist_t * l, llist_item_t * i)
{
llist_item_t *j = NULL;
if (l->head && i == l->head)
l->head = i->next;
else
{
for (j = l->head; j && j->next != i; j = j->next)
;
}
else {
for (j = l->head; j && j->next != i; j = j->next) ;
}
if (i)
{
if (j)
j->next = i->next;
if (i == l->tail)
l->tail = j;
if (i) {
if (j)
j->next = i->next;
if (i == l->tail)
l->tail = j;
mem_free (i);
}
mem_free(i);
}
}
/*
* Find the first item matched by some filter callback.
*/
llist_item_t *
llist_find_first (llist_t *l, long data, llist_fn_match_t fn_match)
llist_item_t *llist_find_first(llist_t * l, long data,
llist_fn_match_t fn_match)
{
llist_item_t *i;
for (i = l->head; i; i = i->next)
{
if (fn_match (i->data, data))
return i;
}
for (i = l->head; i; i = i->next) {
if (fn_match(i->data, data))
return i;
}
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.
*/
llist_item_t *
llist_find_next (llist_item_t *i, long data, llist_fn_match_t fn_match)
llist_item_t *llist_find_next(llist_item_t * i, long data,
llist_fn_match_t fn_match)
{
if (i)
{
i = i->next;
for (; i; i = i->next)
{
if (fn_match (i->data, data))
return i;
}
if (i) {
i = i->next;
for (; i; i = i->next) {
if (fn_match(i->data, data))
return i;
}
}
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.
*/
llist_item_t *
llist_find_nth (llist_t *l, int n, long data, llist_fn_match_t fn_match)
llist_item_t *llist_find_nth(llist_t * l, int n, long data,
llist_fn_match_t fn_match)
{
llist_item_t *i;
if (n < 0)
return NULL;
for (i = l->head; i; i = i->next)
{
if (fn_match (i->data, data) && (n-- == 0))
return i;
}
for (i = l->head; i; i = i->next) {
if (fn_match(i->data, data) && (n-- == 0))
return i;
}
return NULL;
}

30
src/llist.h
View File

@ -38,7 +38,7 @@
typedef struct llist_item llist_item_t;
struct llist_item {
struct llist_item *next;
void *data;
void *data;
};
typedef struct llist llist_t;
@ -52,9 +52,9 @@ typedef int (*llist_fn_match_t) (void *, long);
typedef void (*llist_fn_free_t) (void *);
/* Initialization and deallocation. */
void llist_init (llist_t *);
void llist_free (llist_t *);
void llist_free_inner (llist_t *, llist_fn_free_t);
void llist_init(llist_t *);
void llist_free(llist_t *);
void llist_free_inner(llist_t *, llist_fn_free_t);
#define LLIST_INIT(l) llist_init(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)
/* Retrieving list items. */
llist_item_t *llist_first (llist_t *);
llist_item_t *llist_nth (llist_t *, int);
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_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_nth (llist_t *, int, long, llist_fn_match_t);
llist_item_t *llist_first(llist_t *);
llist_item_t *llist_nth(llist_t *, int);
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_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_nth(llist_t *, int, long, llist_fn_match_t);
#define LLIST_FIRST(l) llist_first(l)
#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))
/* 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)
/* List manipulation. */
void llist_add (llist_t *, void *);
void llist_add_sorted (llist_t *, void *, llist_fn_cmp_t);
void llist_remove (llist_t *, llist_item_t *);
void llist_add(llist_t *, void *);
void llist_add_sorted(llist_t *, void *, llist_fn_cmp_t);
void llist_remove(llist_t *, llist_item_t *);
#define LLIST_ADD(l, data) llist_add(l, data)
#define LLIST_ADD_SORTED(l, data, fn_cmp) \

7
src/llist_ts.h
View File

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

220
src/note.c
View File

@ -43,135 +43,124 @@
struct note_gc_hash {
char *hash;
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 int note_gc_cmp (struct note_gc_hash *, struct note_gc_hash *);
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 *);
HTABLE_HEAD (htp, NOTE_GC_HSIZE, note_gc_hash);
HTABLE_PROTOTYPE (htp, note_gc_hash)
HTABLE_GENERATE (htp, note_gc_hash, note_gc_extract_key, note_gc_cmp)
HTABLE_HEAD(htp, NOTE_GC_HSIZE, note_gc_hash);
HTABLE_PROTOTYPE(htp, note_gc_hash)
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
* contains its name. */
char *
generate_note (const char *str)
char *generate_note(const char *str)
{
char *sha1 = mem_malloc (SHA1_DIGESTLEN * 2 + 1);
char *sha1 = mem_malloc(SHA1_DIGESTLEN * 2 + 1);
char notepath[BUFSIZ];
FILE *fp;
sha1_digest (str, sha1);
snprintf (notepath, BUFSIZ, "%s%s", path_notes, sha1);
fp = fopen (notepath, "w");
EXIT_IF (fp == NULL, _("Warning: could not open %s, Aborting..."), notepath);
fputs (str, fp);
file_close (fp, __FILE_POS__);
sha1_digest(str, sha1);
snprintf(notepath, BUFSIZ, "%s%s", path_notes, sha1);
fp = fopen(notepath, "w");
EXIT_IF(fp == NULL, _("Warning: could not open %s, Aborting..."), notepath);
fputs(str, fp);
file_close(fp, __FILE_POS__);
return sha1;
}
/* Edit a note with an external editor. */
void
edit_note (char **note, const char *editor)
void edit_note(char **note, const char *editor)
{
char tmppath[BUFSIZ];
char *tmpext;
char notepath[BUFSIZ];
char *sha1 = mem_malloc (SHA1_DIGESTLEN * 2 + 1);
char *sha1 = mem_malloc(SHA1_DIGESTLEN * 2 + 1);
FILE *fp;
strncpy (tmppath, get_tempdir (), BUFSIZ);
strncat (tmppath, "/calcurse-note.", BUFSIZ - strlen (tmppath) - 1);
if ((tmpext = new_tempfile (tmppath, TMPEXTSIZ)) == NULL)
strncpy(tmppath, get_tempdir(), BUFSIZ);
strncat(tmppath, "/calcurse-note.", BUFSIZ - strlen(tmppath) - 1);
if ((tmpext = new_tempfile(tmppath, TMPEXTSIZ)) == NULL)
return;
strncat (tmppath, tmpext, BUFSIZ - strlen (tmppath) - 1);
mem_free (tmpext);
strncat(tmppath, tmpext, BUFSIZ - strlen(tmppath) - 1);
mem_free(tmpext);
if (*note != NULL)
{
snprintf (notepath, BUFSIZ, "%s%s", path_notes, *note);
io_file_cp (notepath, tmppath);
}
if (*note != NULL) {
snprintf(notepath, BUFSIZ, "%s%s", path_notes, *note);
io_file_cp(notepath, tmppath);
}
wins_launch_external (tmppath, editor);
wins_launch_external(tmppath, editor);
if (io_file_is_empty (tmppath) > 0)
erase_note (note);
else if ((fp = fopen (tmppath, "r")))
{
sha1_stream (fp, sha1);
fclose (fp);
*note = sha1;
if (io_file_is_empty(tmppath) > 0)
erase_note(note);
else if ((fp = fopen(tmppath, "r"))) {
sha1_stream(fp, sha1);
fclose(fp);
*note = sha1;
snprintf (notepath, BUFSIZ, "%s%s", path_notes, *note);
io_file_cp (tmppath, notepath);
}
snprintf(notepath, BUFSIZ, "%s%s", path_notes, *note);
io_file_cp(tmppath, notepath);
}
unlink (tmppath);
unlink(tmppath);
}
/* View a note in an external pager. */
void
view_note (const char *note, const char *pager)
void view_note(const char *note, const char *pager)
{
char fullname[BUFSIZ];
if (note == NULL)
return;
snprintf (fullname, BUFSIZ, "%s%s", path_notes, note);
wins_launch_external (fullname, pager);
snprintf(fullname, BUFSIZ, "%s%s", path_notes, note);
wins_launch_external(fullname, pager);
}
/* Erase a note previously attached to an item. */
void
erase_note (char **note)
void erase_note(char **note)
{
if (*note == NULL)
return;
mem_free (*note);
mem_free(*note);
*note = NULL;
}
/* Read a serialized note file name from a stream and deserialize it. */
void
note_read (char *buffer, FILE *fp)
void note_read(char *buffer, FILE * fp)
{
int i;
for (i = 0; i < MAX_NOTESIZ; i++)
{
buffer[i] = getc (fp);
if (buffer[i] == ' ')
{
buffer[i] = '\0';
return;
}
for (i = 0; i < MAX_NOTESIZ; i++) {
buffer[i] = getc(fp);
if (buffer[i] == ' ') {
buffer[i] = '\0';
return;
}
}
while (getc (fp) != ' ');
while (getc(fp) != ' ') ;
buffer[MAX_NOTESIZ] = '\0';
}
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;
*len = strlen (data->hash);
*len = strlen(data->hash);
}
static int
note_gc_cmp (struct note_gc_hash *a, struct note_gc_hash *b)
static int 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. */
void
note_gc (void)
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;
DIR *dirp;
struct dirent *dp;
@ -179,81 +168,68 @@ note_gc (void)
struct note_gc_hash tmph;
char notepath[BUFSIZ];
if (!(dirp = opendir (path_notes)))
if (!(dirp = opendir(path_notes)))
return;
/* Insert all note file names into a hash table. */
do
{
if ((dp = readdir (dirp)) && *(dp->d_name) != '.')
{
hp = mem_malloc (sizeof (struct note_gc_hash));
do {
if ((dp = readdir(dirp)) && *(dp->d_name) != '.') {
hp = mem_malloc(sizeof(struct note_gc_hash));
strncpy (hp->buf, dp->d_name, MAX_NOTESIZ + 1);
hp->hash = hp->buf;
strncpy(hp->buf, dp->d_name, MAX_NOTESIZ + 1);
hp->hash = hp->buf;
HTABLE_INSERT (htp, &gc_htable, hp);
}
HTABLE_INSERT(htp, &gc_htable, hp);
}
}
while (dp);
closedir (dirp);
closedir(dirp);
/* Remove hashes that are actually in use. */
LLIST_TS_FOREACH (&alist_p, i)
{
struct apoint *apt = LLIST_GET_DATA (i);
if (apt->note)
{
tmph.hash = apt->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
LLIST_TS_FOREACH(&alist_p, i) {
struct apoint *apt = LLIST_GET_DATA(i);
if (apt->note) {
tmph.hash = apt->note;
free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
}
}
LLIST_FOREACH (&eventlist, i)
{
struct event *ev = LLIST_GET_DATA (i);
if (ev->note)
{
tmph.hash = ev->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
LLIST_FOREACH(&eventlist, i) {
struct event *ev = LLIST_GET_DATA(i);
if (ev->note) {
tmph.hash = ev->note;
free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
}
}
LLIST_TS_FOREACH (&recur_alist_p, i)
{
struct recur_apoint *rapt = LLIST_GET_DATA (i);
if (rapt->note)
{
tmph.hash = rapt->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
LLIST_TS_FOREACH(&recur_alist_p, i) {
struct recur_apoint *rapt = LLIST_GET_DATA(i);
if (rapt->note) {
tmph.hash = rapt->note;
free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
}
}
LLIST_FOREACH (&recur_elist, i)
{
struct recur_event *rev = LLIST_GET_DATA (i);
if (rev->note)
{
tmph.hash = rev->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
LLIST_FOREACH(&recur_elist, i) {
struct recur_event *rev = LLIST_GET_DATA(i);
if (rev->note) {
tmph.hash = rev->note;
free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
}
}
LLIST_FOREACH (&todolist, i)
{
struct todo *todo = LLIST_GET_DATA (i);
if (todo->note)
{
tmph.hash = todo->note;
free (HTABLE_REMOVE (htp, &gc_htable, &tmph));
}
LLIST_FOREACH(&todolist, i) {
struct todo *todo = LLIST_GET_DATA(i);
if (todo->note) {
tmph.hash = todo->note;
free(HTABLE_REMOVE(htp, &gc_htable, &tmph));
}
}
/* Unlink unused note files. */
HTABLE_FOREACH (hp, htp, &gc_htable)
{
snprintf (notepath, BUFSIZ, "%s%s", path_notes, hp->hash);
unlink (notepath);
}
HTABLE_FOREACH(hp, htp, &gc_htable) {
snprintf(notepath, BUFSIZ, "%s%s", path_notes, hp->hash);
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"
/* Static functions used to add export functionalities. */
static void pcal_export_header (FILE *);
static void pcal_export_recur_events (FILE *);
static void pcal_export_events (FILE *);
static void pcal_export_recur_apoints (FILE *);
static void pcal_export_apoints (FILE *);
static void pcal_export_todo (FILE *);
static void pcal_export_footer (FILE *);
static void pcal_export_header(FILE *);
static void pcal_export_recur_events(FILE *);
static void pcal_export_events(FILE *);
static void pcal_export_recur_apoints(FILE *);
static void pcal_export_apoints(FILE *);
static void pcal_export_todo(FILE *);
static void pcal_export_footer(FILE *);
/* 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
* (mainly used to export data).
*/
static void
foreach_date_dump (const long date_end, struct rpt *rpt, llist_t *exc,
long item_first_date, long item_dur, char *item_mesg,
cb_dump_t cb_dump, FILE *stream)
foreach_date_dump(const long date_end, struct rpt *rpt, llist_t * exc,
long item_first_date, long item_dur, char *item_mesg,
cb_dump_t cb_dump, FILE * stream)
{
long date, item_time;
struct tm lt;
time_t t;
t = item_first_date;
lt = *localtime (&t);
lt = *localtime(&t);
lt.tm_hour = lt.tm_min = lt.tm_sec = 0;
lt.tm_isdst = -1;
date = mktime (&lt);
date = mktime(&lt);
item_time = item_first_date - date;
while (date <= date_end && date <= rpt->until)
{
if (recur_item_inday (item_first_date, item_dur, exc, rpt->type,
rpt->freq, rpt->until, date))
{
(*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;
}
while (date <= date_end && date <= rpt->until) {
if (recur_item_inday(item_first_date, item_dur, exc, rpt->type,
rpt->freq, rpt->until, date)) {
(*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;
}
}
}
static void
pcal_export_header (FILE *stream)
static void pcal_export_header(FILE * stream)
{
fputs ("# calcurse pcal export\n", stream);
fputs ("\n# =======\n# options\n# =======\n", stream);
fprintf (stream, "opt -A -K -l -m -F %s\n",
calendar_week_begins_on_monday () ? "Monday" : "Sunday");
fputs ("# Display week number (i.e. 1-52) on every Monday\n", stream);
fprintf (stream, "all monday in all %s %%w\n", _("Week"));
fputc ('\n', stream);
fputs("# calcurse pcal export\n", stream);
fputs("\n# =======\n# options\n# =======\n", stream);
fprintf(stream, "opt -A -K -l -m -F %s\n",
calendar_week_begins_on_monday()? "Monday" : "Sunday");
fputs("# Display week number (i.e. 1-52) on every Monday\n", stream);
fprintf(stream, "all monday in all %s %%w\n", _("Week"));
fputc('\n', stream);
}
static void
pcal_export_footer (FILE *stream)
static void pcal_export_footer(FILE * stream)
{
}
/* Format and dump event data to a pcal formatted file. */
static void
pcal_dump_event (FILE *stream, long event_date, long event_dur,
char *event_mesg)
pcal_dump_event(FILE * stream, long event_date, long event_dur,
char *event_mesg)
{
char pcal_date[BUFSIZ];
date_sec2date_fmt (event_date, "%b %d", pcal_date);
fprintf (stream, "%s %s\n", pcal_date, event_mesg);
date_sec2date_fmt(event_date, "%b %d", pcal_date);
fprintf(stream, "%s %s\n", pcal_date, event_mesg);
}
/* Format and dump appointment data to a pcal formatted file. */
static void
pcal_dump_apoint (FILE *stream, long apoint_date, long apoint_dur,
char *apoint_mesg)
pcal_dump_apoint(FILE * stream, long apoint_date, long apoint_dur,
char *apoint_mesg)
{
char pcal_date[BUFSIZ], pcal_beg[BUFSIZ], pcal_end[BUFSIZ];
date_sec2date_fmt (apoint_date, "%b %d", pcal_date);
date_sec2date_fmt (apoint_date, "%R", pcal_beg);
date_sec2date_fmt (apoint_date + apoint_dur, "%R", pcal_end);
fprintf (stream, "%s ", pcal_date);
fprintf (stream, "(%s -> %s) %s\n", pcal_beg, pcal_end, apoint_mesg);
date_sec2date_fmt(apoint_date, "%b %d", pcal_date);
date_sec2date_fmt(apoint_date, "%R", pcal_beg);
date_sec2date_fmt(apoint_date + apoint_dur, "%R", pcal_end);
fprintf(stream, "%s ", pcal_date);
fprintf(stream, "(%s -> %s) %s\n", pcal_beg, pcal_end, apoint_mesg);
}
static void
pcal_export_recur_events (FILE *stream)
static void pcal_export_recur_events(FILE * stream)
{
llist_item_t *i;
char pcal_date[BUFSIZ];
fputs ("\n# =============", stream);
fputs ("\n# Recur. Events", stream);
fputs ("\n# =============\n", stream);
fputs ("# (pcal does not support from..until dates specification\n", stream);
fputs("\n# =============", stream);
fputs("\n# Recur. Events", stream);
fputs("\n# =============\n", stream);
fputs("# (pcal does not support from..until dates specification\n", stream);
LLIST_FOREACH (&recur_elist, i)
{
struct recur_event *rev = LLIST_GET_DATA (i);
if (rev->rpt->until == 0 && rev->rpt->freq == 1)
{
switch (rev->rpt->type)
{
case RECUR_DAILY:
date_sec2date_fmt (rev->day, "%b %d", pcal_date);
fprintf (stream, "all day on_or_after %s %s\n", pcal_date,
rev->mesg);
break;
case RECUR_WEEKLY:
date_sec2date_fmt (rev->day, "%a", pcal_date);
fprintf (stream, "all %s on_or_after ", pcal_date);
date_sec2date_fmt (rev->day, "%b %d", pcal_date);
fprintf (stream, "%s %s\n", pcal_date, rev->mesg);
break;
case RECUR_MONTHLY:
date_sec2date_fmt (rev->day, "%d", pcal_date);
fprintf (stream, "day on all %s %s\n", pcal_date, rev->mesg);
break;
case RECUR_YEARLY:
date_sec2date_fmt (rev->day, "%b %d", pcal_date);
fprintf (stream, "%s %s\n", pcal_date, rev->mesg);
break;
default:
EXIT (_("incoherent repetition type"));
}
}
else
{
const long YEAR_START = calendar_start_of_year ();
const long YEAR_END = calendar_end_of_year ();
LLIST_FOREACH(&recur_elist, i) {
struct recur_event *rev = LLIST_GET_DATA(i);
if (rev->rpt->until == 0 && rev->rpt->freq == 1) {
switch (rev->rpt->type) {
case RECUR_DAILY:
date_sec2date_fmt(rev->day, "%b %d", pcal_date);
fprintf(stream, "all day on_or_after %s %s\n", pcal_date, rev->mesg);
break;
case RECUR_WEEKLY:
date_sec2date_fmt(rev->day, "%a", pcal_date);
fprintf(stream, "all %s on_or_after ", pcal_date);
date_sec2date_fmt(rev->day, "%b %d", pcal_date);
fprintf(stream, "%s %s\n", pcal_date, rev->mesg);
break;
case RECUR_MONTHLY:
date_sec2date_fmt(rev->day, "%d", pcal_date);
fprintf(stream, "day on all %s %s\n", pcal_date, rev->mesg);
break;
case RECUR_YEARLY:
date_sec2date_fmt(rev->day, "%b %d", pcal_date);
fprintf(stream, "%s %s\n", pcal_date, rev->mesg);
break;
default:
EXIT(_("incoherent repetition type"));
}
} 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)
foreach_date_dump (YEAR_END, rev->rpt, &rev->exc, rev->day, 0,
rev->mesg, (cb_dump_t) pcal_dump_event, stream);
}
if (rev->day < YEAR_END && rev->day > YEAR_START)
foreach_date_dump(YEAR_END, rev->rpt, &rev->exc, rev->day, 0,
rev->mesg, (cb_dump_t) pcal_dump_event, stream);
}
}
}
static void
pcal_export_events (FILE *stream)
static void pcal_export_events(FILE * stream)
{
llist_item_t *i;
fputs ("\n# ======\n# Events\n# ======\n", stream);
LLIST_FOREACH (&eventlist, i)
{
struct event *ev = LLIST_TS_GET_DATA (i);
pcal_dump_event (stream, ev->day, 0, ev->mesg);
}
fputc ('\n', stream);
fputs("\n# ======\n# Events\n# ======\n", stream);
LLIST_FOREACH(&eventlist, i) {
struct event *ev = LLIST_TS_GET_DATA(i);
pcal_dump_event(stream, ev->day, 0, ev->mesg);
}
fputc('\n', stream);
}
static void
pcal_export_recur_apoints (FILE *stream)
static void pcal_export_recur_apoints(FILE * stream)
{
llist_item_t *i;
char pcal_date[BUFSIZ], pcal_beg[BUFSIZ], pcal_end[BUFSIZ];
fputs ("\n# ==============", stream);
fputs ("\n# Recur. Apoints", stream);
fputs ("\n# ==============\n", stream);
fputs ("# (pcal does not support from..until dates specification\n", stream);
fputs("\n# ==============", stream);
fputs("\n# Recur. Apoints", stream);
fputs("\n# ==============\n", stream);
fputs("# (pcal does not support from..until dates specification\n", stream);
LLIST_TS_FOREACH (&recur_alist_p, i)
{
struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
LLIST_TS_FOREACH(&recur_alist_p, i) {
struct recur_apoint *rapt = LLIST_TS_GET_DATA(i);
if (rapt->rpt->until == 0 && rapt->rpt->freq == 1)
{
date_sec2date_fmt (rapt->start, "%R", pcal_beg);
date_sec2date_fmt (rapt->start + rapt->dur, "%R", pcal_end);
switch (rapt->rpt->type)
{
case RECUR_DAILY:
date_sec2date_fmt (rapt->start, "%b %d", pcal_date);
fprintf (stream, "all day on_or_after %s (%s -> %s) %s\n",
pcal_date, pcal_beg, pcal_end, rapt->mesg);
break;
case RECUR_WEEKLY:
date_sec2date_fmt (rapt->start, "%a", pcal_date);
fprintf (stream, "all %s on_or_after ", pcal_date);
date_sec2date_fmt (rapt->start, "%b %d", pcal_date);
fprintf (stream, "%s (%s -> %s) %s\n", pcal_date, pcal_beg,
pcal_end, rapt->mesg);
break;
case RECUR_MONTHLY:
date_sec2date_fmt (rapt->start, "%d", pcal_date);
fprintf (stream, "day on all %s (%s -> %s) %s\n", pcal_date,
pcal_beg, pcal_end, rapt->mesg);
break;
case RECUR_YEARLY:
date_sec2date_fmt (rapt->start, "%b %d", pcal_date);
fprintf (stream, "%s (%s -> %s) %s\n", pcal_date, pcal_beg,
pcal_end, rapt->mesg);
break;
default:
EXIT (_("incoherent repetition type"));
}
}
else
{
const long YEAR_START = calendar_start_of_year ();
const long YEAR_END = calendar_end_of_year ();
if (rapt->rpt->until == 0 && rapt->rpt->freq == 1) {
date_sec2date_fmt(rapt->start, "%R", pcal_beg);
date_sec2date_fmt(rapt->start + rapt->dur, "%R", pcal_end);
switch (rapt->rpt->type) {
case RECUR_DAILY:
date_sec2date_fmt(rapt->start, "%b %d", pcal_date);
fprintf(stream, "all day on_or_after %s (%s -> %s) %s\n",
pcal_date, pcal_beg, pcal_end, rapt->mesg);
break;
case RECUR_WEEKLY:
date_sec2date_fmt(rapt->start, "%a", pcal_date);
fprintf(stream, "all %s on_or_after ", pcal_date);
date_sec2date_fmt(rapt->start, "%b %d", pcal_date);
fprintf(stream, "%s (%s -> %s) %s\n", pcal_date, pcal_beg,
pcal_end, rapt->mesg);
break;
case RECUR_MONTHLY:
date_sec2date_fmt(rapt->start, "%d", pcal_date);
fprintf(stream, "day on all %s (%s -> %s) %s\n", pcal_date,
pcal_beg, pcal_end, rapt->mesg);
break;
case RECUR_YEARLY:
date_sec2date_fmt(rapt->start, "%b %d", pcal_date);
fprintf(stream, "%s (%s -> %s) %s\n", pcal_date, pcal_beg,
pcal_end, rapt->mesg);
break;
default:
EXIT(_("incoherent repetition type"));
}
} 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)
foreach_date_dump (YEAR_END, rapt->rpt, &rapt->exc, rapt->start,
rapt->dur, rapt->mesg,
(cb_dump_t)pcal_dump_apoint, stream);
}
if (rapt->start < YEAR_END && rapt->start > YEAR_START)
foreach_date_dump(YEAR_END, rapt->rpt, &rapt->exc, rapt->start,
rapt->dur, rapt->mesg,
(cb_dump_t) pcal_dump_apoint, stream);
}
}
}
static void
pcal_export_apoints (FILE *stream)
static void pcal_export_apoints(FILE * stream)
{
llist_item_t *i;
fputs ("\n# ============\n# Appointments\n# ============\n", stream);
LLIST_TS_LOCK (&alist_p);
LLIST_TS_FOREACH (&alist_p, i)
{
struct apoint *apt = LLIST_TS_GET_DATA (i);
pcal_dump_apoint (stream, apt->start, apt->dur, apt->mesg);
}
LLIST_TS_UNLOCK (&alist_p);
fputc ('\n', stream);
fputs("\n# ============\n# Appointments\n# ============\n", stream);
LLIST_TS_LOCK(&alist_p);
LLIST_TS_FOREACH(&alist_p, i) {
struct apoint *apt = LLIST_TS_GET_DATA(i);
pcal_dump_apoint(stream, apt->start, apt->dur, apt->mesg);
}
LLIST_TS_UNLOCK(&alist_p);
fputc('\n', stream);
}
static void
pcal_export_todo (FILE *stream)
static void pcal_export_todo(FILE * stream)
{
llist_item_t *i;
fputs ("#\n# Todos\n#\n", stream);
LLIST_FOREACH (&todolist, i)
{
struct todo *todo = LLIST_TS_GET_DATA (i);
if (todo->id < 0) /* completed items */
continue;
fputs("#\n# Todos\n#\n", stream);
LLIST_FOREACH(&todolist, i) {
struct todo *todo = LLIST_TS_GET_DATA(i);
if (todo->id < 0) /* completed items */
continue;
fputs ("note all ", stream);
fprintf (stream, "%d. %s\n", todo->id, todo->mesg);
}
fputc ('\n', stream);
fputs("note all ", stream);
fprintf(stream, "%d. %s\n", todo->id, todo->mesg);
}
fputc('\n', stream);
}
/* Export calcurse data. */
void
pcal_export_data (FILE *stream)
void pcal_export_data(FILE * stream)
{
pcal_export_header (stream);
pcal_export_recur_events (stream);
pcal_export_events (stream);
pcal_export_recur_apoints (stream);
pcal_export_apoints (stream);
pcal_export_todo (stream);
pcal_export_footer (stream);
pcal_export_header(stream);
pcal_export_recur_events(stream);
pcal_export_events(stream);
pcal_export_recur_apoints(stream);
pcal_export_apoints(stream);
pcal_export_todo(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 + \
rol (v, 5); w = rol (w, 30);
static void
sha1_transform (uint32_t state[5], const uint8_t buffer[64])
static void sha1_transform(uint32_t state[5], const uint8_t buffer[64])
{
typedef union {
uint8_t c[64];
uint32_t l[16];
} b64_t;
b64_t *block = (b64_t *)buffer;
b64_t *block = (b64_t *) buffer;
uint32_t a = state[0];
uint32_t b = state[1];
uint32_t c = state[2];
uint32_t d = state[3];
uint32_t e = state[4];
R0 (a, b, c, d, e, 0); R0 (e, a, b, c, d, 1);
R0 (d, e, a, b, c, 2); R0 (c, d, e, a, b, 3);
R0 (b, c, d, e, a, 4); R0 (a, b, c, d, e, 5);
R0 (e, a, b, c, d, 6); R0 (d, e, a, b, c, 7);
R0 (c, d, e, a, b, 8); R0 (b, c, d, e, a, 9);
R0 (a, b, c, d, e, 10); R0 (e, a, b, c, d, 11);
R0 (d, e, a, b, c, 12); R0 (c, d, e, a, b, 13);
R0 (b, c, d, e, a, 14); R0 (a, b, c, d, e, 15);
R1 (e, a, b, c, d, 16); R1 (d, e, a, b, c, 17);
R1 (c, d, e, a, b, 18); R1 (b, c, d, e, a, 19);
R2 (a, b, c, d, e, 20); R2 (e, a, b, c, d, 21);
R2 (d, e, a, b, c, 22); R2 (c, d, e, a, b, 23);
R2 (b, c, d, e, a, 24); R2 (a, b, c, d, e, 25);
R2 (e, a, b, c, d, 26); R2 (d, e, a, b, c, 27);
R2 (c, d, e, a, b, 28); R2 (b, c, d, e, a, 29);
R2 (a, b, c, d, e, 30); R2 (e, a, b, c, d, 31);
R2 (d, e, a, b, c, 32); R2 (c, d, e, a, b, 33);
R2 (b, c, d, e, a, 34); R2 (a, b, c, d, e, 35);
R2 (e, a, b, c, d, 36); R2 (d, e, a, b, c, 37);
R2 (c, d, e, a, b, 38); 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);
R0(a, b, c, d, e, 0);
R0(e, a, b, c, d, 1);
R0(d, e, a, b, c, 2);
R0(c, d, e, a, b, 3);
R0(b, c, d, e, a, 4);
R0(a, b, c, d, e, 5);
R0(e, a, b, c, d, 6);
R0(d, e, a, b, c, 7);
R0(c, d, e, a, b, 8);
R0(b, c, d, e, a, 9);
R0(a, b, c, d, e, 10);
R0(e, a, b, c, d, 11);
R0(d, e, a, b, c, 12);
R0(c, d, e, a, b, 13);
R0(b, c, d, e, a, 14);
R0(a, b, c, d, e, 15);
R1(e, a, b, c, d, 16);
R1(d, e, a, b, c, 17);
R1(c, d, e, a, b, 18);
R1(b, c, d, e, a, 19);
R2(a, b, c, d, e, 20);
R2(e, a, b, c, d, 21);
R2(d, e, a, b, c, 22);
R2(c, d, e, a, b, 23);
R2(b, c, d, e, a, 24);
R2(a, b, c, d, e, 25);
R2(e, a, b, c, d, 26);
R2(d, e, a, b, c, 27);
R2(c, d, e, a, b, 28);
R2(b, c, d, e, a, 29);
R2(a, b, c, d, e, 30);
R2(e, a, b, c, d, 31);
R2(d, e, a, b, c, 32);
R2(c, d, e, a, b, 33);
R2(b, c, d, e, a, 34);
R2(a, b, c, d, e, 35);
R2(e, a, b, c, d, 36);
R2(d, e, a, b, c, 37);
R2(c, d, e, a, b, 38);
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[1] += b;
@ -132,9 +171,7 @@ sha1_transform (uint32_t state[5], const uint8_t buffer[64])
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[1] = 0xEFCDAB89;
@ -145,8 +182,7 @@ sha1_init (sha1_ctx_t *ctx)
ctx->count[0] = ctx->count[1] = 0;
}
void
sha1_update (sha1_ctx_t *ctx, const uint8_t *data, unsigned int len)
void sha1_update(sha1_ctx_t * ctx, const uint8_t * data, unsigned int len)
{
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] += (len >> 29);
if (j + len > 63)
{
memcpy (&ctx->buffer[j], data, (i = 64 - j));
sha1_transform (ctx->state, ctx->buffer);
for (; i + 63 < len; i += 64)
sha1_transform (ctx->state, &data[i]);
j = 0;
}
else
if (j + len > 63) {
memcpy(&ctx->buffer[j], data, (i = 64 - j));
sha1_transform(ctx->state, ctx->buffer);
for (; i + 63 < len; i += 64)
sha1_transform(ctx->state, &data[i]);
j = 0;
} else
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;
uint8_t finalcount[8];
uint8_t finalcount[8];
for (i = 0; i < 8; i++)
{
finalcount[i] = (uint8_t)((ctx->count[(i >= 4 ? 0 : 1)] >>
((3 - (i & 3)) * 8)) & 255);
}
for (i = 0; i < 8; i++) {
finalcount[i] = (uint8_t) ((ctx->count[(i >= 4 ? 0 : 1)] >>
((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)
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++)
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;
memset (ctx->buffer, 0, SHA1_BLOCKLEN);
memset (ctx->state, 0, SHA1_DIGESTLEN);
memset (ctx->count, 0, 8);
memset (&finalcount, 0, 8);
memset(ctx->buffer, 0, SHA1_BLOCKLEN);
memset(ctx->state, 0, SHA1_DIGESTLEN);
memset(ctx->count, 0, 8);
memset(&finalcount, 0, 8);
}
void
sha1_digest (const char *data, char *buffer)
void sha1_digest(const char *data, char *buffer)
{
sha1_ctx_t ctx;
uint8_t digest[SHA1_DIGESTLEN];
int i;
sha1_init (&ctx);
sha1_update (&ctx, (const uint8_t *)data, strlen (data));
sha1_final (&ctx, (uint8_t *)digest);
sha1_init(&ctx);
sha1_update(&ctx, (const uint8_t *)data, strlen(data));
sha1_final(&ctx, (uint8_t *) digest);
for (i = 0; i < SHA1_DIGESTLEN; i++)
{
snprintf (buffer, 3, "%02x", digest[i]);
buffer += sizeof (char) * 2;
}
for (i = 0; i < SHA1_DIGESTLEN; i++) {
snprintf(buffer, 3, "%02x", digest[i]);
buffer += sizeof(char) * 2;
}
}
void
sha1_stream (FILE *fp, char *buffer)
void sha1_stream(FILE * fp, char *buffer)
{
sha1_ctx_t ctx;
uint8_t data[BUFSIZ];
@ -223,19 +251,17 @@ sha1_stream (FILE *fp, char *buffer)
uint8_t digest[SHA1_DIGESTLEN];
int i;
sha1_init (&ctx);
sha1_init(&ctx);
while (!feof (fp))
{
bytes_read = fread (data, 1, BUFSIZ, fp);
sha1_update (&ctx, data, bytes_read);
}
while (!feof(fp)) {
bytes_read = fread(data, 1, BUFSIZ, fp);
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++)
{
snprintf (buffer, 3, "%02x", digest[i]);
buffer += sizeof (char) * 2;
}
for (i = 0; i < SHA1_DIGESTLEN; i++) {
snprintf(buffer, 3, "%02x", digest[i]);
buffer += sizeof(char) * 2;
}
}

10
src/sha1.h
View File

@ -50,8 +50,8 @@ typedef struct {
uint8_t buffer[SHA1_BLOCKLEN];
} sha1_ctx_t;
void sha1_init (sha1_ctx_t *);
void sha1_update (sha1_ctx_t *, const uint8_t *, unsigned int);
void sha1_final (sha1_ctx_t *, uint8_t *);
void sha1_digest (const char *, char *);
void sha1_stream (FILE *, char *);
void sha1_init(sha1_ctx_t *);
void sha1_update(sha1_ctx_t *, const uint8_t *, unsigned int);
void sha1_final(sha1_ctx_t *, uint8_t *);
void sha1_digest(const char *, 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.
* Also catch CTRL-C (SIGINT), and SIGWINCH to resize screen automatically.
*/
static void
generic_hdlr (int sig)
static void generic_hdlr(int sig)
{
switch (sig)
{
case SIGCHLD:
while (waitpid (WAIT_MYPGRP, NULL, WNOHANG) > 0)
;
break;
case SIGWINCH:
resize = 1;
clearok (curscr, TRUE);
ungetch (KEY_RESIZE);
break;
case SIGTERM:
if (unlink (path_cpid) != 0)
{
EXIT (_("Could not remove calcurse lock file: %s\n"),
strerror (errno));
}
exit (EXIT_SUCCESS);
break;
switch (sig) {
case SIGCHLD:
while (waitpid(WAIT_MYPGRP, NULL, WNOHANG) > 0) ;
break;
case SIGWINCH:
resize = 1;
clearok(curscr, TRUE);
ungetch(KEY_RESIZE);
break;
case SIGTERM:
if (unlink(path_cpid) != 0) {
EXIT(_("Could not remove calcurse lock file: %s\n"), strerror(errno));
}
exit(EXIT_SUCCESS);
break;
}
}
unsigned
sigs_set_hdlr (int sig, void (*handler)(int))
unsigned sigs_set_hdlr(int sig, void (*handler) (int))
{
struct sigaction sa;
memset (&sa, 0, sizeof sa);
sigemptyset (&sa.sa_mask);
memset(&sa, 0, sizeof sa);
sigemptyset(&sa.sa_mask);
sa.sa_handler = handler;
sa.sa_flags = 0;
if (sigaction (sig, &sa, NULL) == -1)
{
ERROR_MSG (_("Error setting signal #%d : %s\n"),
sig, strerror (errno));
return 0;
}
if (sigaction(sig, &sa, NULL) == -1) {
ERROR_MSG(_("Error setting signal #%d : %s\n"), sig, strerror(errno));
return 0;
}
return 1;
}
/* Signal handling init. */
void
sigs_init ()
void sigs_init()
{
if (!sigs_set_hdlr (SIGCHLD, generic_hdlr)
|| !sigs_set_hdlr (SIGWINCH, generic_hdlr)
|| !sigs_set_hdlr (SIGTERM, generic_hdlr)
|| !sigs_set_hdlr (SIGINT, SIG_IGN))
exit_calcurse (1);
if (!sigs_set_hdlr(SIGCHLD, generic_hdlr)
|| !sigs_set_hdlr(SIGWINCH, generic_hdlr)
|| !sigs_set_hdlr(SIGTERM, generic_hdlr)
|| !sigs_set_hdlr(SIGINT, SIG_IGN))
exit_calcurse(1);
}

413
src/todo.c
View File

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

545
src/utf8.c
View File

@ -41,304 +41,295 @@ struct utf8_range {
};
static const struct utf8_range utf8_widthtab[] = {
{ 0x00300, 0x0036f, 0 },
{ 0x00483, 0x00489, 0 },
{ 0x00591, 0x005bd, 0 },
{ 0x005bf, 0x005bf, 0 },
{ 0x005c1, 0x005c2, 0 },
{ 0x005c4, 0x005c5, 0 },
{ 0x005c7, 0x005c7, 0 },
{ 0x00610, 0x0061a, 0 },
{ 0x0064b, 0x0065e, 0 },
{ 0x00670, 0x00670, 0 },
{ 0x006d6, 0x006dc, 0 },
{ 0x006de, 0x006e4, 0 },
{ 0x006e7, 0x006e8, 0 },
{ 0x006ea, 0x006ed, 0 },
{ 0x00711, 0x00711, 0 },
{ 0x00730, 0x0074a, 0 },
{ 0x007a6, 0x007b0, 0 },
{ 0x007eb, 0x007f3, 0 },
{ 0x00816, 0x00819, 0 },
{ 0x0081b, 0x00823, 0 },
{ 0x00825, 0x00827, 0 },
{ 0x00829, 0x0082d, 0 },
{ 0x00900, 0x00903, 0 },
{ 0x0093c, 0x0093c, 0 },
{ 0x0093e, 0x0094e, 0 },
{ 0x00951, 0x00955, 0 },
{ 0x00962, 0x00963, 0 },
{ 0x00981, 0x00983, 0 },
{ 0x009bc, 0x009bc, 0 },
{ 0x009be, 0x009c4, 0 },
{ 0x009c7, 0x009c8, 0 },
{ 0x009cb, 0x009cd, 0 },
{ 0x009d7, 0x009d7, 0 },
{ 0x009e2, 0x009e3, 0 },
{ 0x00a01, 0x00a03, 0 },
{ 0x00a3c, 0x00a3c, 0 },
{ 0x00a3e, 0x00a42, 0 },
{ 0x00a47, 0x00a48, 0 },
{ 0x00a4b, 0x00a4d, 0 },
{ 0x00a51, 0x00a51, 0 },
{ 0x00a70, 0x00a71, 0 },
{ 0x00a75, 0x00a75, 0 },
{ 0x00a81, 0x00a83, 0 },
{ 0x00abc, 0x00abc, 0 },
{ 0x00abe, 0x00ac5, 0 },
{ 0x00ac7, 0x00ac9, 0 },
{ 0x00acb, 0x00acd, 0 },
{ 0x00ae2, 0x00ae3, 0 },
{ 0x00b01, 0x00b03, 0 },
{ 0x00b3c, 0x00b3c, 0 },
{ 0x00b3e, 0x00b44, 0 },
{ 0x00b47, 0x00b48, 0 },
{ 0x00b4b, 0x00b4d, 0 },
{ 0x00b56, 0x00b57, 0 },
{ 0x00b62, 0x00b63, 0 },
{ 0x00b82, 0x00b82, 0 },
{ 0x00bbe, 0x00bc2, 0 },
{ 0x00bc6, 0x00bc8, 0 },
{ 0x00bca, 0x00bcd, 0 },
{ 0x00bd7, 0x00bd7, 0 },
{ 0x00c01, 0x00c03, 0 },
{ 0x00c3e, 0x00c44, 0 },
{ 0x00c46, 0x00c48, 0 },
{ 0x00c4a, 0x00c4d, 0 },
{ 0x00c55, 0x00c56, 0 },
{ 0x00c62, 0x00c63, 0 },
{ 0x00c82, 0x00c83, 0 },
{ 0x00cbc, 0x00cbc, 0 },
{ 0x00cbe, 0x00cc4, 0 },
{ 0x00cc6, 0x00cc8, 0 },
{ 0x00cca, 0x00ccd, 0 },
{ 0x00cd5, 0x00cd6, 0 },
{ 0x00ce2, 0x00ce3, 0 },
{ 0x00d02, 0x00d03, 0 },
{ 0x00d3e, 0x00d44, 0 },
{ 0x00d46, 0x00d48, 0 },
{ 0x00d4a, 0x00d4d, 0 },
{ 0x00d57, 0x00d57, 0 },
{ 0x00d62, 0x00d63, 0 },
{ 0x00d82, 0x00d83, 0 },
{ 0x00dca, 0x00dca, 0 },
{ 0x00dcf, 0x00dd4, 0 },
{ 0x00dd6, 0x00dd6, 0 },
{ 0x00dd8, 0x00ddf, 0 },
{ 0x00df2, 0x00df3, 0 },
{ 0x00e31, 0x00e31, 0 },
{ 0x00e34, 0x00e3a, 0 },
{ 0x00e47, 0x00e4e, 0 },
{ 0x00eb1, 0x00eb1, 0 },
{ 0x00eb4, 0x00eb9, 0 },
{ 0x00ebb, 0x00ebc, 0 },
{ 0x00ec8, 0x00ecd, 0 },
{ 0x00f18, 0x00f19, 0 },
{ 0x00f35, 0x00f35, 0 },
{ 0x00f37, 0x00f37, 0 },
{ 0x00f39, 0x00f39, 0 },
{ 0x00f3e, 0x00f3f, 0 },
{ 0x00f71, 0x00f84, 0 },
{ 0x00f86, 0x00f87, 0 },
{ 0x00f90, 0x00f97, 0 },
{ 0x00f99, 0x00fbc, 0 },
{ 0x00fc6, 0x00fc6, 0 },
{ 0x0102b, 0x0103e, 0 },
{ 0x01056, 0x01059, 0 },
{ 0x0105e, 0x01060, 0 },
{ 0x01062, 0x01064, 0 },
{ 0x01067, 0x0106d, 0 },
{ 0x01071, 0x01074, 0 },
{ 0x01082, 0x0108d, 0 },
{ 0x0108f, 0x0108f, 0 },
{ 0x0109a, 0x0109d, 0 },
{ 0x01100, 0x0115f, 2 },
{ 0x011a3, 0x011a7, 2 },
{ 0x011fa, 0x011ff, 2 },
{ 0x0135f, 0x0135f, 0 },
{ 0x01712, 0x01714, 0 },
{ 0x01732, 0x01734, 0 },
{ 0x01752, 0x01753, 0 },
{ 0x01772, 0x01773, 0 },
{ 0x017b6, 0x017d3, 0 },
{ 0x017dd, 0x017dd, 0 },
{ 0x0180b, 0x0180d, 0 },
{ 0x018a9, 0x018a9, 0 },
{ 0x01920, 0x0192b, 0 },
{ 0x01930, 0x0193b, 0 },
{ 0x019b0, 0x019c0, 0 },
{ 0x019c8, 0x019c9, 0 },
{ 0x01a17, 0x01a1b, 0 },
{ 0x01a55, 0x01a5e, 0 },
{ 0x01a60, 0x01a7c, 0 },
{ 0x01a7f, 0x01a7f, 0 },
{ 0x01b00, 0x01b04, 0 },
{ 0x01b34, 0x01b44, 0 },
{ 0x01b6b, 0x01b73, 0 },
{ 0x01b80, 0x01b82, 0 },
{ 0x01ba1, 0x01baa, 0 },
{ 0x01c24, 0x01c37, 0 },
{ 0x01cd0, 0x01cd2, 0 },
{ 0x01cd4, 0x01ce8, 0 },
{ 0x01ced, 0x01ced, 0 },
{ 0x01cf2, 0x01cf2, 0 },
{ 0x01dc0, 0x01de6, 0 },
{ 0x01dfd, 0x01dff, 0 },
{ 0x020d0, 0x020f0, 0 },
{ 0x02329, 0x0232a, 2 },
{ 0x02cef, 0x02cf1, 0 },
{ 0x02de0, 0x02dff, 0 },
{ 0x02e80, 0x02e99, 2 },
{ 0x02e9b, 0x02ef3, 2 },
{ 0x02f00, 0x02fd5, 2 },
{ 0x02ff0, 0x02ffb, 2 },
{ 0x03000, 0x03029, 2 },
{ 0x0302a, 0x0302f, 0 },
{ 0x03030, 0x0303e, 2 },
{ 0x03041, 0x03096, 2 },
{ 0x03099, 0x0309a, 0 },
{ 0x0309b, 0x030ff, 2 },
{ 0x03105, 0x0312d, 2 },
{ 0x03131, 0x0318e, 2 },
{ 0x03190, 0x031b7, 2 },
{ 0x031c0, 0x031e3, 2 },
{ 0x031f0, 0x0321e, 2 },
{ 0x03220, 0x03247, 2 },
{ 0x03250, 0x032fe, 2 },
{ 0x03300, 0x04dbf, 2 },
{ 0x04e00, 0x0a48c, 2 },
{ 0x0a490, 0x0a4c6, 2 },
{ 0x0a66f, 0x0a672, 0 },
{ 0x0a67c, 0x0a67d, 0 },
{ 0x0a6f0, 0x0a6f1, 0 },
{ 0x0a802, 0x0a802, 0 },
{ 0x0a806, 0x0a806, 0 },
{ 0x0a80b, 0x0a80b, 0 },
{ 0x0a823, 0x0a827, 0 },
{ 0x0a880, 0x0a881, 0 },
{ 0x0a8b4, 0x0a8c4, 0 },
{ 0x0a8e0, 0x0a8f1, 0 },
{ 0x0a926, 0x0a92d, 0 },
{ 0x0a947, 0x0a953, 0 },
{ 0x0a960, 0x0a97c, 2 },
{ 0x0a980, 0x0a983, 0 },
{ 0x0a9b3, 0x0a9c0, 0 },
{ 0x0aa29, 0x0aa36, 0 },
{ 0x0aa43, 0x0aa43, 0 },
{ 0x0aa4c, 0x0aa4d, 0 },
{ 0x0aa7b, 0x0aa7b, 0 },
{ 0x0aab0, 0x0aab0, 0 },
{ 0x0aab2, 0x0aab4, 0 },
{ 0x0aab7, 0x0aab8, 0 },
{ 0x0aabe, 0x0aabf, 0 },
{ 0x0aac1, 0x0aac1, 0 },
{ 0x0abe3, 0x0abea, 0 },
{ 0x0abec, 0x0abed, 0 },
{ 0x0ac00, 0x0d7a3, 2 },
{ 0x0d7b0, 0x0d7c6, 2 },
{ 0x0d7cb, 0x0d7fb, 2 },
{ 0x0f900, 0x0faff, 2 },
{ 0x0fb1e, 0x0fb1e, 0 },
{ 0x0fe00, 0x0fe0f, 0 },
{ 0x0fe10, 0x0fe19, 2 },
{ 0x0fe20, 0x0fe26, 0 },
{ 0x0fe30, 0x0fe52, 2 },
{ 0x0fe54, 0x0fe66, 2 },
{ 0x0fe68, 0x0fe6b, 2 },
{ 0x0ff01, 0x0ff60, 2 },
{ 0x0ffe0, 0x0ffe6, 2 },
{ 0x101fd, 0x101fd, 0 },
{ 0x10a01, 0x10a03, 0 },
{ 0x10a05, 0x10a06, 0 },
{ 0x10a0c, 0x10a0f, 0 },
{ 0x10a38, 0x10a3a, 0 },
{ 0x10a3f, 0x10a3f, 0 },
{ 0x11080, 0x11082, 0 },
{ 0x110b0, 0x110ba, 0 },
{ 0x1d165, 0x1d169, 0 },
{ 0x1d16d, 0x1d172, 0 },
{ 0x1d17b, 0x1d182, 0 },
{ 0x1d185, 0x1d18b, 0 },
{ 0x1d1aa, 0x1d1ad, 0 },
{ 0x1d242, 0x1d244, 0 },
{ 0x1f200, 0x1f200, 2 },
{ 0x1f210, 0x1f231, 2 },
{ 0x1f240, 0x1f248, 2 },
{ 0x20000, 0x2fffd, 2 },
{ 0x30000, 0x3fffd, 2 },
{ 0xe0100, 0xe01ef, 0 }
{0x00300, 0x0036f, 0},
{0x00483, 0x00489, 0},
{0x00591, 0x005bd, 0},
{0x005bf, 0x005bf, 0},
{0x005c1, 0x005c2, 0},
{0x005c4, 0x005c5, 0},
{0x005c7, 0x005c7, 0},
{0x00610, 0x0061a, 0},
{0x0064b, 0x0065e, 0},
{0x00670, 0x00670, 0},
{0x006d6, 0x006dc, 0},
{0x006de, 0x006e4, 0},
{0x006e7, 0x006e8, 0},
{0x006ea, 0x006ed, 0},
{0x00711, 0x00711, 0},
{0x00730, 0x0074a, 0},
{0x007a6, 0x007b0, 0},
{0x007eb, 0x007f3, 0},
{0x00816, 0x00819, 0},
{0x0081b, 0x00823, 0},
{0x00825, 0x00827, 0},
{0x00829, 0x0082d, 0},
{0x00900, 0x00903, 0},
{0x0093c, 0x0093c, 0},
{0x0093e, 0x0094e, 0},
{0x00951, 0x00955, 0},
{0x00962, 0x00963, 0},
{0x00981, 0x00983, 0},
{0x009bc, 0x009bc, 0},
{0x009be, 0x009c4, 0},
{0x009c7, 0x009c8, 0},
{0x009cb, 0x009cd, 0},
{0x009d7, 0x009d7, 0},
{0x009e2, 0x009e3, 0},
{0x00a01, 0x00a03, 0},
{0x00a3c, 0x00a3c, 0},
{0x00a3e, 0x00a42, 0},
{0x00a47, 0x00a48, 0},
{0x00a4b, 0x00a4d, 0},
{0x00a51, 0x00a51, 0},
{0x00a70, 0x00a71, 0},
{0x00a75, 0x00a75, 0},
{0x00a81, 0x00a83, 0},
{0x00abc, 0x00abc, 0},
{0x00abe, 0x00ac5, 0},
{0x00ac7, 0x00ac9, 0},
{0x00acb, 0x00acd, 0},
{0x00ae2, 0x00ae3, 0},
{0x00b01, 0x00b03, 0},
{0x00b3c, 0x00b3c, 0},
{0x00b3e, 0x00b44, 0},
{0x00b47, 0x00b48, 0},
{0x00b4b, 0x00b4d, 0},
{0x00b56, 0x00b57, 0},
{0x00b62, 0x00b63, 0},
{0x00b82, 0x00b82, 0},
{0x00bbe, 0x00bc2, 0},
{0x00bc6, 0x00bc8, 0},
{0x00bca, 0x00bcd, 0},
{0x00bd7, 0x00bd7, 0},
{0x00c01, 0x00c03, 0},
{0x00c3e, 0x00c44, 0},
{0x00c46, 0x00c48, 0},
{0x00c4a, 0x00c4d, 0},
{0x00c55, 0x00c56, 0},
{0x00c62, 0x00c63, 0},
{0x00c82, 0x00c83, 0},
{0x00cbc, 0x00cbc, 0},
{0x00cbe, 0x00cc4, 0},
{0x00cc6, 0x00cc8, 0},
{0x00cca, 0x00ccd, 0},
{0x00cd5, 0x00cd6, 0},
{0x00ce2, 0x00ce3, 0},
{0x00d02, 0x00d03, 0},
{0x00d3e, 0x00d44, 0},
{0x00d46, 0x00d48, 0},
{0x00d4a, 0x00d4d, 0},
{0x00d57, 0x00d57, 0},
{0x00d62, 0x00d63, 0},
{0x00d82, 0x00d83, 0},
{0x00dca, 0x00dca, 0},
{0x00dcf, 0x00dd4, 0},
{0x00dd6, 0x00dd6, 0},
{0x00dd8, 0x00ddf, 0},
{0x00df2, 0x00df3, 0},
{0x00e31, 0x00e31, 0},
{0x00e34, 0x00e3a, 0},
{0x00e47, 0x00e4e, 0},
{0x00eb1, 0x00eb1, 0},
{0x00eb4, 0x00eb9, 0},
{0x00ebb, 0x00ebc, 0},
{0x00ec8, 0x00ecd, 0},
{0x00f18, 0x00f19, 0},
{0x00f35, 0x00f35, 0},
{0x00f37, 0x00f37, 0},
{0x00f39, 0x00f39, 0},
{0x00f3e, 0x00f3f, 0},
{0x00f71, 0x00f84, 0},
{0x00f86, 0x00f87, 0},
{0x00f90, 0x00f97, 0},
{0x00f99, 0x00fbc, 0},
{0x00fc6, 0x00fc6, 0},
{0x0102b, 0x0103e, 0},
{0x01056, 0x01059, 0},
{0x0105e, 0x01060, 0},
{0x01062, 0x01064, 0},
{0x01067, 0x0106d, 0},
{0x01071, 0x01074, 0},
{0x01082, 0x0108d, 0},
{0x0108f, 0x0108f, 0},
{0x0109a, 0x0109d, 0},
{0x01100, 0x0115f, 2},
{0x011a3, 0x011a7, 2},
{0x011fa, 0x011ff, 2},
{0x0135f, 0x0135f, 0},
{0x01712, 0x01714, 0},
{0x01732, 0x01734, 0},
{0x01752, 0x01753, 0},
{0x01772, 0x01773, 0},
{0x017b6, 0x017d3, 0},
{0x017dd, 0x017dd, 0},
{0x0180b, 0x0180d, 0},
{0x018a9, 0x018a9, 0},
{0x01920, 0x0192b, 0},
{0x01930, 0x0193b, 0},
{0x019b0, 0x019c0, 0},
{0x019c8, 0x019c9, 0},
{0x01a17, 0x01a1b, 0},
{0x01a55, 0x01a5e, 0},
{0x01a60, 0x01a7c, 0},
{0x01a7f, 0x01a7f, 0},
{0x01b00, 0x01b04, 0},
{0x01b34, 0x01b44, 0},
{0x01b6b, 0x01b73, 0},
{0x01b80, 0x01b82, 0},
{0x01ba1, 0x01baa, 0},
{0x01c24, 0x01c37, 0},
{0x01cd0, 0x01cd2, 0},
{0x01cd4, 0x01ce8, 0},
{0x01ced, 0x01ced, 0},
{0x01cf2, 0x01cf2, 0},
{0x01dc0, 0x01de6, 0},
{0x01dfd, 0x01dff, 0},
{0x020d0, 0x020f0, 0},
{0x02329, 0x0232a, 2},
{0x02cef, 0x02cf1, 0},
{0x02de0, 0x02dff, 0},
{0x02e80, 0x02e99, 2},
{0x02e9b, 0x02ef3, 2},
{0x02f00, 0x02fd5, 2},
{0x02ff0, 0x02ffb, 2},
{0x03000, 0x03029, 2},
{0x0302a, 0x0302f, 0},
{0x03030, 0x0303e, 2},
{0x03041, 0x03096, 2},
{0x03099, 0x0309a, 0},
{0x0309b, 0x030ff, 2},
{0x03105, 0x0312d, 2},
{0x03131, 0x0318e, 2},
{0x03190, 0x031b7, 2},
{0x031c0, 0x031e3, 2},
{0x031f0, 0x0321e, 2},
{0x03220, 0x03247, 2},
{0x03250, 0x032fe, 2},
{0x03300, 0x04dbf, 2},
{0x04e00, 0x0a48c, 2},
{0x0a490, 0x0a4c6, 2},
{0x0a66f, 0x0a672, 0},
{0x0a67c, 0x0a67d, 0},
{0x0a6f0, 0x0a6f1, 0},
{0x0a802, 0x0a802, 0},
{0x0a806, 0x0a806, 0},
{0x0a80b, 0x0a80b, 0},
{0x0a823, 0x0a827, 0},
{0x0a880, 0x0a881, 0},
{0x0a8b4, 0x0a8c4, 0},
{0x0a8e0, 0x0a8f1, 0},
{0x0a926, 0x0a92d, 0},
{0x0a947, 0x0a953, 0},
{0x0a960, 0x0a97c, 2},
{0x0a980, 0x0a983, 0},
{0x0a9b3, 0x0a9c0, 0},
{0x0aa29, 0x0aa36, 0},
{0x0aa43, 0x0aa43, 0},
{0x0aa4c, 0x0aa4d, 0},
{0x0aa7b, 0x0aa7b, 0},
{0x0aab0, 0x0aab0, 0},
{0x0aab2, 0x0aab4, 0},
{0x0aab7, 0x0aab8, 0},
{0x0aabe, 0x0aabf, 0},
{0x0aac1, 0x0aac1, 0},
{0x0abe3, 0x0abea, 0},
{0x0abec, 0x0abed, 0},
{0x0ac00, 0x0d7a3, 2},
{0x0d7b0, 0x0d7c6, 2},
{0x0d7cb, 0x0d7fb, 2},
{0x0f900, 0x0faff, 2},
{0x0fb1e, 0x0fb1e, 0},
{0x0fe00, 0x0fe0f, 0},
{0x0fe10, 0x0fe19, 2},
{0x0fe20, 0x0fe26, 0},
{0x0fe30, 0x0fe52, 2},
{0x0fe54, 0x0fe66, 2},
{0x0fe68, 0x0fe6b, 2},
{0x0ff01, 0x0ff60, 2},
{0x0ffe0, 0x0ffe6, 2},
{0x101fd, 0x101fd, 0},
{0x10a01, 0x10a03, 0},
{0x10a05, 0x10a06, 0},
{0x10a0c, 0x10a0f, 0},
{0x10a38, 0x10a3a, 0},
{0x10a3f, 0x10a3f, 0},
{0x11080, 0x11082, 0},
{0x110b0, 0x110ba, 0},
{0x1d165, 0x1d169, 0},
{0x1d16d, 0x1d172, 0},
{0x1d17b, 0x1d182, 0},
{0x1d185, 0x1d18b, 0},
{0x1d1aa, 0x1d1ad, 0},
{0x1d242, 0x1d244, 0},
{0x1f200, 0x1f200, 2},
{0x1f210, 0x1f231, 2},
{0x1f240, 0x1f248, 2},
{0x20000, 0x2fffd, 2},
{0x30000, 0x3fffd, 2},
{0xe0100, 0xe01ef, 0}
};
/* Get the width of a UTF-8 character. */
int
utf8_width (char *s)
int utf8_width(char *s)
{
int val, low, high, cur;
if (UTF8_ISCONT (*s))
if (UTF8_ISCONT(*s))
return 0;
switch (UTF8_LENGTH (*s))
{
case 1:
val = s[0];
break;
case 2:
val = (s[1] & 0x3f) | (s[0] & 0x1f) << 6;
break;
case 3:
val = ((s[2] & 0x3f) | (s[1] & 0x3f) << 6) |
(s[0] & 0x0f) << 12;
break;
case 4:
val = (((s[3] & 0x3f) | (s[2] & 0x3f) << 6) |
(s[1] & 0x3f) << 12) | (s[0] & 0x3f) << 18;
break;
case 5:
val = ((((s[4] & 0x3f) | (s[3] & 0x3f) << 6) |
(s[2] & 0x3f) << 12) | (s[1] & 0x3f) << 18) |
(s[0] & 0x3f) << 24;
break;
case 6:
val = (((((s[5] & 0x3f) | (s[4] & 0x3f) << 6) |
(s[3] & 0x3f) << 12) | (s[2] & 0x3f) << 18) |
(s[1] & 0x3f) << 24) | (s[0] & 0x3f) << 30;
break;
default:
return 0;
}
switch (UTF8_LENGTH(*s)) {
case 1:
val = s[0];
break;
case 2:
val = (s[1] & 0x3f) | (s[0] & 0x1f) << 6;
break;
case 3:
val = ((s[2] & 0x3f) | (s[1] & 0x3f) << 6) | (s[0] & 0x0f) << 12;
break;
case 4:
val = (((s[3] & 0x3f) | (s[2] & 0x3f) << 6) |
(s[1] & 0x3f) << 12) | (s[0] & 0x3f) << 18;
break;
case 5:
val = ((((s[4] & 0x3f) | (s[3] & 0x3f) << 6) |
(s[2] & 0x3f) << 12) | (s[1] & 0x3f) << 18) | (s[0] & 0x3f) << 24;
break;
case 6:
val = (((((s[5] & 0x3f) | (s[4] & 0x3f) << 6) |
(s[3] & 0x3f) << 12) | (s[2] & 0x3f) << 18) |
(s[1] & 0x3f) << 24) | (s[0] & 0x3f) << 30;
break;
default:
return 0;
}
low = 0;
high = sizeof(utf8_widthtab) / sizeof(utf8_widthtab[0]);
do
{
cur = (low + high) / 2;
if (val >= utf8_widthtab[cur].min)
{
if (val <= utf8_widthtab[cur].max)
return utf8_widthtab[cur].width;
else
low = cur + 1;
}
do {
cur = (low + high) / 2;
if (val >= utf8_widthtab[cur].min) {
if (val <= utf8_widthtab[cur].max)
return utf8_widthtab[cur].width;
else
high = cur - 1;
}
low = cur + 1;
} else
high = cur - 1;
}
while (low <= high);
return 1;
}
/* Get the width of a UTF-8 string. */
int
utf8_strwidth (char *s)
int utf8_strwidth(char *s)
{
int width = 0;
for (; s && *s; s++)
{
if (!UTF8_ISCONT (*s))
width += utf8_width (s);
}
for (; s && *s; s++) {
if (!UTF8_ISCONT(*s))
width += utf8_width(s);
}
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
*/
int days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
const char *monthnames[12] = {
N_("January"),
N_("February"),
@ -120,8 +121,7 @@ struct dmon_conf dmon;
/*
* Variables init
*/
void
vars_init (void)
void vars_init(void)
{
const char *ed, *pg;
@ -133,33 +133,33 @@ vars_init (void)
conf.periodic_save = 0;
conf.system_dialogs = 1;
conf.progress_bar = 1;
strncpy (conf.output_datefmt, "%D", 3);
strncpy(conf.output_datefmt, "%D", 3);
conf.input_datefmt = 1;
/* Default external editor and pager */
ed = getenv ("VISUAL");
ed = getenv("VISUAL");
if (ed == NULL || ed[0] == '\0')
ed = getenv ("EDITOR");
ed = getenv("EDITOR");
if (ed == NULL || ed[0] == '\0')
ed = DEFAULT_EDITOR;
conf.editor = ed;
pg = getenv ("PAGER");
pg = getenv("PAGER");
if (pg == NULL || pg[0] == '\0')
pg = DEFAULT_PAGER;
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 */
apad.length = 1;
apad.first_onscreen = 0;
/* Attribute definitions for color and non-color terminals */
custom_init_attr ();
custom_init_attr();
/* 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.
*/
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 pid;
if (pfdin && (pipe (pin) == -1))
if (pfdin && (pipe(pin) == -1))
return 0;
if (pfdout && (pipe (pout) == -1))
if (pfdout && (pipe(pout) == -1))
return 0;
if ((pid = fork ()) == 0)
{
if (pfdout)
{
if (dup2 (pout[0], STDIN_FILENO) < 0)
_exit (127);
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);
if ((pid = fork()) == 0) {
if (pfdout) {
if (dup2(pout[0], STDIN_FILENO) < 0)
_exit(127);
close(pout[0]);
close(pout[1]);
}
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;
}
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) {
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;
}
/* Wait for a child process to terminate. */
static int
child_wait (int *pfdin, int *pfdout, int pid)
static int child_wait(int *pfdin, int *pfdout, int pid)
{
int stat;
if (pfdin)
close (*pfdin);
close(*pfdin);
if (pfdout)
close (*pfdout);
close(*pfdout);
waitpid (pid, &stat, 0);
waitpid(pid, &stat, 0);
return stat;
}
/* Print error message and bail out. */
static void
die (const char *format, ...)
static void die(const char *format, ...)
{
va_list arg;
va_start (arg, format);
fprintf (stderr, "error: ");
vfprintf (stderr, format, arg);
va_end (arg);
va_start(arg, format);
fprintf(stderr, "error: ");
vfprintf(stderr, format, arg);
va_end(arg);
exit (1);
exit(1);
}
/* Print usage message. */
static void
usage (void)
static 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. */
static int
run_test (const char *name, int expect_failure)
static int run_test(const char *name, int expect_failure)
{
char filename[BUFSIZ];
char *arg1[3], *arg2[3];
@ -160,93 +146,84 @@ run_test (const char *name, int expect_failure)
char buf1[BUFSIZ], buf2[BUFSIZ];
int ret = 1;
if (snprintf (filename, BUFSIZ, "./%s", name) >= BUFSIZ)
die ("file name too long\n");
if (snprintf(filename, BUFSIZ, "./%s", name) >= BUFSIZ)
die("file name too long\n");
if (access (filename, F_OK) != 0)
{
if (snprintf (filename, BUFSIZ, "./%s.sh", name) >= BUFSIZ)
die ("file name too long\n");
if (access(filename, F_OK) != 0) {
if (snprintf(filename, BUFSIZ, "./%s.sh", name) >= BUFSIZ)
die("file name too long\n");
if (access (filename, F_OK) != 0)
die ("test not found: %s\n", name);
}
if (access(filename, F_OK) != 0)
die("test not found: %s\n", name);
}
if (access (filename, X_OK) != 0)
die ("script is not executable: %s\n", filename);
if (access(filename, X_OK) != 0)
die("script is not executable: %s\n", filename);
arg1[0] = arg2[0] = filename;
arg1[1] = "expected";
arg2[1] = "actual";
arg1[2] = arg2[2] = NULL;
printf ("Running %s...", name);
printf("Running %s...", name);
if ((pid1 = fork_exec (&pin1, NULL, *arg1, arg1)) < 0)
die("failed to execute %s: %s\n", filename, strerror (errno));
if ((pid1 = fork_exec(&pin1, NULL, *arg1, arg1)) < 0)
die("failed to execute %s: %s\n", filename, strerror(errno));
if ((pid2 = fork_exec (&pin2, NULL, *arg2, arg2)) < 0)
die("failed to execute %s: %s\n", filename, strerror (errno));
if ((pid2 = fork_exec(&pin2, NULL, *arg2, arg2)) < 0)
die("failed to execute %s: %s\n", filename, strerror(errno));
fpin1 = fdopen (pin1, "r");
fpin2 = fdopen (pin2, "r");
fpin1 = fdopen(pin1, "r");
fpin2 = fdopen(pin2, "r");
while (fgets (buf1, BUFSIZ, fpin1))
{
if (!fgets (buf2, BUFSIZ, fpin2) || strcmp (buf1, buf2) != 0)
{
ret = 0;
break;
}
while (fgets(buf1, BUFSIZ, fpin1)) {
if (!fgets(buf2, BUFSIZ, fpin2) || strcmp(buf1, buf2) != 0) {
ret = 0;
break;
}
}
if (fpin1)
fclose (fpin1);
fclose(fpin1);
if (fpin2)
fclose (fpin2);
fclose(fpin2);
if (child_wait (&pin1, NULL, pid1) != 0)
if (child_wait(&pin1, NULL, pid1) != 0)
ret = 0;
if (child_wait (&pin2, NULL, pid2) != 0)
if (child_wait(&pin2, NULL, pid2) != 0)
ret = 0;
if (expect_failure)
ret = 1 - ret;
if (ret == 1)
printf (" ok\n");
printf(" ok\n");
else
printf (" FAIL\n");
printf(" FAIL\n");
return ret;
}
int
main (int argc, char **argv)
int main(int argc, char **argv)
{
int i;
if (!argv[1])
die ("no tests specified, bailing out\n");
else if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0)
{
usage();
return 0;
}
die("no tests specified, bailing out\n");
else if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
usage();
return 0;
}
for (i = 1; i < argc; i++)
{
if (*argv[i] == '!')
{
if (!run_test (argv[i] + 1, 1))
return 1;
}
else
{
if (!run_test (argv[i], 0))
return 1;
}
for (i = 1; i < argc; i++) {
if (*argv[i] == '!') {
if (!run_test(argv[i] + 1, 1))
return 1;
} else {
if (!run_test(argv[i], 0))
return 1;
}
}
return 0;
}