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

Use generic lists for recurring apointments and events.

Browse Source 
Use them instead of "recur_apoint_list" and "next" pointers in
"recur_event" type variables. Includes some code simplifications and
cleanups.

Signed-off-by: Lukas Fleischer <calcurse@cryptocrack.de>
This commit is contained in:
Lukas Fleischer 2011-04-16 15:20:42 +02:00
parent 2438470fd3
commit 9fab24818a
5 changed files with 372 additions and 465 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
src/args.c
View File

@ -352,8 +352,6 @@ app_arg (int add_line, struct date *day, long date, int print_note,
struct conf *conf, regex_t *regex)
{
llist_item_t *i;
struct recur_event *re;
struct recur_apoint *ra;
long today;
unsigned print_date = 1;
int app_found = 0;
@ -370,31 +368,28 @@ app_arg (int add_line, struct date *day, long date, int print_note,
* that date and it is the first one, and then print all the events for
* that date.
*/
for (re = recur_elist; re != NULL; re = re->next)
LLIST_FIND_FOREACH (&recur_elist, today, recur_event_inday, i)
{
if (recur_item_inday (re->day, re->exc, re->rpt->type, re->rpt->freq,
re->rpt->until, today))
{
if (regex && regexec (regex, re->mesg, 0, 0, 0) != 0)
continue;
struct recur_event *re = LLIST_GET_DATA (i);
if (regex && regexec (regex, re->mesg, 0, 0, 0) != 0)
continue;
app_found = 1;
if (add_line)
{
fputs ("\n", stdout);
add_line = 0;
}
if (print_date)
{
arg_print_date (today, conf);
print_date = 0;
}
fputs (" * ", stdout);
fputs (re->mesg, stdout);
app_found = 1;
if (add_line)
{
fputs ("\n", stdout);
if (print_note && re->note)
print_notefile (stdout, re->note, 2);
add_line = 0;
}
if (print_date)
{
arg_print_date (today, conf);
print_date = 0;
}
fputs (" * ", stdout);
fputs (re->mesg, stdout);
fputs ("\n", stdout);
if (print_note && re->note)
print_notefile (stdout, re->note, 2);
}
LLIST_FIND_FOREACH (&eventlist, today, event_inday, i)
@ -422,45 +417,42 @@ app_arg (int add_line, struct date *day, long date, int print_note,
}
/* Same process is performed but this time on the appointments. */
pthread_mutex_lock (&(recur_alist_p->mutex));
for (ra = recur_alist_p->root; ra != NULL; ra = ra->next)
LLIST_TS_LOCK (&recur_alist_p);
LLIST_TS_FIND_FOREACH (&recur_alist_p, today, recur_apoint_inday, i)
{
if (recur_item_inday (ra->start, ra->exc, ra->rpt->type, ra->rpt->freq,
ra->rpt->until, today))
struct recur_apoint *ra = LLIST_TS_GET_DATA (i);
struct apoint *apt;
if (regex && regexec (regex, ra->mesg, 0, 0, 0) != 0)
continue;
app_found = 1;
if (add_line)
{
struct apoint *apt;
if (regex && regexec (regex, ra->mesg, 0, 0, 0) != 0)
continue;
app_found = 1;
if (add_line)
{
fputs ("\n", stdout);
add_line = 0;
}
if (print_date)
{
arg_print_date (today, conf);
print_date = 0;
}
apt = apoint_recur_s2apoint_s (ra);
apoint_sec2str (apt, RECUR_APPT, today, apoint_start_time,
apoint_end_time);
mem_free (apt->mesg);
mem_free (apt);
fputs (" - ", stdout);
fputs (apoint_start_time, stdout);
fputs (" -> ", stdout);
fputs (apoint_end_time, stdout);
fputs ("\n\t", stdout);
fputs (ra->mesg, stdout);
fputs ("\n", stdout);
if (print_note && ra->note)
print_notefile (stdout, ra->note, 2);
add_line = 0;
}
if (print_date)
{
arg_print_date (today, conf);
print_date = 0;
}
apt = apoint_recur_s2apoint_s (ra);
apoint_sec2str (apt, RECUR_APPT, today, apoint_start_time,
apoint_end_time);
mem_free (apt->mesg);
mem_free (apt);
fputs (" - ", stdout);
fputs (apoint_start_time, stdout);
fputs (" -> ", stdout);
fputs (apoint_end_time, stdout);
fputs ("\n\t", stdout);
fputs (ra->mesg, stdout);
fputs ("\n", stdout);
if (print_note && ra->note)
print_notefile (stdout, ra->note, 2);
}
pthread_mutex_unlock (&(recur_alist_p->mutex));
LLIST_TS_UNLOCK (&recur_alist_p);
LLIST_TS_LOCK (&alist_p);
LLIST_TS_FIND_FOREACH (&alist_p, today, apoint_inday, i)

11
src/calcurse.h
View File

@ -334,15 +334,8 @@ struct recur_apoint {
char *note; /* note attached to appointment */
};
/* Recurrent appointments are stored in a linked-list. */
struct recur_apoint_list {
struct recur_apoint *root;
pthread_mutex_t mutex;
};
/* Reccurent event definition. */
struct recur_event {
struct recur_event *next;
struct rpt *rpt; /* information about repetition */
struct days *exc; /* days when the item should not be repeated */
int id; /* event type */
@ -768,8 +761,8 @@ int notify_same_recur_item (struct recur_apoint *);
void notify_config_bar (void);
/* recur.c */
extern struct recur_apoint_list *recur_alist_p;
extern struct recur_event *recur_elist;
extern llist_ts_t recur_alist_p;
extern llist_t recur_elist;
void recur_event_free_bkp (enum eraseflg);
void recur_apoint_free_bkp (enum eraseflg);
void recur_apoint_llist_init (void);

94
src/day.c
View File

@ -168,17 +168,15 @@ day_store_events (long date)
static int
day_store_recur_events (long date)
{
struct recur_event *j;
llist_item_t *i;
int e_nb = 0;
for (j = recur_elist; j != NULL; j = j->next)
LLIST_FIND_FOREACH (&recur_elist, date, recur_event_inday, i)
{
if (recur_item_inday (j->day, j->exc, j->rpt->type, j->rpt->freq,
j->rpt->until, date))
{
e_nb++;
(void)day_add_event (RECUR_EVNT, j->mesg, j->note, j->day, j->id);
}
struct recur_event *rev = LLIST_TS_GET_DATA (i);
(void)day_add_event (RECUR_EVNT, rev->mesg, rev->note, rev->day,
rev->id);
e_nb++;
}
return e_nb;
@ -213,31 +211,26 @@ day_store_apoints (long date)
/*
* Store the recurrent apoints for the selected day in structure pointed
* by day_items. This is done by copying the appointments
* from the general structure pointed by recur_alist_p->root to the
* from the general structure pointed by recur_alist_p to the
* structure dedicated to the selected day.
* Returns the number of recurrent appointments for the selected day.
*/
static int
day_store_recur_apoints (long date)
{
struct recur_apoint *j;
long real_start;
int a_nb = 0, n = 0;
llist_item_t *i;
int a_nb = 0;
pthread_mutex_lock (&(recur_alist_p->mutex));
for (j = recur_alist_p->root; j != NULL; j = j->next)
LLIST_TS_LOCK (&recur_alist_p);
LLIST_TS_FIND_FOREACH (&recur_alist_p, date, recur_apoint_inday, i)
{
if ((real_start = recur_item_inday (j->start, j->exc,
j->rpt->type, j->rpt->freq,
j->rpt->until, date)))
{
a_nb++;
(void)day_add_apoint (RECUR_APPT, j->mesg, j->note,
real_start, j->dur, j->state, n);
n++;
}
struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
int real_start = recur_apoint_inday (rapt, date);
(void)day_add_apoint (RECUR_APPT, rapt->mesg, rapt->note, real_start,
rapt->dur, rapt->state, a_nb);
a_nb++;
}
pthread_mutex_unlock (&(recur_alist_p->mutex));
LLIST_TS_UNLOCK (&recur_alist_p);
return a_nb;
}
@ -467,24 +460,18 @@ day_popup_item (void)
int
day_check_if_item (struct date day)
{
struct recur_event *re;
struct recur_apoint *ra;
const long date = date2sec (day, 0, 0);
for (re = recur_elist; re != NULL; re = re->next)
if (recur_item_inday (re->day, re->exc, re->rpt->type,
re->rpt->freq, re->rpt->until, date))
return (1);
if (LLIST_FIND_FIRST (&recur_elist, date, recur_event_inday))
return (1);
pthread_mutex_lock (&(recur_alist_p->mutex));
for (ra = recur_alist_p->root; ra != NULL; ra = ra->next)
if (recur_item_inday (ra->start, ra->exc, ra->rpt->type,
ra->rpt->freq, ra->rpt->until, date))
{
pthread_mutex_unlock (&(recur_alist_p->mutex));
return (1);
}
pthread_mutex_unlock (&(recur_alist_p->mutex));
LLIST_TS_LOCK (&recur_alist_p);
if (LLIST_TS_FIND_FIRST (&recur_alist_p, date, recur_apoint_inday))
{
LLIST_TS_UNLOCK (&recur_alist_p);
return (1);
}
LLIST_TS_UNLOCK (&recur_alist_p);
if (LLIST_FIND_FIRST (&eventlist, date, event_inday))
return (1);
@ -526,7 +513,6 @@ unsigned
day_chk_busy_slices (struct date day, int slicesno, int *slices)
{
llist_item_t *i;
struct recur_apoint *ra;
int slicelen;
const long date = date2sec (day, 0, 0);
@ -534,22 +520,20 @@ day_chk_busy_slices (struct date day, int slicesno, int *slices)
#define SLICENUM(tsec) ((tsec) / slicelen % slicesno)
pthread_mutex_lock (&(recur_alist_p->mutex));
for (ra = recur_alist_p->root; ra != NULL; ra = ra->next)
if (recur_item_inday (ra->start, ra->exc, ra->rpt->type,
ra->rpt->freq, ra->rpt->until, date))
{
long start, end;
LLIST_TS_LOCK (&recur_alist_p);
LLIST_TS_FIND_FOREACH (&recur_alist_p, date, recur_apoint_inday, i)
{
struct apoint *rapt = LLIST_TS_GET_DATA (i);
long start = get_item_time (rapt->start);
long end = get_item_time (rapt->start + rapt->dur);
start = get_item_time (ra->start);
end = get_item_time (ra->start + ra->dur);
if (!fill_slices (slices, slicesno, SLICENUM (start), SLICENUM (end)))
{
pthread_mutex_unlock (&(recur_alist_p->mutex));
return 0;
}
}
pthread_mutex_unlock (&(recur_alist_p->mutex));
if (!fill_slices (slices, slicesno, SLICENUM (start), SLICENUM (end)))
{
LLIST_TS_UNLOCK (&recur_alist_p);
return 0;
}
}
LLIST_TS_UNLOCK (&recur_alist_p);
LLIST_TS_LOCK (&alist_p);
LLIST_TS_FIND_FOREACH (&alist_p, date, apoint_inday, i)

125
src/io.c
View File

@ -342,31 +342,32 @@ pcal_export_footer (FILE *stream)
static void
ical_export_recur_events (FILE *stream)
{
struct recur_event *i;
llist_item_t *i;
struct days *day;
char ical_date[BUFSIZ];
for (i = recur_elist; i != NULL; i = i->next)
LLIST_FOREACH (&recur_elist, i)
{
date_sec2date_fmt (i->day, ICALDATEFMT, ical_date);
struct recur_event *rev = LLIST_GET_DATA (i);
date_sec2date_fmt (rev->day, ICALDATEFMT, ical_date);
(void)fprintf (stream, "BEGIN:VEVENT\n");
(void)fprintf (stream, "DTSTART:%s\n", ical_date);
(void)fprintf (stream, "RRULE:FREQ=%s;INTERVAL=%d",
ical_recur_type[i->rpt->type], i->rpt->freq);
ical_recur_type[rev->rpt->type], rev->rpt->freq);
if (i->rpt->until != 0)
if (rev->rpt->until != 0)
{
date_sec2date_fmt (i->rpt->until, ICALDATEFMT, ical_date);
date_sec2date_fmt (rev->rpt->until, ICALDATEFMT, ical_date);
(void)fprintf (stream, ";UNTIL=%s\n", ical_date);
}
else
(void)fprintf (stream, "\n");
if (i->exc != NULL)
if (rev->exc != NULL)
{
date_sec2date_fmt (i->exc->st, ICALDATEFMT, ical_date);
date_sec2date_fmt (rev->exc->st, ICALDATEFMT, ical_date);
(void)fprintf (stream, "EXDATE:%s", ical_date);
for (day = i->exc->next; day; day = day->next)
for (day = rev->exc->next; day; day = day->next)
{
date_sec2date_fmt (day->st, ICALDATEFMT, ical_date);
(void)fprintf (stream, ",%s", ical_date);
@ -374,7 +375,7 @@ ical_export_recur_events (FILE *stream)
(void)fprintf (stream, "\n");
}
(void)fprintf (stream, "SUMMARY:%s\n", i->mesg);
(void)fprintf (stream, "SUMMARY:%s\n", rev->mesg);
(void)fprintf (stream, "END:VEVENT\n");
}
}
@ -407,7 +408,7 @@ pcal_dump_apoint (FILE *stream, long apoint_date, long apoint_dur,
static void
pcal_export_recur_events (FILE *stream)
{
struct recur_event *i;
llist_item_t *i;
char pcal_date[BUFSIZ];
(void)fprintf (stream, "\n# =============");
@ -416,30 +417,32 @@ pcal_export_recur_events (FILE *stream)
(void)fprintf (stream,
"# (pcal does not support from..until dates specification\n");
for (i = recur_elist; i != NULL; i = i->next)
LLIST_FOREACH (&recur_elist, i)
{
if (i->rpt->until == 0 && i->rpt->freq == 1)
struct recur_event *rev = LLIST_GET_DATA (i);
if (rev->rpt->until == 0 && rev->rpt->freq == 1)
{
switch (i->rpt->type)
switch (rev->rpt->type)
{
case RECUR_DAILY:
date_sec2date_fmt (i->day, "%b %d", pcal_date);
date_sec2date_fmt (rev->day, "%b %d", pcal_date);
(void)fprintf (stream, "all day on_or_after %s %s\n",
pcal_date, i->mesg);
pcal_date, rev->mesg);
break;
case RECUR_WEEKLY:
date_sec2date_fmt (i->day, "%a", pcal_date);
date_sec2date_fmt (rev->day, "%a", pcal_date);
(void)fprintf (stream, "all %s on_or_after ", pcal_date);
date_sec2date_fmt (i->day, "%b %d", pcal_date);
(void)fprintf (stream, "%s %s\n", pcal_date, i->mesg);
date_sec2date_fmt (rev->day, "%b %d", pcal_date);
(void)fprintf (stream, "%s %s\n", pcal_date, rev->mesg);
break;
case RECUR_MONTHLY:
date_sec2date_fmt (i->day, "%d", pcal_date);
(void)fprintf (stream, "day on all %s %s\n", pcal_date, i->mesg);
date_sec2date_fmt (rev->day, "%d", pcal_date);
(void)fprintf (stream, "day on all %s %s\n", pcal_date,
rev->mesg);
break;
case RECUR_YEARLY:
date_sec2date_fmt (i->day, "%b %d", pcal_date);
(void)fprintf (stream, "%s %s\n", pcal_date, i->mesg);
date_sec2date_fmt (rev->day, "%b %d", pcal_date);
(void)fprintf (stream, "%s %s\n", pcal_date, rev->mesg);
break;
default:
EXIT (_("incoherent repetition type"));
@ -450,9 +453,9 @@ pcal_export_recur_events (FILE *stream)
const long YEAR_START = calendar_start_of_year ();
const long YEAR_END = calendar_end_of_year ();
if (i->day < YEAR_END && i->day > YEAR_START)
foreach_date_dump (YEAR_END, i->rpt, i->exc, i->day, 0, i->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);
}
}
}
@ -493,34 +496,37 @@ pcal_export_events (FILE *stream)
static void
ical_export_recur_apoints (FILE *stream)
{
struct recur_apoint *i;
llist_item_t *i;
struct days *day;
char ical_datetime[BUFSIZ];
char ical_date[BUFSIZ];
pthread_mutex_lock (&(recur_alist_p->mutex));
for (i = recur_alist_p->root; i != NULL; i = i->next)
LLIST_TS_LOCK (&recur_alist_p);
LLIST_TS_FOREACH (&recur_alist_p, i)
{
date_sec2date_fmt (i->start, ICALDATETIMEFMT, ical_datetime);
struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
date_sec2date_fmt (rapt->start, ICALDATETIMEFMT, ical_datetime);
(void)fprintf (stream, "BEGIN:VEVENT\n");
(void)fprintf (stream, "DTSTART:%s\n", ical_datetime);
(void)fprintf (stream, "DURATION:PT0H0M%ldS\n", i->dur);
(void)fprintf (stream, "DURATION:PT0H0M%ldS\n", rapt->dur);
(void)fprintf (stream, "RRULE:FREQ=%s;INTERVAL=%d",
ical_recur_type[i->rpt->type], i->rpt->freq);
ical_recur_type[rapt->rpt->type], rapt->rpt->freq);
if (i->rpt->until != 0)
if (rapt->rpt->until != 0)
{
date_sec2date_fmt (i->rpt->until + HOURINSEC, ICALDATEFMT, ical_date);
date_sec2date_fmt (rapt->rpt->until + HOURINSEC, ICALDATEFMT,
ical_date);
(void)fprintf (stream, ";UNTIL=%s\n", ical_date);
}
else
(void)fprintf (stream, "\n");
if (i->exc != NULL)
if (rapt->exc != NULL)
{
date_sec2date_fmt (i->exc->st, ICALDATEFMT, ical_date);
date_sec2date_fmt (rapt->exc->st, ICALDATEFMT, ical_date);
(void)fprintf (stream, "EXDATE:%s", ical_date);
for (day = i->exc->next; day; day = day->next)
for (day = rapt->exc->next; day; day = day->next)
{
date_sec2date_fmt (day->st, ICALDATEFMT, ical_date);
(void)fprintf (stream, ",%s", ical_date);
@ -528,18 +534,18 @@ ical_export_recur_apoints (FILE *stream)
(void)fprintf (stream, "\n");
}
(void)fprintf (stream, "SUMMARY:%s\n", i->mesg);
if (i->state & APOINT_NOTIFY)
(void)fprintf (stream, "SUMMARY:%s\n", rapt->mesg);
if (rapt->state & APOINT_NOTIFY)
ical_export_valarm (stream);
(void)fprintf (stream, "END:VEVENT\n");
}
pthread_mutex_unlock (&(recur_alist_p->mutex));
LLIST_TS_UNLOCK (&recur_alist_p);
}
static void
pcal_export_recur_apoints (FILE *stream)
{
struct recur_apoint *i;
llist_item_t *i;
char pcal_date[BUFSIZ], pcal_beg[BUFSIZ], pcal_end[BUFSIZ];
(void)fprintf (stream, "\n# ==============");
@ -548,35 +554,37 @@ pcal_export_recur_apoints (FILE *stream)
(void)fprintf (stream,
"# (pcal does not support from..until dates specification\n");
for (i = recur_alist_p->root; i != NULL; i = i->next)
LLIST_TS_FOREACH (&recur_alist_p, i)
{
if (i->rpt->until == 0 && i->rpt->freq == 1)
struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
if (rapt->rpt->until == 0 && rapt->rpt->freq == 1)
{
date_sec2date_fmt (i->start, "%R", pcal_beg);
date_sec2date_fmt (i->start + i->dur, "%R", pcal_end);
switch (i->rpt->type)
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 (i->start, "%b %d", pcal_date);
date_sec2date_fmt (rapt->start, "%b %d", pcal_date);
(void)fprintf (stream, "all day on_or_after %s (%s -> %s) %s\n",
pcal_date, pcal_beg, pcal_end, i->mesg);
pcal_date, pcal_beg, pcal_end, rapt->mesg);
break;
case RECUR_WEEKLY:
date_sec2date_fmt (i->start, "%a", pcal_date);
date_sec2date_fmt (rapt->start, "%a", pcal_date);
(void)fprintf (stream, "all %s on_or_after ", pcal_date);
date_sec2date_fmt (i->start, "%b %d", pcal_date);
date_sec2date_fmt (rapt->start, "%b %d", pcal_date);
(void)fprintf (stream, "%s (%s -> %s) %s\n", pcal_date,
pcal_beg, pcal_end, i->mesg);
pcal_beg, pcal_end, rapt->mesg);
break;
case RECUR_MONTHLY:
date_sec2date_fmt (i->start, "%d", pcal_date);
date_sec2date_fmt (rapt->start, "%d", pcal_date);
(void)fprintf (stream, "day on all %s (%s -> %s) %s\n",
pcal_date, pcal_beg, pcal_end, i->mesg);
pcal_date, pcal_beg, pcal_end, rapt->mesg);
break;
case RECUR_YEARLY:
date_sec2date_fmt (i->start, "%b %d", pcal_date);
date_sec2date_fmt (rapt->start, "%b %d", pcal_date);
(void)fprintf (stream, "%s (%s -> %s) %s\n", pcal_date,
pcal_beg, pcal_end, i->mesg);
pcal_beg, pcal_end, rapt->mesg);
break;
default:
EXIT (_("incoherent repetition type"));
@ -587,9 +595,10 @@ pcal_export_recur_apoints (FILE *stream)
const long YEAR_START = calendar_start_of_year ();
const long YEAR_END = calendar_end_of_year ();
if (i->start < YEAR_END && i->start > YEAR_START)
foreach_date_dump (YEAR_END, i->rpt, i->exc, i->start, i->dur,
i->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);
}
}
}

501
src/recur.c
View File

@ -42,10 +42,10 @@
#include "calcurse.h"
struct recur_apoint_list *recur_alist_p;
struct recur_event *recur_elist;
static struct recur_event bkp_cut_recur_event;
static struct recur_apoint bkp_cut_recur_apoint;
llist_ts_t recur_alist_p;
llist_t recur_elist;
static struct recur_event bkp_cut_recur_event;
static struct recur_apoint bkp_cut_recur_apoint;
static void
@ -179,58 +179,65 @@ recur_apoint_dup (struct recur_apoint *in, struct recur_apoint *bkp)
void
recur_apoint_llist_init (void)
{
recur_alist_p = mem_malloc (sizeof (struct recur_apoint_list));
recur_alist_p->root = NULL;
pthread_mutex_init (&(recur_alist_p->mutex), NULL);
LLIST_TS_INIT (&recur_alist_p);
}
static void
recur_apoint_free (struct recur_apoint *rapt)
{
mem_free (rapt->mesg);
if (rapt->note)
mem_free (rapt->note);
if (rapt->rpt)
mem_free (rapt->rpt);
if (rapt->exc)
{
free_exc (rapt->exc);
rapt->exc = 0;
}
mem_free (rapt);
}
static void
recur_event_free (struct recur_event *rev)
{
mem_free (rev->mesg);
if (rev->note)
mem_free (rev->note);
if (rev->rpt)
mem_free (rev->rpt);
if (rev->exc)
{
free_exc (rev->exc);
rev->exc = 0;
}
mem_free (rev);
}
void
recur_apoint_llist_free (void)
{
struct recur_apoint *o, **i;
i = &recur_alist_p->root;
while (*i)
{
o = *i;
*i = o->next;
mem_free (o->mesg);
if (o->note)
mem_free (o->note);
if (o->rpt)
mem_free (o->rpt);
if (o->exc)
{
free_exc (o->exc);
o->exc = 0;
}
mem_free (o);
}
mem_free (recur_alist_p);
LLIST_TS_FREE_INNER (&recur_alist_p, recur_apoint_free);
LLIST_TS_FREE (&recur_alist_p);
}
void
recur_event_llist_free (void)
{
struct recur_event *o, **i;
LLIST_FREE_INNER (&recur_elist, recur_event_free);
LLIST_FREE (&recur_elist);
}
i = &recur_elist;
while (*i)
{
o = *i;
*i = o->next;
mem_free (o->mesg);
if (o->note)
mem_free (o->note);
if (o->rpt)
mem_free (o->rpt);
if (o->exc)
{
free_exc (o->exc);
o->exc = 0;
}
mem_free (o);
}
static int
recur_apoint_cmp_start (struct recur_apoint *a, struct recur_apoint *b)
{
return (a->start < b->start ? -1 : (a->start == b->start ? 0 : 1));
}
static int
recur_event_cmp_day (struct recur_event *a, struct recur_event *b)
{
return (a->day < b->day ? -1 : (a->day == b->day ? 0 : 1));
}
/* Insert a new recursive appointment in the general linked list */
@ -238,41 +245,30 @@ struct recur_apoint *
recur_apoint_new (char *mesg, char *note, long start, long dur, char state,
int type, int freq, long until, struct days **except)
{
struct recur_apoint *o, **i;
struct recur_apoint *rapt = mem_malloc (sizeof (struct recur_apoint));
o = mem_malloc (sizeof (struct recur_apoint));
o->rpt = mem_malloc (sizeof (struct rpt));
o->mesg = mem_strdup (mesg);
o->note = (note != NULL) ? mem_strdup (note) : 0;
o->start = start;
o->state = state;
o->dur = dur;
o->rpt->type = type;
o->rpt->freq = freq;
o->rpt->until = until;
o->exc = 0;
rapt->rpt = mem_malloc (sizeof (struct rpt));
rapt->mesg = mem_strdup (mesg);
rapt->note = (note != NULL) ? mem_strdup (note) : 0;
rapt->start = start;
rapt->state = state;
rapt->dur = dur;
rapt->rpt->type = type;
rapt->rpt->freq = freq;
rapt->rpt->until = until;
rapt->exc = 0;
if (except && *except)
{
exc_dup (&o->exc, *except);
exc_dup (&rapt->exc, *except);
free_exc (*except);
*except = 0;
}
pthread_mutex_lock (&(recur_alist_p->mutex));
i = &recur_alist_p->root;
for (;;)
{
if (*i == NULL || (*i)->start > start)
{
o->next = *i;
*i = o;
break;
}
i = &(*i)->next;
}
pthread_mutex_unlock (&(recur_alist_p->mutex));
LLIST_TS_LOCK (&recur_alist_p);
LLIST_TS_ADD_SORTED (&recur_alist_p, rapt, recur_apoint_cmp_start);
LLIST_TS_UNLOCK (&recur_alist_p);
return (o);
return rapt;
}
/* Insert a new recursive event in the general linked list */
@ -280,37 +276,27 @@ struct recur_event *
recur_event_new (char *mesg, char *note, long day, int id, int type, int freq,
long until, struct days **except)
{
struct recur_event *o, **i;
struct recur_event *rev = mem_malloc (sizeof (struct recur_event));
o = mem_malloc (sizeof (struct recur_event));
o->rpt = mem_malloc (sizeof (struct rpt));
o->mesg = mem_strdup (mesg);
o->note = (note != NULL) ? mem_strdup (note) : 0;
o->day = day;
o->id = id;
o->rpt->type = type;
o->rpt->freq = freq;
o->rpt->until = until;
o->exc = 0;
rev->rpt = mem_malloc (sizeof (struct rpt));
rev->mesg = mem_strdup (mesg);
rev->note = (note != NULL) ? mem_strdup (note) : 0;
rev->day = day;
rev->id = id;
rev->rpt->type = type;
rev->rpt->freq = freq;
rev->rpt->until = until;
rev->exc = 0;
if (except && *except)
{
exc_dup (&o->exc, *except);
exc_dup (&rev->exc, *except);
free_exc (*except);
*except = 0;
}
i = &recur_elist;
for (;;)
{
if (*i == NULL || (*i)->day > day)
{
o->next = *i;
*i = o;
break;
}
i = &(*i)->next;
}
return (o);
LLIST_ADD_SORTED (&recur_elist, rev, recur_event_cmp_day);
return rev;
}
/*
@ -566,16 +552,21 @@ recur_event_write (struct recur_event *o, FILE *f)
void
recur_save_data (FILE *f)
{
struct recur_event *re;
struct recur_apoint *ra;
llist_item_t *i;
for (re = recur_elist; re != NULL; re = re->next)
recur_event_write (re, f);
LLIST_FOREACH (&recur_elist, i)
{
struct recur_event *rev = LLIST_GET_DATA (i);
recur_event_write (rev, f);
}
pthread_mutex_lock (&(recur_alist_p->mutex));
for (ra = recur_alist_p->root; ra != NULL; ra = ra->next)
recur_apoint_write (ra, f);
pthread_mutex_unlock (&(recur_alist_p->mutex));
LLIST_TS_LOCK (&recur_alist_p);
LLIST_TS_FOREACH (&recur_alist_p, i)
{
struct recur_apoint *rapt = LLIST_GET_DATA (i);
recur_apoint_write (rapt, f);
}
LLIST_TS_UNLOCK (&recur_alist_p);
}
@ -750,61 +741,47 @@ void
recur_event_erase (long start, unsigned num, unsigned delete_whole,
enum eraseflg flag)
{
unsigned n = 0;
struct recur_event *i, **iptr;
llist_item_t *i;
i = LLIST_FIND_NTH (&recur_elist, num, start, recur_event_inday);
iptr = &recur_elist;
for (i = recur_elist; i != NULL; i = i->next)
if (!i)
EXIT (_("event not found"));
struct recur_event *rev = LLIST_GET_DATA (i);
if (delete_whole)
{
if (recur_item_inday (i->day, i->exc, i->rpt->type,
i->rpt->freq, i->rpt->until, start))
switch (flag)
{
if (n == num)
case ERASE_FORCE_ONLY_NOTE:
erase_note (&rev->note, flag);
break;
case ERASE_CUT:
recur_event_free_bkp (ERASE_FORCE);
recur_event_dup (rev, &bkp_cut_recur_event);
erase_note (&rev->note, ERASE_FORCE_KEEP_NOTE);
/* FALLTHROUGH */
default:
LLIST_REMOVE (&recur_elist, i);
mem_free (rev->mesg);
if (rev->rpt)
{
if (delete_whole)
{
switch (flag)
{
case ERASE_FORCE_ONLY_NOTE:
erase_note (&i->note, flag);
break;
case ERASE_CUT:
recur_event_free_bkp (ERASE_FORCE);
recur_event_dup (i, &bkp_cut_recur_event);
erase_note (&i->note, ERASE_FORCE_KEEP_NOTE);
/* FALLTHROUGH */
default:
*iptr = i->next;
mem_free (i->mesg);
if (i->rpt)
{
mem_free (i->rpt);
i->rpt = 0;
}
if (i->exc)
{
free_exc (i->exc);
i->exc = 0;
}
if (flag != ERASE_FORCE_KEEP_NOTE && flag != ERASE_CUT)
erase_note (&i->note, flag);
mem_free (i);
break;
}
return;
}
else
{
recur_add_exc (&i->exc, start);
return;
}
mem_free (rev->rpt);
rev->rpt = 0;
}
n++;
if (rev->exc)
{
free_exc (rev->exc);
rev->exc = 0;
}
if (flag != ERASE_FORCE_KEEP_NOTE && flag != ERASE_CUT)
erase_note (&rev->note, flag);
mem_free (rev);
break;
}
iptr = &i->next;
}
EXIT (_("event not found"));
/* NOTREACHED */
else
recur_add_exc (&rev->exc, start);
}
/*
@ -815,71 +792,58 @@ void
recur_apoint_erase (long start, unsigned num, unsigned delete_whole,
enum eraseflg flag)
{
unsigned n = 0;
struct recur_apoint *i, **iptr;
llist_item_t *i;
int need_check_notify = 0;
i = LLIST_TS_FIND_NTH (&recur_alist_p, num, start, recur_apoint_inday);
pthread_mutex_lock (&(recur_alist_p->mutex));
iptr = &recur_alist_p->root;
for (i = recur_alist_p->root; i != NULL; i = i->next)
if (!i)
EXIT (_("appointment not found"));
struct recur_apoint *rapt = LLIST_GET_DATA (i);
LLIST_TS_LOCK (&recur_alist_p);
if (notify_bar () && flag != ERASE_FORCE_ONLY_NOTE)
need_check_notify = notify_same_recur_item (rapt);
if (delete_whole)
{
if (recur_item_inday (i->start, i->exc, i->rpt->type,
i->rpt->freq, i->rpt->until, start))
switch (flag)
{
if (n == num)
case ERASE_FORCE_ONLY_NOTE:
erase_note (&rapt->note, flag);
break;
case ERASE_CUT:
recur_apoint_free_bkp (ERASE_FORCE);
recur_apoint_dup (rapt, &bkp_cut_recur_apoint);
erase_note (&rapt->note, ERASE_FORCE_KEEP_NOTE);
/* FALLTHROUGH */
default:
LLIST_TS_REMOVE (&recur_alist_p, i);
mem_free (rapt->mesg);
if (rapt->rpt)
{
if (notify_bar () && flag != ERASE_FORCE_ONLY_NOTE)
need_check_notify = notify_same_recur_item (i);
if (delete_whole)
{
switch (flag)
{
case ERASE_FORCE_ONLY_NOTE:
erase_note (&i->note, flag);
break;
case ERASE_CUT:
recur_apoint_free_bkp (ERASE_FORCE);
recur_apoint_dup (i, &bkp_cut_recur_apoint);
erase_note (&i->note, ERASE_FORCE_KEEP_NOTE);
/* FALLTHROUGH */
default:
*iptr = i->next;
mem_free (i->mesg);
if (i->rpt)
{
mem_free (i->rpt);
i->rpt = 0;
}
if (i->exc)
{
free_exc (i->exc);
i->exc = 0;
}
if (flag != ERASE_FORCE_KEEP_NOTE && flag != ERASE_CUT)
erase_note (&i->note, flag);
mem_free (i);
pthread_mutex_unlock (&(recur_alist_p->mutex));
if (need_check_notify)
notify_check_next_app ();
break;
}
return;
}
else
{
recur_add_exc (&i->exc, start);
pthread_mutex_unlock (&(recur_alist_p->mutex));
if (need_check_notify)
notify_check_next_app ();
return;
}
mem_free (rapt->rpt);
rapt->rpt = 0;
}
n++;
if (rapt->exc)
{
free_exc (rapt->exc);
rapt->exc = 0;
}
if (flag != ERASE_FORCE_KEEP_NOTE && flag != ERASE_CUT)
erase_note (&rapt->note, flag);
mem_free (rapt);
if (need_check_notify)
notify_check_next_app ();
break;
}
iptr = &i->next;
}
EXIT (_("appointment not found"));
/* NOTREACHED */
else
{
recur_add_exc (&rapt->exc, start);
if (need_check_notify)
notify_check_next_app ();
}
LLIST_TS_UNLOCK (&recur_alist_p);
}
/*
@ -1064,6 +1028,12 @@ recur_exc_scan (FILE *data_file)
return exc_head;
}
static int
recur_apoint_starts_after (struct recur_apoint *rapt, long time)
{
return (rapt->start > 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).
@ -1071,32 +1041,27 @@ recur_exc_scan (FILE *data_file)
struct notify_app *
recur_apoint_check_next (struct notify_app *app, long start, long day)
{
struct recur_apoint *i;
llist_item_t *i;
long real_recur_start_time;
pthread_mutex_lock (&(recur_alist_p->mutex));
for (i = recur_alist_p->root; i != NULL; i = i->next)
LLIST_TS_LOCK (&recur_alist_p);
i = LLIST_TS_FIND_FIRST (&recur_alist_p, start, recur_apoint_starts_after);
if (i)
{
if (i->start > app->time)
struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
real_recur_start_time = recur_apoint_inday(rapt, day);
if (real_recur_start_time > start)
{
pthread_mutex_unlock (&(recur_alist_p->mutex));
return (app);
}
else
{
real_recur_start_time =
recur_item_inday (i->start, i->exc, i->rpt->type, i->rpt->freq,
i->rpt->until, day);
if (real_recur_start_time > start)
{
app->time = real_recur_start_time;
app->txt = mem_strdup (i->mesg);
app->state = i->state;
app->got_app = 1;
}
app->time = real_recur_start_time;
app->txt = mem_strdup (rapt->mesg);
app->state = rapt->state;
app->got_app = 1;
}
}
pthread_mutex_unlock (&(recur_alist_p->mutex));
LLIST_TS_UNLOCK (&recur_alist_p);
return (app);
}
@ -1105,25 +1070,13 @@ recur_apoint_check_next (struct notify_app *app, long start, long day)
struct recur_apoint *
recur_get_apoint (long date, int num)
{
struct recur_apoint *o;
int n = 0;
llist_item_t *i = LLIST_TS_FIND_NTH (&recur_alist_p, num, date,
recur_apoint_inday);
if (i)
return LLIST_TS_GET_DATA (i);
pthread_mutex_lock (&(recur_alist_p->mutex));
for (o = recur_alist_p->root; o != NULL; o = o->next)
{
if (recur_item_inday (o->start, o->exc, o->rpt->type,
o->rpt->freq, o->rpt->until, date))
{
if (n == num)
{
pthread_mutex_unlock (&(recur_alist_p->mutex));
return (o);
}
n++;
}
}
EXIT (_("item not found"));
return 0;
/* NOTREACHED */
}
@ -1131,23 +1084,13 @@ recur_get_apoint (long date, int num)
struct recur_event *
recur_get_event (long date, int num)
{
struct recur_event *o;
int n = 0;
llist_item_t *i = LLIST_FIND_NTH (&recur_elist, num, date,
recur_event_inday);
if (i)
return LLIST_GET_DATA (i);
for (o = recur_elist; o != NULL; o = o->next)
{
if (recur_item_inday (o->day, o->exc, o->rpt->type,
o->rpt->freq, o->rpt->until, date))
{
if (n == num)
{
return (o);
}
n++;
}
}
EXIT (_("item not found"));
return 0;
/* NOTREACHED */
}
@ -1155,35 +1098,21 @@ recur_get_event (long date, int num)
void
recur_apoint_switch_notify (long date, int recur_nb)
{
int n, need_chk_notify;
struct recur_apoint *o;
llist_item_t *i;
n = 0;
need_chk_notify = 0;
LLIST_TS_LOCK (&recur_alist_p);
i = LLIST_TS_FIND_NTH (&recur_alist_p, recur_nb, date, recur_apoint_inday);
pthread_mutex_lock (&(recur_alist_p->mutex));
for (o = recur_alist_p->root; o != NULL; o = o->next)
{
if (recur_item_inday (o->start, o->exc, o->rpt->type,
o->rpt->freq, o->rpt->until, date))
{
if (n == recur_nb)
{
o->state ^= APOINT_NOTIFY;
if (!i)
EXIT (_("item not found"));
struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
if (notify_bar ())
notify_check_repeated (o);
rapt->state ^= APOINT_NOTIFY;
pthread_mutex_unlock (&(recur_alist_p->mutex));
if (need_chk_notify)
notify_check_next_app ();
return;
}
n++;
}
}
EXIT (_("item not found"));
/* NOTREACHED */
if (notify_bar ())
notify_check_repeated (rapt);
LLIST_TS_UNLOCK (&recur_alist_p);
}
void