diff options
Diffstat (limited to 'src/recur.c')
| -rw-r--r-- | src/recur.c | 1213 |
1 files changed, 549 insertions, 664 deletions
diff --git a/src/recur.c b/src/recur.c index d1a5516..dad9c25 100644 --- a/src/recur.c +++ b/src/recur.c @@ -42,242 +42,217 @@ #include "calcurse.h" -llist_ts_t recur_alist_p; -llist_t recur_elist; -static struct recur_event bkp_cut_recur_event; +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 -free_exc (struct excp *exc) +static void free_exc(struct excp *exc) { - mem_free (exc); + mem_free(exc); } -static void -free_exc_list (llist_t *exc) +static void free_exc_list(llist_t * exc) { - LLIST_FREE_INNER (exc, free_exc); - LLIST_FREE (exc); + LLIST_FREE_INNER(exc, free_exc); + LLIST_FREE(exc); } -static int -exc_cmp_day (struct excp *a, struct excp *b) +static int exc_cmp_day(struct excp *a, struct excp *b) { return a->st < b->st ? -1 : (a->st == b->st ? 0 : 1); } -static void -recur_add_exc (llist_t *exc, long day) +static void recur_add_exc(llist_t * exc, long day) { - struct excp *o = mem_malloc (sizeof (struct excp)); + struct excp *o = mem_malloc(sizeof(struct excp)); o->st = day; - LLIST_ADD_SORTED (exc, o, exc_cmp_day); + LLIST_ADD_SORTED(exc, o, exc_cmp_day); } -static void -exc_dup (llist_t *in, llist_t *exc) +static void exc_dup(llist_t * in, llist_t * exc) { llist_item_t *i; - LLIST_INIT (in); + LLIST_INIT(in); - if (exc) - { - LLIST_FOREACH (exc, i) - { - struct excp *p = LLIST_GET_DATA (i); - recur_add_exc (in, p->st); - } + if (exc) { + LLIST_FOREACH(exc, i) { + struct excp *p = LLIST_GET_DATA(i); + recur_add_exc(in, p->st); } + } } -void -recur_event_free_bkp (void) +void recur_event_free_bkp(void) { - if (bkp_cut_recur_event.mesg) - { - mem_free (bkp_cut_recur_event.mesg); - bkp_cut_recur_event.mesg = 0; - } - if (bkp_cut_recur_event.rpt) - { - mem_free (bkp_cut_recur_event.rpt); - bkp_cut_recur_event.rpt = 0; - } - free_exc_list (&bkp_cut_recur_event.exc); - erase_note (&bkp_cut_recur_event.note); + if (bkp_cut_recur_event.mesg) { + mem_free(bkp_cut_recur_event.mesg); + bkp_cut_recur_event.mesg = 0; + } + if (bkp_cut_recur_event.rpt) { + mem_free(bkp_cut_recur_event.rpt); + bkp_cut_recur_event.rpt = 0; + } + free_exc_list(&bkp_cut_recur_event.exc); + erase_note(&bkp_cut_recur_event.note); } -void -recur_apoint_free_bkp (void) +void recur_apoint_free_bkp(void) { - if (bkp_cut_recur_apoint.mesg) - { - mem_free (bkp_cut_recur_apoint.mesg); - bkp_cut_recur_apoint.mesg = 0; - } - if (bkp_cut_recur_apoint.rpt) - { - mem_free (bkp_cut_recur_apoint.rpt); - bkp_cut_recur_apoint.rpt = 0; - } - free_exc_list (&bkp_cut_recur_apoint.exc); - erase_note (&bkp_cut_recur_apoint.note); + if (bkp_cut_recur_apoint.mesg) { + mem_free(bkp_cut_recur_apoint.mesg); + bkp_cut_recur_apoint.mesg = 0; + } + if (bkp_cut_recur_apoint.rpt) { + mem_free(bkp_cut_recur_apoint.rpt); + bkp_cut_recur_apoint.rpt = 0; + } + free_exc_list(&bkp_cut_recur_apoint.exc); + erase_note(&bkp_cut_recur_apoint.note); } -static void -recur_event_dup (struct recur_event *in, struct recur_event *bkp) +static void recur_event_dup(struct recur_event *in, struct recur_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); - bkp->rpt = mem_malloc (sizeof (struct rpt)); + bkp->rpt = mem_malloc(sizeof(struct rpt)); bkp->rpt->type = in->rpt->type; bkp->rpt->freq = in->rpt->freq; bkp->rpt->until = in->rpt->until; - exc_dup (&bkp->exc, &in->exc); + exc_dup(&bkp->exc, &in->exc); if (in->note) - bkp->note = mem_strdup (in->note); + bkp->note = mem_strdup(in->note); } -static void -recur_apoint_dup (struct recur_apoint *in, struct recur_apoint *bkp) +static void recur_apoint_dup(struct recur_apoint *in, struct recur_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); - bkp->rpt = mem_malloc (sizeof (struct rpt)); + bkp->rpt = mem_malloc(sizeof(struct rpt)); bkp->rpt->type = in->rpt->type; bkp->rpt->freq = in->rpt->freq; bkp->rpt->until = in->rpt->until; - exc_dup (&bkp->exc, &in->exc); + exc_dup(&bkp->exc, &in->exc); if (in->note) - bkp->note = mem_strdup (in->note); + bkp->note = mem_strdup(in->note); } -void -recur_apoint_llist_init (void) +void recur_apoint_llist_init(void) { - LLIST_TS_INIT (&recur_alist_p); + LLIST_TS_INIT(&recur_alist_p); } -static void -recur_apoint_free (struct recur_apoint *rapt) +static void recur_apoint_free(struct recur_apoint *rapt) { - mem_free (rapt->mesg); + mem_free(rapt->mesg); if (rapt->note) - mem_free (rapt->note); + mem_free(rapt->note); if (rapt->rpt) - mem_free (rapt->rpt); - free_exc_list (&rapt->exc); - mem_free (rapt); + mem_free(rapt->rpt); + free_exc_list(&rapt->exc); + mem_free(rapt); } -static void -recur_event_free (struct recur_event *rev) +static void recur_event_free(struct recur_event *rev) { - mem_free (rev->mesg); + mem_free(rev->mesg); if (rev->note) - mem_free (rev->note); + mem_free(rev->note); if (rev->rpt) - mem_free (rev->rpt); - free_exc_list (&rev->exc); - mem_free (rev); + mem_free(rev->rpt); + free_exc_list(&rev->exc); + mem_free(rev); } -void -recur_apoint_llist_free (void) +void recur_apoint_llist_free(void) { - LLIST_TS_FREE_INNER (&recur_alist_p, recur_apoint_free); - LLIST_TS_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) +void recur_event_llist_free(void) { - LLIST_FREE_INNER (&recur_elist, recur_event_free); - LLIST_FREE (&recur_elist); + LLIST_FREE_INNER(&recur_elist, recur_event_free); + LLIST_FREE(&recur_elist); } static int -recur_apoint_cmp_start (struct recur_apoint *a, struct recur_apoint *b) +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) +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 */ -struct recur_apoint * -recur_apoint_new (char *mesg, char *note, long start, long dur, char state, - int type, int freq, long until, llist_t *except) +struct recur_apoint *recur_apoint_new(char *mesg, char *note, long start, + long dur, char state, int type, int freq, + long until, llist_t * except) { - struct recur_apoint *rapt = mem_malloc (sizeof (struct recur_apoint)); + struct recur_apoint *rapt = mem_malloc(sizeof(struct recur_apoint)); - rapt->rpt = mem_malloc (sizeof (struct rpt)); - rapt->mesg = mem_strdup (mesg); - rapt->note = (note != NULL) ? mem_strdup (note) : 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; - if (except) - { - exc_dup (&rapt->exc, except); - free_exc_list (except); - } - else - LLIST_INIT (&rapt->exc); + if (except) { + exc_dup(&rapt->exc, except); + free_exc_list(except); + } else + LLIST_INIT(&rapt->exc); - LLIST_TS_LOCK (&recur_alist_p); - LLIST_TS_ADD_SORTED (&recur_alist_p, rapt, recur_apoint_cmp_start); - LLIST_TS_UNLOCK (&recur_alist_p); + 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 rapt; } /* Insert a new recursive event in the general linked list */ -struct recur_event * -recur_event_new (char *mesg, char *note, long day, int id, int type, int freq, - long until, llist_t *except) +struct recur_event *recur_event_new(char *mesg, char *note, long day, int id, + int type, int freq, long until, + llist_t * except) { - struct recur_event *rev = mem_malloc (sizeof (struct recur_event)); + struct recur_event *rev = mem_malloc(sizeof(struct recur_event)); - rev->rpt = mem_malloc (sizeof (struct rpt)); - rev->mesg = mem_strdup (mesg); - rev->note = (note != NULL) ? mem_strdup (note) : 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; - if (except) - { - exc_dup (&rev->exc, except); - free_exc_list (except); - } - else - LLIST_INIT (&rev->exc); + if (except) { + exc_dup(&rev->exc, except); + free_exc_list(except); + } else + LLIST_INIT(&rev->exc); - LLIST_ADD_SORTED (&recur_elist, rev, recur_event_cmp_day); + LLIST_ADD_SORTED(&recur_elist, rev, recur_event_cmp_day); return rev; } @@ -286,29 +261,27 @@ recur_event_new (char *mesg, char *note, long day, int id, int type, int freq, * Correspondance between the defines on recursive type, * and the letter to be written in file. */ -char -recur_def2char (enum recur_type define) +char recur_def2char(enum recur_type define) { char recur_char; - switch (define) - { - case RECUR_DAILY: - recur_char = 'D'; - break; - case RECUR_WEEKLY: - recur_char = 'W'; - break; - case RECUR_MONTHLY: - recur_char = 'M'; - break; - case RECUR_YEARLY: - recur_char = 'Y'; - break; - default: - EXIT (_("unknown repetition type")); - return 0; - } + switch (define) { + case RECUR_DAILY: + recur_char = 'D'; + break; + case RECUR_WEEKLY: + recur_char = 'W'; + break; + case RECUR_MONTHLY: + recur_char = 'M'; + break; + case RECUR_YEARLY: + recur_char = 'Y'; + break; + default: + EXIT(_("unknown repetition type")); + return 0; + } return recur_char; } @@ -317,185 +290,166 @@ recur_def2char (enum recur_type define) * Correspondance between the letters written in file and the defines * concerning the recursive type. */ -int -recur_char2def (char type) +int recur_char2def(char type) { int recur_def; - switch (type) - { - case 'D': - recur_def = RECUR_DAILY; - break; - case 'W': - recur_def = RECUR_WEEKLY; - break; - case 'M': - recur_def = RECUR_MONTHLY; - break; - case 'Y': - recur_def = RECUR_YEARLY; - break; - default: - EXIT (_("unknown character")); - return 0; - } + switch (type) { + case 'D': + recur_def = RECUR_DAILY; + break; + case 'W': + recur_def = RECUR_WEEKLY; + break; + case 'M': + recur_def = RECUR_MONTHLY; + break; + case 'Y': + recur_def = RECUR_YEARLY; + break; + default: + EXIT(_("unknown character")); + return 0; + } return recur_def; } /* Write days for which recurrent items should not be repeated. */ -static void -recur_write_exc (llist_t *lexc, FILE *f) +static void recur_write_exc(llist_t * lexc, FILE * f) { llist_item_t *i; struct tm *lt; time_t t; int st_mon, st_day, st_year; - LLIST_FOREACH (lexc, i) - { - struct excp *exc = LLIST_GET_DATA (i); - t = exc->st; - lt = localtime (&t); - st_mon = lt->tm_mon + 1; - st_day = lt->tm_mday; - st_year = lt->tm_year + 1900; - fprintf (f, " !%02u/%02u/%04u", st_mon, st_day, st_year); - } + LLIST_FOREACH(lexc, i) { + struct excp *exc = LLIST_GET_DATA(i); + t = exc->st; + lt = localtime(&t); + st_mon = lt->tm_mon + 1; + st_day = lt->tm_mday; + st_year = lt->tm_year + 1900; + fprintf(f, " !%02u/%02u/%04u", st_mon, st_day, st_year); + } } /* Load the recursive appointment description */ -struct recur_apoint * -recur_apoint_scan (FILE *f, struct tm start, struct tm end, char type, - int freq, struct tm until, char *note, llist_t *exc, - char state) +struct recur_apoint *recur_apoint_scan(FILE * f, struct tm start, struct tm end, + char type, int freq, struct tm until, + char *note, llist_t * exc, char state) { char buf[BUFSIZ], *nl; time_t tstart, tend, tuntil; /* Read the appointment 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_sec = end.tm_sec = 0; start.tm_isdst = end.tm_isdst = -1; start.tm_year -= 1900; start.tm_mon--; end.tm_year -= 1900; end.tm_mon--; - tstart = mktime (&start); - tend = mktime (&end); - - if (until.tm_year != 0) - { - until.tm_hour = 23; - until.tm_min = 59; - until.tm_sec = 0; - until.tm_isdst = -1; - until.tm_year -= 1900; - until.tm_mon--; - tuntil = mktime (&until); - } - else - { - tuntil = 0; - } - EXIT_IF (tstart == -1 || tend == -1 || tstart > tend || tuntil == -1, - _("date error in appointment")); - - return recur_apoint_new (buf, note, tstart, tend - tstart, state, - recur_char2def(type), freq, tuntil, exc); + tstart = mktime(&start); + tend = mktime(&end); + + if (until.tm_year != 0) { + until.tm_hour = 23; + until.tm_min = 59; + until.tm_sec = 0; + until.tm_isdst = -1; + until.tm_year -= 1900; + until.tm_mon--; + tuntil = mktime(&until); + } else { + tuntil = 0; + } + EXIT_IF(tstart == -1 || tend == -1 || tstart > tend || tuntil == -1, + _("date error in appointment")); + + return recur_apoint_new(buf, note, tstart, tend - tstart, state, + recur_char2def(type), freq, tuntil, exc); } /* Load the recursive events from file */ -struct recur_event * -recur_event_scan (FILE *f, struct tm start, int id, char type, int freq, - struct tm until, char *note, llist_t *exc) +struct recur_event *recur_event_scan(FILE * f, struct tm start, int id, + char type, int freq, struct tm until, + char *note, llist_t * exc) { char buf[BUFSIZ], *nl; time_t tstart, tuntil; /* 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 = until.tm_hour = 0; start.tm_min = until.tm_min = 0; start.tm_sec = until.tm_sec = 0; start.tm_isdst = until.tm_isdst = -1; start.tm_year -= 1900; start.tm_mon--; - if (until.tm_year != 0) - { - until.tm_year -= 1900; - until.tm_mon--; - tuntil = mktime (&until); - } - else - { - tuntil = 0; - } - tstart = mktime (&start); - EXIT_IF (tstart == -1 || tuntil == -1, - _("date error in event")); - - return recur_event_new (buf, note, tstart, id, recur_char2def(type), freq, - tuntil, exc); + if (until.tm_year != 0) { + until.tm_year -= 1900; + until.tm_mon--; + tuntil = mktime(&until); + } else { + tuntil = 0; + } + tstart = mktime(&start); + EXIT_IF(tstart == -1 || tuntil == -1, _("date error in event")); + + return recur_event_new(buf, note, tstart, id, recur_char2def(type), freq, + tuntil, exc); } /* Writting of a recursive appointment into file. */ -void -recur_apoint_write (struct recur_apoint *o, FILE *f) +void recur_apoint_write(struct recur_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); t = o->rpt->until; - if (t == 0) - { /* We have an endless recurrent appointment. */ - fprintf (f, " {%d%c", o->rpt->freq, recur_def2char (o->rpt->type)); - } - else - { - lt = localtime (&t); - fprintf (f, " {%d%c -> %02u/%02u/%04u", o->rpt->freq, - recur_def2char (o->rpt->type), lt->tm_mon + 1, lt->tm_mday, - 1900 + lt->tm_year); - } - recur_write_exc (&o->exc, f); - fputs ("} ", f); + if (t == 0) { /* We have an endless recurrent appointment. */ + fprintf(f, " {%d%c", o->rpt->freq, recur_def2char(o->rpt->type)); + } else { + lt = localtime(&t); + fprintf(f, " {%d%c -> %02u/%02u/%04u", o->rpt->freq, + recur_def2char(o->rpt->type), lt->tm_mon + 1, lt->tm_mday, + 1900 + lt->tm_year); + } + recur_write_exc(&o->exc, f); + fputs("} ", f); 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); - fprintf (f, "%s\n", o->mesg); + fputc('|', f); + fprintf(f, "%s\n", o->mesg); } /* Writting of a recursive event into file. */ -void -recur_event_write (struct recur_event *o, FILE *f) +void recur_event_write(struct recur_event *o, FILE * f) { struct tm *lt; time_t t; @@ -503,55 +457,48 @@ recur_event_write (struct recur_event *o, FILE *f) int end_mon, end_day, end_year; t = o->day; - lt = localtime (&t); + lt = localtime(&t); st_mon = lt->tm_mon + 1; st_day = lt->tm_mday; st_year = lt->tm_year + 1900; t = o->rpt->until; - if (t == 0) - { /* We have an endless recurrent event. */ - fprintf (f, "%02u/%02u/%04u [%d] {%d%c", st_mon, st_day, st_year, o->id, - o->rpt->freq, recur_def2char (o->rpt->type)); - } - else - { - lt = localtime (&t); - end_mon = lt->tm_mon + 1; - end_day = lt->tm_mday; - end_year = lt->tm_year + 1900; - fprintf (f, "%02u/%02u/%04u [%d] {%d%c -> %02u/%02u/%04u", st_mon, - st_day, st_year, o->id, o->rpt->freq, - recur_def2char (o->rpt->type), end_mon, end_day, end_year); - } - recur_write_exc (&o->exc, f); - fputs ("} ", f); + if (t == 0) { /* We have an endless recurrent event. */ + fprintf(f, "%02u/%02u/%04u [%d] {%d%c", st_mon, st_day, st_year, o->id, + o->rpt->freq, recur_def2char(o->rpt->type)); + } else { + lt = localtime(&t); + end_mon = lt->tm_mon + 1; + end_day = lt->tm_mday; + end_year = lt->tm_year + 1900; + fprintf(f, "%02u/%02u/%04u [%d] {%d%c -> %02u/%02u/%04u", st_mon, + st_day, st_year, o->id, o->rpt->freq, + recur_def2char(o->rpt->type), end_mon, end_day, end_year); + } + recur_write_exc(&o->exc, f); + fputs("} ", f); 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); } /* Write recursive items to file. */ -void -recur_save_data (FILE *f) +void recur_save_data(FILE * f) { llist_item_t *i; - LLIST_FOREACH (&recur_elist, i) - { - struct recur_event *rev = LLIST_GET_DATA (i); - recur_event_write (rev, f); - } - - 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); + LLIST_FOREACH(&recur_elist, i) { + struct recur_event *rev = LLIST_GET_DATA(i); + recur_event_write(rev, f); + } + + 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); } - /* * The two following defines together with the diff_days, diff_months and * diff_years functions were provided by Lukas Fleischer to correct the wrong @@ -564,10 +511,8 @@ recur_save_data (FILE *f) #define LEAPCOUNT(start, end) \ (BC(start, end, 4) - BC(start, end, 100) + BC(start, end, 400)) - /* Calculate the difference in days between two dates. */ -static long -diff_days (struct tm lt_start, struct tm lt_end) +static long diff_days(struct tm lt_start, struct tm lt_end) { long diff; @@ -576,19 +521,17 @@ diff_days (struct tm lt_start, struct tm lt_end) diff = lt_end.tm_yday - lt_start.tm_yday; - if (lt_end.tm_year > lt_start.tm_year) - { - diff += (lt_end.tm_year - lt_start.tm_year) * YEARINDAYS; - diff += LEAPCOUNT (lt_start.tm_year + TM_YEAR_BASE, - lt_end.tm_year + TM_YEAR_BASE - 1); - } + if (lt_end.tm_year > lt_start.tm_year) { + diff += (lt_end.tm_year - lt_start.tm_year) * YEARINDAYS; + diff += LEAPCOUNT(lt_start.tm_year + TM_YEAR_BASE, + lt_end.tm_year + TM_YEAR_BASE - 1); + } return diff; } /* Calculate the difference in months between two dates. */ -static long -diff_months (struct tm lt_start, struct tm lt_end) +static long diff_months(struct tm lt_start, struct tm lt_end) { long diff; @@ -602,14 +545,12 @@ diff_months (struct tm lt_start, struct tm lt_end) } /* Calculate the difference in years between two dates. */ -static long -diff_years (struct tm lt_start, struct tm lt_end) +static long diff_years(struct tm lt_start, struct tm lt_end) { return lt_end.tm_year - lt_start.tm_year; } -static int -exc_inday (struct excp *exc, long day_start) +static int exc_inday(struct excp *exc, long day_start) { return (exc->st >= day_start && exc->st < day_start + DAYINSEC); } @@ -624,9 +565,9 @@ exc_inday (struct excp *exc, long day_start) * calculation of recurrent dates after a turn of years. */ unsigned -recur_item_find_occurrence (long item_start, long item_dur, llist_t *item_exc, - int rpt_type, int rpt_freq, long rpt_until, - long day_start, unsigned *occurrence) +recur_item_find_occurrence(long item_start, long item_dur, llist_t * item_exc, + int rpt_type, int rpt_freq, long rpt_until, + long day_start, unsigned *occurrence) { struct date start_date; long diff, span; @@ -640,81 +581,77 @@ recur_item_find_occurrence (long item_start, long item_dur, llist_t *item_exc, return 0; t = day_start; - lt_day = *localtime (&t); + lt_day = *localtime(&t); t = item_start; - lt_item = *localtime (&t); + lt_item = *localtime(&t); lt_item_day = lt_item; lt_item_day.tm_sec = lt_item_day.tm_min = lt_item_day.tm_hour = 0; - span = (item_start - mktime (<_item_day) + item_dur - 1) / DAYINSEC; - - switch (rpt_type) - { - case RECUR_DAILY: - diff = diff_days (lt_item_day, lt_day) % rpt_freq; - lt_item_day.tm_mday = lt_day.tm_mday - diff; - lt_item_day.tm_mon = lt_day.tm_mon; - lt_item_day.tm_year = lt_day.tm_year; - break; - case RECUR_WEEKLY: - diff = diff_days (lt_item_day, lt_day) % (rpt_freq * WEEKINDAYS); - lt_item_day.tm_mday = lt_day.tm_mday - diff; - lt_item_day.tm_mon = lt_day.tm_mon; - lt_item_day.tm_year = lt_day.tm_year; - break; - case RECUR_MONTHLY: - diff = diff_months (lt_item_day, lt_day) % rpt_freq; - if (lt_day.tm_mday < lt_item_day.tm_mday) - diff++; - lt_item_day.tm_mon = lt_day.tm_mon - diff; - lt_item_day.tm_year = lt_day.tm_year; - break; - case RECUR_YEARLY: - diff = diff_years (lt_item_day, lt_day) % rpt_freq; - if (lt_day.tm_mon < lt_item_day.tm_mon || - (lt_day.tm_mon == lt_item_day.tm_mon && - lt_day.tm_mday < lt_item_day.tm_mday)) - diff++; - lt_item_day.tm_year = lt_day.tm_year - diff; - break; - default: - EXIT (_("unknown item type")); - } + span = (item_start - mktime(<_item_day) + item_dur - 1) / DAYINSEC; + + switch (rpt_type) { + case RECUR_DAILY: + diff = diff_days(lt_item_day, lt_day) % rpt_freq; + lt_item_day.tm_mday = lt_day.tm_mday - diff; + lt_item_day.tm_mon = lt_day.tm_mon; + lt_item_day.tm_year = lt_day.tm_year; + break; + case RECUR_WEEKLY: + diff = diff_days(lt_item_day, lt_day) % (rpt_freq * WEEKINDAYS); + lt_item_day.tm_mday = lt_day.tm_mday - diff; + lt_item_day.tm_mon = lt_day.tm_mon; + lt_item_day.tm_year = lt_day.tm_year; + break; + case RECUR_MONTHLY: + diff = diff_months(lt_item_day, lt_day) % rpt_freq; + if (lt_day.tm_mday < lt_item_day.tm_mday) + diff++; + lt_item_day.tm_mon = lt_day.tm_mon - diff; + lt_item_day.tm_year = lt_day.tm_year; + break; + case RECUR_YEARLY: + diff = diff_years(lt_item_day, lt_day) % rpt_freq; + if (lt_day.tm_mon < lt_item_day.tm_mon || + (lt_day.tm_mon == lt_item_day.tm_mon && + lt_day.tm_mday < lt_item_day.tm_mday)) + diff++; + lt_item_day.tm_year = lt_day.tm_year - diff; + break; + default: + EXIT(_("unknown item type")); + } lt_item_day.tm_isdst = lt_day.tm_isdst; - t = mktime (<_item_day); + t = mktime(<_item_day); - if (LLIST_FIND_FIRST (item_exc, t, exc_inday)) + if (LLIST_FIND_FIRST(item_exc, t, exc_inday)) return 0; if (rpt_until != 0 && t > rpt_until) return 0; - lt_item_day = *localtime (&t); - diff = diff_days (lt_item_day, lt_day); - - if (diff <= span) - { - if (occurrence) - { - start_date.dd = lt_item_day.tm_mday; - start_date.mm = lt_item_day.tm_mon + 1; - start_date.yyyy = lt_item_day.tm_year + 1900; + lt_item_day = *localtime(&t); + diff = diff_days(lt_item_day, lt_day); - *occurrence = date2sec (start_date, lt_item.tm_hour, lt_item.tm_min); - } + if (diff <= span) { + if (occurrence) { + start_date.dd = lt_item_day.tm_mday; + start_date.mm = lt_item_day.tm_mon + 1; + start_date.yyyy = lt_item_day.tm_year + 1900; - return 1; + *occurrence = date2sec(start_date, lt_item.tm_hour, lt_item.tm_min); } - else + + return 1; + } else return 0; } unsigned -recur_apoint_find_occurrence (struct recur_apoint *rapt, long day_start, - unsigned *occurrence) +recur_apoint_find_occurrence(struct recur_apoint *rapt, long day_start, + unsigned *occurrence) { return recur_item_find_occurrence(rapt->start, rapt->dur, &rapt->exc, rapt->rpt->type, rapt->rpt->freq, @@ -722,8 +659,8 @@ recur_apoint_find_occurrence (struct recur_apoint *rapt, long day_start, } unsigned -recur_event_find_occurrence (struct recur_event *rev, long day_start, - unsigned *occurrence) +recur_event_find_occurrence(struct recur_event *rev, long day_start, + unsigned *occurrence) { return recur_item_find_occurrence(rev->day, DAYINSEC, &rev->exc, rev->rpt->type, rev->rpt->freq, @@ -732,8 +669,8 @@ recur_event_find_occurrence (struct recur_event *rev, long day_start, /* Check if a recurrent item belongs to the selected day. */ unsigned -recur_item_inday (long item_start, long item_dur, llist_t *item_exc, - int rpt_type, int rpt_freq, long rpt_until, long day_start) +recur_item_inday(long item_start, long item_dur, llist_t * item_exc, + int rpt_type, int rpt_freq, long rpt_until, long day_start) { /* We do not need the (real) start time of the occurrence here, so just * ignore the buffer. */ @@ -741,15 +678,13 @@ recur_item_inday (long item_start, long item_dur, llist_t *item_exc, rpt_freq, rpt_until, day_start, NULL); } -unsigned -recur_apoint_inday(struct recur_apoint *rapt, long day_start) +unsigned recur_apoint_inday(struct recur_apoint *rapt, long day_start) { return recur_item_inday(rapt->start, rapt->dur, &rapt->exc, rapt->rpt->type, rapt->rpt->freq, rapt->rpt->until, day_start); } -unsigned -recur_event_inday(struct recur_event *rev, long day_start) +unsigned recur_event_inday(struct recur_event *rev, long day_start) { return recur_item_inday(rev->day, DAYINSEC, &rev->exc, rev->rpt->type, rev->rpt->freq, rev->rpt->until, day_start); @@ -760,44 +695,40 @@ recur_event_inday(struct recur_event *rev, long day_start) * or delete only one occurence of the recurrent event. */ void -recur_event_erase (long start, unsigned num, unsigned delete_whole, - enum eraseflg flag) +recur_event_erase(long start, unsigned num, unsigned delete_whole, + enum eraseflg flag) { llist_item_t *i; - i = LLIST_FIND_NTH (&recur_elist, num, start, recur_event_inday); + i = LLIST_FIND_NTH(&recur_elist, num, start, recur_event_inday); if (!i) - EXIT (_("event not found")); - struct recur_event *rev = LLIST_GET_DATA (i); - - if (delete_whole) - { - switch (flag) - { - case ERASE_FORCE_ONLY_NOTE: - erase_note (&rev->note); - break; - case ERASE_CUT: - recur_event_free_bkp (); - recur_event_dup (rev, &bkp_cut_recur_event); - erase_note (&rev->note); - /* FALLTHROUGH */ - default: - LLIST_REMOVE (&recur_elist, i); - mem_free (rev->mesg); - if (rev->rpt) - { - mem_free (rev->rpt); - rev->rpt = 0; - } - free_exc_list (&rev->exc); - mem_free (rev); - break; - } + EXIT(_("event not found")); + struct recur_event *rev = LLIST_GET_DATA(i); + + if (delete_whole) { + switch (flag) { + case ERASE_FORCE_ONLY_NOTE: + erase_note(&rev->note); + break; + case ERASE_CUT: + recur_event_free_bkp(); + recur_event_dup(rev, &bkp_cut_recur_event); + erase_note(&rev->note); + /* FALLTHROUGH */ + default: + LLIST_REMOVE(&recur_elist, i); + mem_free(rev->mesg); + if (rev->rpt) { + mem_free(rev->rpt); + rev->rpt = 0; + } + free_exc_list(&rev->exc); + mem_free(rev); + break; } - else - recur_add_exc (&rev->exc, start); + } else + recur_add_exc(&rev->exc, start); } /* @@ -805,55 +736,50 @@ recur_event_erase (long start, unsigned num, unsigned delete_whole, * or delete only one occurence of the recurrent appointment. */ void -recur_apoint_erase (long start, unsigned num, unsigned delete_whole, - enum eraseflg flag) +recur_apoint_erase(long start, unsigned num, unsigned delete_whole, + enum eraseflg flag) { llist_item_t *i; int need_check_notify = 0; - i = LLIST_TS_FIND_NTH (&recur_alist_p, num, start, recur_apoint_inday); + i = LLIST_TS_FIND_NTH(&recur_alist_p, num, start, recur_apoint_inday); 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) - { - switch (flag) - { - case ERASE_FORCE_ONLY_NOTE: - erase_note (&rapt->note); - break; - case ERASE_CUT: - recur_apoint_free_bkp (); - recur_apoint_dup (rapt, &bkp_cut_recur_apoint); - erase_note (&rapt->note); - /* FALLTHROUGH */ - default: - LLIST_TS_REMOVE (&recur_alist_p, i); - mem_free (rapt->mesg); - if (rapt->rpt) - { - mem_free (rapt->rpt); - rapt->rpt = 0; - } - free_exc_list (&rapt->exc); - mem_free (rapt); - if (need_check_notify) - notify_check_next_app (0); - break; - } - } - else - { - recur_add_exc (&rapt->exc, start); + 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) { + switch (flag) { + case ERASE_FORCE_ONLY_NOTE: + erase_note(&rapt->note); + break; + case ERASE_CUT: + recur_apoint_free_bkp(); + recur_apoint_dup(rapt, &bkp_cut_recur_apoint); + erase_note(&rapt->note); + /* FALLTHROUGH */ + default: + LLIST_TS_REMOVE(&recur_alist_p, i); + mem_free(rapt->mesg); + if (rapt->rpt) { + mem_free(rapt->rpt); + rapt->rpt = 0; + } + free_exc_list(&rapt->exc); + mem_free(rapt); if (need_check_notify) - notify_check_next_app (0); + notify_check_next_app(0); + break; } - LLIST_TS_UNLOCK (&recur_alist_p); + } else { + recur_add_exc(&rapt->exc, start); + if (need_check_notify) + notify_check_next_app(0); + } + LLIST_TS_UNLOCK(&recur_alist_p); } /* @@ -863,8 +789,7 @@ recur_apoint_erase (long start, unsigned num, unsigned delete_whole, * o repetition end date * and then delete the selected item to recreate it as a recurrent one */ -void -recur_repeat_item (void) +void recur_repeat_item(void) { struct tm *lt; time_t t; @@ -882,22 +807,19 @@ recur_repeat_item (void) const char *mesg_freq_1 = _("Enter the repetition frequence:"); const char *mesg_wrong_freq = _("The frequence you entered is not valid."); const char *mesg_until_1 = - _("Enter the ending date: [%s] or '0' for an endless repetition"); + _("Enter the ending date: [%s] or '0' for an endless repetition"); const char *mesg_wrong_1 = _("The entered date is not valid."); const char *mesg_wrong_2 = - _("Possible formats are [%s] or '0' for an endless repetition"); + _("Possible formats are [%s] or '0' for an endless repetition"); const char *wrong_type_1 = _("This item is already a repeated one."); const char *wrong_type_2 = _("Press [ENTER] to continue."); const char *mesg_older = - _("Sorry, the date you entered is older than the item start time."); + _("Sorry, the date you entered is older than the item start time."); char msg_asktype[BUFSIZ]; - snprintf (msg_asktype, BUFSIZ, "%s %s, %s, %s, %s", - msg_rpt_prefix, - msg_rpt_daily, - msg_rpt_weekly, - msg_rpt_monthly, - msg_rpt_yearly); + snprintf(msg_asktype, BUFSIZ, "%s %s, %s, %s, %s", + msg_rpt_prefix, + msg_rpt_daily, msg_rpt_weekly, msg_rpt_monthly, msg_rpt_yearly); int type = 0, freq = 0; int item_nb; @@ -905,151 +827,123 @@ recur_repeat_item (void) struct recur_apoint *ra; long until, date; - item_nb = apoint_hilt (); - p = day_get_item (item_nb); - if (p->type != APPT && p->type != EVNT) - { - status_mesg (wrong_type_1, wrong_type_2); - wgetch (win[STA].p); - return; - } - - switch (status_ask_choice (msg_asktype, msg_type_choice, 4)) - { - case 1: - type = RECUR_DAILY; - break; - case 2: - type = RECUR_WEEKLY; - break; - case 3: - type = RECUR_MONTHLY; - break; - case 4: - type = RECUR_YEARLY; - break; - default: + item_nb = apoint_hilt(); + p = day_get_item(item_nb); + if (p->type != APPT && p->type != EVNT) { + status_mesg(wrong_type_1, wrong_type_2); + wgetch(win[STA].p); + return; + } + + switch (status_ask_choice(msg_asktype, msg_type_choice, 4)) { + case 1: + type = RECUR_DAILY; + break; + case 2: + type = RECUR_WEEKLY; + break; + case 3: + type = RECUR_MONTHLY; + break; + case 4: + type = RECUR_YEARLY; + break; + default: + return; + } + + while (freq == 0) { + status_mesg(mesg_freq_1, ""); + if (getstring(win[STA].p, user_input, BUFSIZ, 0, 1) == GETSTRING_VALID) { + freq = atoi(user_input); + if (freq == 0) { + status_mesg(mesg_wrong_freq, wrong_type_2); + wgetch(win[STA].p); + } + user_input[0] = '\0'; + } else return; - } - - while (freq == 0) - { - status_mesg (mesg_freq_1, ""); - if (getstring (win[STA].p, user_input, BUFSIZ, 0, 1) == GETSTRING_VALID) - { - freq = atoi (user_input); - if (freq == 0) - { - status_mesg (mesg_wrong_freq, wrong_type_2); - wgetch (win[STA].p); - } - user_input[0] = '\0'; - } - else - return; - } - - while (!date_entered) - { - snprintf (outstr, BUFSIZ, mesg_until_1, - DATEFMT_DESC (conf.input_datefmt)); - status_mesg (_(outstr), ""); - if (getstring (win[STA].p, user_input, BUFSIZ, 0, 1) == GETSTRING_VALID) - { - if (strlen (user_input) == 1 && strcmp (user_input, "0") == 0) - { - until = 0; - date_entered = 1; - } - else - { - if (parse_date (user_input, conf.input_datefmt, - &year, &month, &day, calendar_get_slctd_day ())) - { - t = p->start; - lt = localtime (&t); - until_date.dd = day; - until_date.mm = month; - until_date.yyyy = year; - until = date2sec (until_date, lt->tm_hour, lt->tm_min); - if (until < p->start) - { - status_mesg (mesg_older, wrong_type_2); - wgetch (win[STA].p); - date_entered = 0; - } - else - { - date_entered = 1; - } - } - else - { - snprintf (outstr, BUFSIZ, mesg_wrong_2, - DATEFMT_DESC (conf.input_datefmt)); - status_mesg (mesg_wrong_1, _(outstr)); - wgetch (win[STA].p); - date_entered = 0; - } - } + } + + while (!date_entered) { + snprintf(outstr, BUFSIZ, mesg_until_1, DATEFMT_DESC(conf.input_datefmt)); + status_mesg(_(outstr), ""); + if (getstring(win[STA].p, user_input, BUFSIZ, 0, 1) == GETSTRING_VALID) { + if (strlen(user_input) == 1 && strcmp(user_input, "0") == 0) { + until = 0; + date_entered = 1; + } else { + if (parse_date(user_input, conf.input_datefmt, + &year, &month, &day, calendar_get_slctd_day())) { + t = p->start; + lt = localtime(&t); + until_date.dd = day; + until_date.mm = month; + until_date.yyyy = year; + until = date2sec(until_date, lt->tm_hour, lt->tm_min); + if (until < p->start) { + status_mesg(mesg_older, wrong_type_2); + wgetch(win[STA].p); + date_entered = 0; + } else { + date_entered = 1; + } + } else { + snprintf(outstr, BUFSIZ, mesg_wrong_2, + DATEFMT_DESC(conf.input_datefmt)); + status_mesg(mesg_wrong_1, _(outstr)); + wgetch(win[STA].p); + date_entered = 0; } - else - return; - } - - date = calendar_get_slctd_day_sec (); - if (p->type == EVNT) - { - recur_event_new (p->mesg, p->note, p->start, p->evnt_id, type, freq, - until, NULL); - } - else if (p->type == APPT) - { - ra = recur_apoint_new (p->mesg, p->note, p->start, p->appt_dur, - p->state, type, freq, until, NULL); - if (notify_bar ()) - notify_check_repeated (ra); - } - else - { - EXIT (_("wrong item type")); - /* NOTREACHED */ - } - day_erase_item (date, item_nb, ERASE_FORCE); + } + } else + return; + } + + date = calendar_get_slctd_day_sec(); + if (p->type == EVNT) { + recur_event_new(p->mesg, p->note, p->start, p->evnt_id, type, freq, + until, NULL); + } else if (p->type == APPT) { + ra = recur_apoint_new(p->mesg, p->note, p->start, p->appt_dur, + p->state, type, freq, until, NULL); + if (notify_bar()) + notify_check_repeated(ra); + } else { + EXIT(_("wrong item type")); + /* NOTREACHED */ + } + day_erase_item(date, item_nb, ERASE_FORCE); } /* * Read days for which recurrent items must not be repeated * (such days are called exceptions). */ -void -recur_exc_scan (llist_t *lexc, FILE *data_file) +void recur_exc_scan(llist_t * lexc, FILE * data_file) { int c = 0; struct tm day; - LLIST_INIT (lexc); - while ((c = getc (data_file)) == '!') - { - ungetc (c, data_file); - if (fscanf (data_file, "!%d / %d / %d ", - &day.tm_mon, &day.tm_mday, &day.tm_year) != 3) - { - EXIT (_("syntax error in item date")); - } - day.tm_hour = 0; - day.tm_min = day.tm_sec = 0; - day.tm_isdst = -1; - day.tm_year -= 1900; - day.tm_mon--; - struct excp *exc = mem_malloc (sizeof (struct excp)); - exc->st = mktime (&day); - LLIST_ADD (lexc, exc); + LLIST_INIT(lexc); + while ((c = getc(data_file)) == '!') { + ungetc(c, data_file); + if (fscanf(data_file, "!%d / %d / %d ", + &day.tm_mon, &day.tm_mday, &day.tm_year) != 3) { + EXIT(_("syntax error in item date")); } + day.tm_hour = 0; + day.tm_min = day.tm_sec = 0; + day.tm_isdst = -1; + day.tm_year -= 1900; + day.tm_mon--; + struct excp *exc = mem_malloc(sizeof(struct excp)); + exc->st = mktime(&day); + LLIST_ADD(lexc, exc); + } } -static int -recur_apoint_starts_before (struct recur_apoint *rapt, long time) +static int recur_apoint_starts_before(struct recur_apoint *rapt, long time) { return rapt->start < time; } @@ -1058,135 +952,126 @@ recur_apoint_starts_before (struct recur_apoint *rapt, 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 * -recur_apoint_check_next (struct notify_app *app, long start, long day) +struct notify_app *recur_apoint_check_next(struct notify_app *app, long start, + long day) { llist_item_t *i; unsigned real_recur_start_time; - LLIST_TS_LOCK (&recur_alist_p); - LLIST_TS_FIND_FOREACH (&recur_alist_p, app->time, recur_apoint_starts_before, i) - { - struct recur_apoint *rapt = LLIST_TS_GET_DATA (i); - - if (recur_apoint_find_occurrence (rapt, day, &real_recur_start_time) && - real_recur_start_time > start) - { - app->time = real_recur_start_time; - app->txt = mem_strdup (rapt->mesg); - app->state = rapt->state; - app->got_app = 1; - } + LLIST_TS_LOCK(&recur_alist_p); + LLIST_TS_FIND_FOREACH(&recur_alist_p, app->time, recur_apoint_starts_before, + i) { + struct recur_apoint *rapt = LLIST_TS_GET_DATA(i); + + if (recur_apoint_find_occurrence(rapt, day, &real_recur_start_time) && + real_recur_start_time > start) { + app->time = real_recur_start_time; + app->txt = mem_strdup(rapt->mesg); + app->state = rapt->state; + app->got_app = 1; } - LLIST_TS_UNLOCK (&recur_alist_p); + } + LLIST_TS_UNLOCK(&recur_alist_p); return app; } /* Returns a structure containing the selected recurrent appointment. */ -struct recur_apoint * -recur_get_apoint (long date, int num) +struct recur_apoint *recur_get_apoint(long date, int num) { - llist_item_t *i = LLIST_TS_FIND_NTH (&recur_alist_p, num, date, + llist_item_t *i = LLIST_TS_FIND_NTH(&recur_alist_p, num, date, recur_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 */ } /* Returns a structure containing the selected recurrent event. */ -struct recur_event * -recur_get_event (long date, int num) +struct recur_event *recur_get_event(long date, int num) { - llist_item_t *i = LLIST_FIND_NTH (&recur_elist, num, date, - recur_event_inday); + llist_item_t *i = LLIST_FIND_NTH(&recur_elist, num, date, + recur_event_inday); if (i) - return LLIST_GET_DATA (i); + return LLIST_GET_DATA(i); - EXIT (_("item not found")); + EXIT(_("item not found")); /* NOTREACHED */ } /* Switch recurrent item notification state. */ -void -recur_apoint_switch_notify (long date, int recur_nb) +void recur_apoint_switch_notify(long date, int recur_nb) { llist_item_t *i; - LLIST_TS_LOCK (&recur_alist_p); - i = LLIST_TS_FIND_NTH (&recur_alist_p, recur_nb, date, recur_apoint_inday); + LLIST_TS_LOCK(&recur_alist_p); + i = LLIST_TS_FIND_NTH(&recur_alist_p, recur_nb, date, recur_apoint_inday); if (!i) - EXIT (_("item not found")); - struct recur_apoint *rapt = LLIST_TS_GET_DATA (i); + EXIT(_("item not found")); + struct recur_apoint *rapt = LLIST_TS_GET_DATA(i); rapt->state ^= APOINT_NOTIFY; - if (notify_bar ()) - notify_check_repeated (rapt); + if (notify_bar()) + notify_check_repeated(rapt); - LLIST_TS_UNLOCK (&recur_alist_p); + LLIST_TS_UNLOCK(&recur_alist_p); } -void -recur_event_paste_item (void) +void recur_event_paste_item(void) { long new_start, time_shift; llist_item_t *i; - new_start = date2sec (*calendar_get_slctd_day (), 0, 0); + new_start = date2sec(*calendar_get_slctd_day(), 0, 0); time_shift = new_start - bkp_cut_recur_event.day; bkp_cut_recur_event.day += time_shift; if (bkp_cut_recur_event.rpt->until != 0) bkp_cut_recur_event.rpt->until += time_shift; - LLIST_FOREACH (&bkp_cut_recur_event.exc, i) - { - struct excp *exc = LLIST_GET_DATA (i); - exc->st += time_shift; - } - - recur_event_new (bkp_cut_recur_event.mesg, bkp_cut_recur_event.note, - bkp_cut_recur_event.day, bkp_cut_recur_event.id, - bkp_cut_recur_event.rpt->type, - bkp_cut_recur_event.rpt->freq, - bkp_cut_recur_event.rpt->until, &bkp_cut_recur_event.exc); - recur_event_free_bkp (); + LLIST_FOREACH(&bkp_cut_recur_event.exc, i) { + struct excp *exc = LLIST_GET_DATA(i); + exc->st += time_shift; + } + + recur_event_new(bkp_cut_recur_event.mesg, bkp_cut_recur_event.note, + bkp_cut_recur_event.day, bkp_cut_recur_event.id, + bkp_cut_recur_event.rpt->type, + bkp_cut_recur_event.rpt->freq, + bkp_cut_recur_event.rpt->until, &bkp_cut_recur_event.exc); + recur_event_free_bkp(); } -void -recur_apoint_paste_item (void) +void recur_apoint_paste_item(void) { long new_start, time_shift; llist_item_t *i; - new_start = date2sec (*calendar_get_slctd_day (), - get_item_hour (bkp_cut_recur_apoint.start), - get_item_min (bkp_cut_recur_apoint.start)); + new_start = date2sec(*calendar_get_slctd_day(), + get_item_hour(bkp_cut_recur_apoint.start), + get_item_min(bkp_cut_recur_apoint.start)); time_shift = new_start - bkp_cut_recur_apoint.start; bkp_cut_recur_apoint.start += time_shift; if (bkp_cut_recur_apoint.rpt->until != 0) bkp_cut_recur_apoint.rpt->until += time_shift; - LLIST_FOREACH (&bkp_cut_recur_event.exc, i) - { - struct excp *exc = LLIST_GET_DATA (i); - exc->st += time_shift; - } + LLIST_FOREACH(&bkp_cut_recur_event.exc, i) { + struct excp *exc = LLIST_GET_DATA(i); + exc->st += time_shift; + } - recur_apoint_new (bkp_cut_recur_apoint.mesg, bkp_cut_recur_apoint.note, - bkp_cut_recur_apoint.start, bkp_cut_recur_apoint.dur, - bkp_cut_recur_apoint.state, bkp_cut_recur_apoint.rpt->type, - bkp_cut_recur_apoint.rpt->freq, - bkp_cut_recur_apoint.rpt->until, - &bkp_cut_recur_apoint.exc); + recur_apoint_new(bkp_cut_recur_apoint.mesg, bkp_cut_recur_apoint.note, + bkp_cut_recur_apoint.start, bkp_cut_recur_apoint.dur, + bkp_cut_recur_apoint.state, bkp_cut_recur_apoint.rpt->type, + bkp_cut_recur_apoint.rpt->freq, + bkp_cut_recur_apoint.rpt->until, &bkp_cut_recur_apoint.exc); - if (notify_bar ()) - notify_check_repeated (&bkp_cut_recur_apoint); + if (notify_bar()) + notify_check_repeated(&bkp_cut_recur_apoint); - recur_apoint_free_bkp (); + recur_apoint_free_bkp(); } |