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) struct conf *conf, regex_t *regex)
{ {
llist_item_t *i; llist_item_t *i;
struct recur_event *re;
struct recur_apoint *ra;
long today; long today;
unsigned print_date = 1; unsigned print_date = 1;
int app_found = 0; 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 and it is the first one, and then print all the events for
* that date. * 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, struct recur_event *re = LLIST_GET_DATA (i);
re->rpt->until, today)) if (regex && regexec (regex, re->mesg, 0, 0, 0) != 0)
{ continue;
if (regex && regexec (regex, re->mesg, 0, 0, 0) != 0)
continue;
app_found = 1; app_found = 1;
if (add_line) 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);
fputs ("\n", stdout); fputs ("\n", stdout);
if (print_note && re->note) add_line = 0;
print_notefile (stdout, re->note, 2);
} }
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) 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. */ /* Same process is performed but this time on the appointments. */
pthread_mutex_lock (&(recur_alist_p->mutex)); LLIST_TS_LOCK (&recur_alist_p);
for (ra = recur_alist_p->root; ra != NULL; ra = ra->next) 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, struct recur_apoint *ra = LLIST_TS_GET_DATA (i);
ra->rpt->until, today)) 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); fputs ("\n", stdout);
if (print_note && ra->note) add_line = 0;
print_notefile (stdout, ra->note, 2);
} }
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_LOCK (&alist_p);
LLIST_TS_FIND_FOREACH (&alist_p, today, apoint_inday, i) 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 */ 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. */ /* Reccurent event definition. */
struct recur_event { struct recur_event {
struct recur_event *next;
struct rpt *rpt; /* information about repetition */ struct rpt *rpt; /* information about repetition */
struct days *exc; /* days when the item should not be repeated */ struct days *exc; /* days when the item should not be repeated */
int id; /* event type */ int id; /* event type */
@ -768,8 +761,8 @@ int notify_same_recur_item (struct recur_apoint *);
void notify_config_bar (void); void notify_config_bar (void);
/* recur.c */ /* recur.c */
extern struct recur_apoint_list *recur_alist_p; extern llist_ts_t recur_alist_p;
extern struct recur_event *recur_elist; extern llist_t recur_elist;
void recur_event_free_bkp (enum eraseflg); void recur_event_free_bkp (enum eraseflg);
void recur_apoint_free_bkp (enum eraseflg); void recur_apoint_free_bkp (enum eraseflg);
void recur_apoint_llist_init (void); void recur_apoint_llist_init (void);

94
src/day.c
View File

@ -168,17 +168,15 @@ day_store_events (long date)
static int static int
day_store_recur_events (long date) day_store_recur_events (long date)
{ {
struct recur_event *j; llist_item_t *i;
int e_nb = 0; 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, struct recur_event *rev = LLIST_TS_GET_DATA (i);
j->rpt->until, date)) (void)day_add_event (RECUR_EVNT, rev->mesg, rev->note, rev->day,
{ rev->id);
e_nb++; e_nb++;
(void)day_add_event (RECUR_EVNT, j->mesg, j->note, j->day, j->id);
}
} }
return 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 * Store the recurrent apoints for the selected day in structure pointed
* by day_items. This is done by copying the appointments * 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. * structure dedicated to the selected day.
* Returns the number of recurrent appointments for the selected day. * Returns the number of recurrent appointments for the selected day.
*/ */
static int static int
day_store_recur_apoints (long date) day_store_recur_apoints (long date)
{ {
struct recur_apoint *j; llist_item_t *i;
long real_start; int a_nb = 0;
int a_nb = 0, n = 0;
pthread_mutex_lock (&(recur_alist_p->mutex)); LLIST_TS_LOCK (&recur_alist_p);
for (j = recur_alist_p->root; j != NULL; j = j->next) LLIST_TS_FIND_FOREACH (&recur_alist_p, date, recur_apoint_inday, i)
{ {
if ((real_start = recur_item_inday (j->start, j->exc, struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
j->rpt->type, j->rpt->freq, int real_start = recur_apoint_inday (rapt, date);
j->rpt->until, date))) (void)day_add_apoint (RECUR_APPT, rapt->mesg, rapt->note, real_start,
{ rapt->dur, rapt->state, a_nb);
a_nb++; a_nb++;
(void)day_add_apoint (RECUR_APPT, j->mesg, j->note,
real_start, j->dur, j->state, n);
n++;
}
} }
pthread_mutex_unlock (&(recur_alist_p->mutex)); LLIST_TS_UNLOCK (&recur_alist_p);
return a_nb; return a_nb;
} }
@ -467,24 +460,18 @@ day_popup_item (void)
int int
day_check_if_item (struct date day) day_check_if_item (struct date day)
{ {
struct recur_event *re;
struct recur_apoint *ra;
const long date = date2sec (day, 0, 0); const long date = date2sec (day, 0, 0);
for (re = recur_elist; re != NULL; re = re->next) if (LLIST_FIND_FIRST (&recur_elist, date, recur_event_inday))
if (recur_item_inday (re->day, re->exc, re->rpt->type, return (1);
re->rpt->freq, re->rpt->until, date))
return (1);
pthread_mutex_lock (&(recur_alist_p->mutex)); LLIST_TS_LOCK (&recur_alist_p);
for (ra = recur_alist_p->root; ra != NULL; ra = ra->next) if (LLIST_TS_FIND_FIRST (&recur_alist_p, date, recur_apoint_inday))
if (recur_item_inday (ra->start, ra->exc, ra->rpt->type, {
ra->rpt->freq, ra->rpt->until, date)) LLIST_TS_UNLOCK (&recur_alist_p);
{ return (1);
pthread_mutex_unlock (&(recur_alist_p->mutex)); }
return (1); LLIST_TS_UNLOCK (&recur_alist_p);
}
pthread_mutex_unlock (&(recur_alist_p->mutex));
if (LLIST_FIND_FIRST (&eventlist, date, event_inday)) if (LLIST_FIND_FIRST (&eventlist, date, event_inday))
return (1); return (1);
@ -526,7 +513,6 @@ unsigned
day_chk_busy_slices (struct date day, int slicesno, int *slices) day_chk_busy_slices (struct date day, int slicesno, int *slices)
{ {
llist_item_t *i; llist_item_t *i;
struct recur_apoint *ra;
int slicelen; int slicelen;
const long date = date2sec (day, 0, 0); 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) #define SLICENUM(tsec) ((tsec) / slicelen % slicesno)
pthread_mutex_lock (&(recur_alist_p->mutex)); LLIST_TS_LOCK (&recur_alist_p);
for (ra = recur_alist_p->root; ra != NULL; ra = ra->next) LLIST_TS_FIND_FOREACH (&recur_alist_p, date, recur_apoint_inday, i)
if (recur_item_inday (ra->start, ra->exc, ra->rpt->type, {
ra->rpt->freq, ra->rpt->until, date)) struct apoint *rapt = LLIST_TS_GET_DATA (i);
{ long start = get_item_time (rapt->start);
long start, end; long end = get_item_time (rapt->start + rapt->dur);
start = get_item_time (ra->start); if (!fill_slices (slices, slicesno, SLICENUM (start), SLICENUM (end)))
end = get_item_time (ra->start + ra->dur); {
if (!fill_slices (slices, slicesno, SLICENUM (start), SLICENUM (end))) LLIST_TS_UNLOCK (&recur_alist_p);
{ return 0;
pthread_mutex_unlock (&(recur_alist_p->mutex)); }
return 0; }
} LLIST_TS_UNLOCK (&recur_alist_p);
}
pthread_mutex_unlock (&(recur_alist_p->mutex));
LLIST_TS_LOCK (&alist_p); LLIST_TS_LOCK (&alist_p);
LLIST_TS_FIND_FOREACH (&alist_p, date, apoint_inday, i) 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 static void
ical_export_recur_events (FILE *stream) ical_export_recur_events (FILE *stream)
{ {
struct recur_event *i; llist_item_t *i;
struct days *day; struct days *day;
char ical_date[BUFSIZ]; 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, "BEGIN:VEVENT\n");
(void)fprintf (stream, "DTSTART:%s\n", ical_date); (void)fprintf (stream, "DTSTART:%s\n", ical_date);
(void)fprintf (stream, "RRULE:FREQ=%s;INTERVAL=%d", (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); (void)fprintf (stream, ";UNTIL=%s\n", ical_date);
} }
else else
(void)fprintf (stream, "\n"); (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); (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); date_sec2date_fmt (day->st, ICALDATEFMT, ical_date);
(void)fprintf (stream, ",%s", 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, "\n");
} }
(void)fprintf (stream, "SUMMARY:%s\n", i->mesg); (void)fprintf (stream, "SUMMARY:%s\n", rev->mesg);
(void)fprintf (stream, "END:VEVENT\n"); (void)fprintf (stream, "END:VEVENT\n");
} }
} }
@ -407,7 +408,7 @@ pcal_dump_apoint (FILE *stream, long apoint_date, long apoint_dur,
static void static void
pcal_export_recur_events (FILE *stream) pcal_export_recur_events (FILE *stream)
{ {
struct recur_event *i; llist_item_t *i;
char pcal_date[BUFSIZ]; char pcal_date[BUFSIZ];
(void)fprintf (stream, "\n# ============="); (void)fprintf (stream, "\n# =============");
@ -416,30 +417,32 @@ pcal_export_recur_events (FILE *stream)
(void)fprintf (stream, (void)fprintf (stream,
"# (pcal does not support from..until dates specification\n"); "# (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: 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", (void)fprintf (stream, "all day on_or_after %s %s\n",
pcal_date, i->mesg); pcal_date, rev->mesg);
break; break;
case RECUR_WEEKLY: 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); (void)fprintf (stream, "all %s on_or_after ", pcal_date);
date_sec2date_fmt (i->day, "%b %d", pcal_date); date_sec2date_fmt (rev->day, "%b %d", pcal_date);
(void)fprintf (stream, "%s %s\n", pcal_date, i->mesg); (void)fprintf (stream, "%s %s\n", pcal_date, rev->mesg);
break; break;
case RECUR_MONTHLY: case RECUR_MONTHLY:
date_sec2date_fmt (i->day, "%d", pcal_date); date_sec2date_fmt (rev->day, "%d", pcal_date);
(void)fprintf (stream, "day on all %s %s\n", pcal_date, i->mesg); (void)fprintf (stream, "day on all %s %s\n", pcal_date,
rev->mesg);
break; break;
case RECUR_YEARLY: case RECUR_YEARLY:
date_sec2date_fmt (i->day, "%b %d", pcal_date); date_sec2date_fmt (rev->day, "%b %d", pcal_date);
(void)fprintf (stream, "%s %s\n", pcal_date, i->mesg); (void)fprintf (stream, "%s %s\n", pcal_date, rev->mesg);
break; break;
default: default:
EXIT (_("incoherent repetition type")); 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_START = calendar_start_of_year ();
const long YEAR_END = calendar_end_of_year (); const long YEAR_END = calendar_end_of_year ();
if (i->day < YEAR_END && i->day > YEAR_START) if (rev->day < YEAR_END && rev->day > YEAR_START)
foreach_date_dump (YEAR_END, i->rpt, i->exc, i->day, 0, i->mesg, foreach_date_dump (YEAR_END, rev->rpt, rev->exc, rev->day, 0,
(cb_dump_t) pcal_dump_event, stream); rev->mesg, (cb_dump_t) pcal_dump_event, stream);
} }
} }
} }
@ -493,34 +496,37 @@ pcal_export_events (FILE *stream)
static void static void
ical_export_recur_apoints (FILE *stream) ical_export_recur_apoints (FILE *stream)
{ {
struct recur_apoint *i; llist_item_t *i;
struct days *day; struct days *day;
char ical_datetime[BUFSIZ]; char ical_datetime[BUFSIZ];
char ical_date[BUFSIZ]; char ical_date[BUFSIZ];
pthread_mutex_lock (&(recur_alist_p->mutex)); LLIST_TS_LOCK (&recur_alist_p);
for (i = recur_alist_p->root; i != NULL; i = i->next) 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, "BEGIN:VEVENT\n");
(void)fprintf (stream, "DTSTART:%s\n", ical_datetime); (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", (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); (void)fprintf (stream, ";UNTIL=%s\n", ical_date);
} }
else else
(void)fprintf (stream, "\n"); (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); (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); date_sec2date_fmt (day->st, ICALDATEFMT, ical_date);
(void)fprintf (stream, ",%s", 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, "\n");
} }
(void)fprintf (stream, "SUMMARY:%s\n", i->mesg); (void)fprintf (stream, "SUMMARY:%s\n", rapt->mesg);
if (i->state & APOINT_NOTIFY) if (rapt->state & APOINT_NOTIFY)
ical_export_valarm (stream); ical_export_valarm (stream);
(void)fprintf (stream, "END:VEVENT\n"); (void)fprintf (stream, "END:VEVENT\n");
} }
pthread_mutex_unlock (&(recur_alist_p->mutex)); LLIST_TS_UNLOCK (&recur_alist_p);
} }
static void static void
pcal_export_recur_apoints (FILE *stream) pcal_export_recur_apoints (FILE *stream)
{ {
struct recur_apoint *i; llist_item_t *i;
char pcal_date[BUFSIZ], pcal_beg[BUFSIZ], pcal_end[BUFSIZ]; char pcal_date[BUFSIZ], pcal_beg[BUFSIZ], pcal_end[BUFSIZ];
(void)fprintf (stream, "\n# =============="); (void)fprintf (stream, "\n# ==============");
@ -548,35 +554,37 @@ pcal_export_recur_apoints (FILE *stream)
(void)fprintf (stream, (void)fprintf (stream,
"# (pcal does not support from..until dates specification\n"); "# (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 (rapt->start, "%R", pcal_beg);
date_sec2date_fmt (i->start + i->dur, "%R", pcal_end); date_sec2date_fmt (rapt->start + rapt->dur, "%R", pcal_end);
switch (i->rpt->type) switch (rapt->rpt->type)
{ {
case RECUR_DAILY: 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", (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; break;
case RECUR_WEEKLY: 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); (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, (void)fprintf (stream, "%s (%s -> %s) %s\n", pcal_date,
pcal_beg, pcal_end, i->mesg); pcal_beg, pcal_end, rapt->mesg);
break; break;
case RECUR_MONTHLY: 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", (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; break;
case RECUR_YEARLY: 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, (void)fprintf (stream, "%s (%s -> %s) %s\n", pcal_date,
pcal_beg, pcal_end, i->mesg); pcal_beg, pcal_end, rapt->mesg);
break; break;
default: default:
EXIT (_("incoherent repetition type")); 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_START = calendar_start_of_year ();
const long YEAR_END = calendar_end_of_year (); const long YEAR_END = calendar_end_of_year ();
if (i->start < YEAR_END && i->start > YEAR_START) if (rapt->start < YEAR_END && rapt->start > YEAR_START)
foreach_date_dump (YEAR_END, i->rpt, i->exc, i->start, i->dur, foreach_date_dump (YEAR_END, rapt->rpt, rapt->exc, rapt->start,
i->mesg, (cb_dump_t)pcal_dump_apoint, stream); rapt->dur, rapt->mesg,
(cb_dump_t)pcal_dump_apoint, stream);
} }
} }
} }

501
src/recur.c
View File

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