1 files changed, 490 insertions, 468 deletions

diff --git a/src/notify.c b/src/notify.c
index 0befe8b..0634db1 100755
--- a/src/notify.c
+++ b/src/notify.c
@@ -1,8 +1,8 @@
-/*	$calcurse: notify.c,v 1.24 2008/02/10 16:29:50 culot Exp $	*/
+/*	$calcurse: notify.c,v 1.25 2008/04/12 21:14:03 culot Exp $	*/
 
 /*
  * Calcurse - text-based organizer
- * Copyright (c) 2004-2007 Frederic Culot
+ * Copyright (c) 2004-2008 Frederic Culot
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -39,51 +39,52 @@ static struct notify_app_s *notify_app = NULL;
 static pthread_t notify_t_main;
 
 /* Return 1 if we need to display the notify-bar, else 0. */
-int 
-notify_bar(void)
+int
+notify_bar (void)
 {
-	int display_bar = 0;
+  int display_bar = 0;
 
-	pthread_mutex_lock(&nbar->mutex);
-	display_bar = (nbar->show) ? 1 : 0;
-	pthread_mutex_unlock(&nbar->mutex);
-	
-	return display_bar;
+  pthread_mutex_lock (&nbar->mutex);
+  display_bar = (nbar->show) ? 1 : 0;
+  pthread_mutex_unlock (&nbar->mutex);
+
+  return (display_bar);
 }
 
 /* Initialize the nbar variable used to store notification options. */
-void 
-notify_init_vars(void)
+void
+notify_init_vars (void)
 {
-	char *time_format = "%T";
-	char *date_format = "%a %F";
-	char *cmd = "printf '\\a'";
-
-	nbar = (struct nbar_s *) malloc(sizeof(struct nbar_s));
-	pthread_mutex_init(&nbar->mutex, NULL);
-	nbar->show = 1;
-	nbar->cntdwn = 300; 
-	strncpy(nbar->datefmt, date_format, strlen(date_format) + 1); 
-	strncpy(nbar->timefmt, time_format, strlen(time_format) + 1);
-	strncpy(nbar->cmd, cmd, strlen(cmd) + 1);
-
-	if ((nbar->shell = getenv("SHELL")) == NULL)
-		nbar->shell = "/bin/sh"; 
+  char *time_format = "%T";
+  char *date_format = "%a %F";
+  char *cmd = "printf '\\a'";
+
+  nbar = (struct nbar_s *) malloc (sizeof (struct nbar_s));
+  pthread_mutex_init (&nbar->mutex, NULL);
+  nbar->show = 1;
+  nbar->cntdwn = 300;
+  strncpy (nbar->datefmt, date_format, strlen (date_format) + 1);
+  strncpy (nbar->timefmt, time_format, strlen (time_format) + 1);
+  strncpy (nbar->cmd, cmd, strlen (cmd) + 1);
+
+  if ((nbar->shell = getenv ("SHELL")) == NULL)
+    nbar->shell = "/bin/sh";
 }
 
 /* Extract the appointment file name from the complete file path. */
-static void 
-extract_aptsfile(void)
+static void
+extract_aptsfile (void)
 {
-	char *file;
-
-	file = strrchr(path_apts, '/');
-	if (!file)
-		notify->apts_file = path_apts;
-	else {
-		notify->apts_file = file;
-		notify->apts_file++;
-	}
+  char *file;
+
+  file = strrchr (path_apts, '/');
+  if (!file)
+    notify->apts_file = path_apts;
+  else
+    {
+      notify->apts_file = file;
+      notify->apts_file++;
+    }
 }
 
 /* 
@@ -91,510 +92,531 @@ extract_aptsfile(void)
  * creating the notification window (l is the number of lines, c the
  * number of columns, y and x are its coordinates). 
  */
-void 
-notify_init_bar(void)
+void
+notify_init_bar (void)
 {
-	notify = (struct notify_vars_s *) malloc(sizeof(struct notify_vars_s));	
-	notify_app = (struct notify_app_s *) 
-	    malloc(sizeof(struct notify_app_s));
-	pthread_mutex_init(&notify->mutex, NULL);
-	pthread_mutex_init(&notify_app->mutex, NULL);
-	notify_app->got_app = 0;
-	notify->win = newwin(win[NOT].h, win[NOT].w, win[NOT].y, win[NOT].x);
-	extract_aptsfile();
+  notify = (struct notify_vars_s *) malloc (sizeof (struct notify_vars_s));
+  notify_app = (struct notify_app_s *) malloc (sizeof (struct notify_app_s));
+  pthread_mutex_init (&notify->mutex, NULL);
+  pthread_mutex_init (&notify_app->mutex, NULL);
+  notify_app->got_app = 0;
+  notify->win = newwin (win[NOT].h, win[NOT].w, win[NOT].y, win[NOT].x);
+  extract_aptsfile ();
 }
 
 /* Stop the notify-bar main thread. */
-void 
-notify_stop_main_thread(void)
+void
+notify_stop_main_thread (void)
 {
-	pthread_cancel(notify_t_main);
-	return;
+  pthread_cancel (notify_t_main);
+  return;
 }
 
 /* 
  * The calcurse window geometry has changed so we need to reset the 
  * notification window. 
  */
-void 
-notify_reinit_bar(int l, int c, int y, int x)
+void
+notify_reinit_bar (int l, int c, int y, int x)
 {
-	delwin(notify->win);
-	notify->win = newwin(l, c, y, x);
+  delwin (notify->win);
+  notify->win = newwin (l, c, y, x);
 }
 
 /* Launch user defined command as a notification. */
 static void
-launch_cmd(char *cmd, char *shell)
+launch_cmd (char *cmd, char *shell)
 {
-	int pid;
-
-	pid = fork();
-	
-	if (pid < 0)
-		ierror(_("FATAL ERROR in launch_cmd: could not fork"),
-		    IERROR_WARN);
-	else if (pid == 0) /* Child: launch user defined command */
-		if (execlp(shell, shell, "-c", cmd, (char *)NULL) < 0)
-			ierror(_("FATAL ERROR in launch_cmd: could not "
-			    "launch user command"),
-			    IERROR_WARN);
+  int pid;
+
+  pid = fork ();
+
+  if (pid < 0)
+    ierror (_("FATAL ERROR in launch_cmd: could not fork"), IERROR_WARN);
+  else if (pid == 0)		/* Child: launch user defined command */
+    if (execlp (shell, shell, "-c", cmd, (char *) NULL) < 0)
+      ierror (_("FATAL ERROR in launch_cmd: could not "
+		"launch user command"), IERROR_WARN);
 }
 
 /* 
  * Update the notification bar. This is useful when changing color theme
  * for example.
  */
-void 
-notify_update_bar(void)
+void
+notify_update_bar (void)
 {
-	const int space = 3;
-	int file_pos, date_pos, app_pos, txt_max_len, too_long = 0;
-	int time_left, hours_left, minutes_left;
-	int blinking;
-	char buf[BUFSIZ];
-	
-	date_pos = space;
-	pthread_mutex_lock(&notify->mutex);
-
-	file_pos = strlen(notify->date) + strlen(notify->time) + 7 + 2*space;
-	app_pos = file_pos + strlen(notify->apts_file) + 2 + space;
-	txt_max_len = col - (app_pos + 12 + space);
-
-	custom_apply_attr(notify->win, ATTR_HIGHEST);
-	wattron(notify->win, A_UNDERLINE | A_REVERSE);
-	mvwhline(notify->win, 0, 0, ACS_HLINE, col);
-	mvwprintw(notify->win, 0, date_pos, "[ %s | %s ]", 
-		notify->date, notify->time);
-	mvwprintw(notify->win, 0, file_pos, "(%s)", notify->apts_file);
-
-	pthread_mutex_lock(&notify_app->mutex);
-	if (notify_app->got_app) {
-		if (strlen(notify_app->txt) > txt_max_len) {
-			too_long = 1;
-			strncpy(buf, notify_app->txt, txt_max_len - 3);
-			buf[txt_max_len - 3] = '\0';
-		}
-		
-		time_left = notify_app->time - notify->time_in_sec; 
-		if (time_left > 0) {
-			hours_left = (time_left / HOURINSEC);
-			minutes_left = (time_left - hours_left * HOURINSEC) / 
-			    MININSEC;
-			pthread_mutex_lock(&nbar->mutex);
-
-			if (time_left < nbar->cntdwn &&
-			    (notify_app->state & APOINT_NOTIFY))
-				blinking = 1;
-			else
-				blinking = 0;
-
-			if (blinking)
-				wattron(notify->win, A_BLINK);
-			if (too_long) 	
-				mvwprintw(notify->win, 0, app_pos, 
-			            "> %02d:%02d :: %s.. <", 
-			            hours_left, minutes_left, buf);
-			else
-				mvwprintw(notify->win, 0, app_pos, 
-			            "> %02d:%02d :: %s <", 
-			            hours_left, minutes_left, 
-				    notify_app->txt);
-			if (blinking)
-				wattroff(notify->win, A_BLINK);
-
-			if (blinking && 
-			    !(notify_app->state & APOINT_NOTIFIED)) {
-				notify_app->state |= APOINT_NOTIFIED;
-				launch_cmd(nbar->cmd, nbar->shell);
-			}
-			pthread_mutex_unlock(&nbar->mutex);
-		} else {
-			notify_app->got_app = 0;
-			pthread_mutex_unlock(&notify_app->mutex);
-			pthread_mutex_unlock(&notify->mutex);
-			notify_check_next_app();
-			return;
-		}
+  const int space = 3;
+  int file_pos, date_pos, app_pos, txt_max_len, too_long = 0;
+  int time_left, hours_left, minutes_left;
+  int blinking;
+  char buf[BUFSIZ];
+
+  date_pos = space;
+  pthread_mutex_lock (&notify->mutex);
+
+  file_pos = strlen (notify->date) + strlen (notify->time) + 7 + 2 * space;
+  app_pos = file_pos + strlen (notify->apts_file) + 2 + space;
+  txt_max_len = col - (app_pos + 12 + space);
+
+  custom_apply_attr (notify->win, ATTR_HIGHEST);
+  wattron (notify->win, A_UNDERLINE | A_REVERSE);
+  mvwhline (notify->win, 0, 0, ACS_HLINE, col);
+  mvwprintw (notify->win, 0, date_pos, "[ %s | %s ]",
+	     notify->date, notify->time);
+  mvwprintw (notify->win, 0, file_pos, "(%s)", notify->apts_file);
+
+  pthread_mutex_lock (&notify_app->mutex);
+  if (notify_app->got_app)
+    {
+      if (strlen (notify_app->txt) > txt_max_len)
+	{
+	  too_long = 1;
+	  strncpy (buf, notify_app->txt, txt_max_len - 3);
+	  buf[txt_max_len - 3] = '\0';
+	}
+      time_left = notify_app->time - notify->time_in_sec;
+      if (time_left > 0)
+	{
+	  hours_left = (time_left / HOURINSEC);
+	  minutes_left = (time_left - hours_left * HOURINSEC) / MININSEC;
+	  pthread_mutex_lock (&nbar->mutex);
+
+	  if (time_left < nbar->cntdwn && (notify_app->state & APOINT_NOTIFY))
+	    blinking = 1;
+	  else
+	    blinking = 0;
+
+	  if (blinking)
+	    wattron (notify->win, A_BLINK);
+	  if (too_long)
+	    mvwprintw (notify->win, 0, app_pos, "> %02d:%02d :: %s.. <",
+		       hours_left, minutes_left, buf);
+	  else
+	    mvwprintw (notify->win, 0, app_pos, "> %02d:%02d :: %s <",
+		       hours_left, minutes_left, notify_app->txt);
+	  if (blinking)
+	    wattroff (notify->win, A_BLINK);
+
+	  if (blinking && !(notify_app->state & APOINT_NOTIFIED))
+	    {
+	      notify_app->state |= APOINT_NOTIFIED;
+	      launch_cmd (nbar->cmd, nbar->shell);
+	    }
+	  pthread_mutex_unlock (&nbar->mutex);
 	}
-	pthread_mutex_unlock(&notify_app->mutex);
+      else
+	{
+	  notify_app->got_app = 0;
+	  pthread_mutex_unlock (&notify_app->mutex);
+	  pthread_mutex_unlock (&notify->mutex);
+	  notify_check_next_app ();
+	  return;
+	}
+    }
+  pthread_mutex_unlock (&notify_app->mutex);
 
-	wattroff(notify->win, A_UNDERLINE | A_REVERSE);
-	custom_remove_attr(notify->win, ATTR_HIGHEST);
-	wrefresh(notify->win);
+  wattroff (notify->win, A_UNDERLINE | A_REVERSE);
+  custom_remove_attr (notify->win, ATTR_HIGHEST);
+  wrefresh (notify->win);
 
-	pthread_mutex_unlock(&notify->mutex);
+  pthread_mutex_unlock (&notify->mutex);
 }
 
 /* Update the notication bar content */
 static void *
-notify_main_thread(void *arg)
+notify_main_thread (void *arg)
 {
-	const unsigned thread_sleep = 1;
-	const unsigned check_app = MININSEC;
-	int elapse= 0, got_app = 0;
-	struct tm *ntime;
-	time_t ntimer;
-
-	elapse = 0;
-	got_app = 0;
-
-	for (;;) {
-		ntimer = time(NULL);
-		ntime = localtime(&ntimer);
-		pthread_mutex_lock(&notify->mutex);
-		notify->time_in_sec = ntimer;
-		pthread_mutex_lock(&nbar->mutex);
-		strftime(notify->time, NOTIFY_FIELD_LENGTH, nbar->timefmt, ntime);
-		strftime(notify->date, NOTIFY_FIELD_LENGTH, nbar->datefmt, ntime);
-		pthread_mutex_unlock(&nbar->mutex);
-		pthread_mutex_unlock(&notify->mutex);
-		notify_update_bar();
-		sleep(thread_sleep);
-		elapse += thread_sleep;
-		if (elapse >= check_app) {
-			elapse = 0;
-			pthread_mutex_lock(&notify_app->mutex);
-			got_app = notify_app->got_app;
-			pthread_mutex_unlock(&notify_app->mutex);
-			if (!got_app) 
-				notify_check_next_app();
-		}
+  const unsigned thread_sleep = 1;
+  const unsigned check_app = MININSEC;
+  int elapse = 0, got_app = 0;
+  struct tm *ntime;
+  time_t ntimer;
+
+  elapse = 0;
+  got_app = 0;
+
+  for (;;)
+    {
+      ntimer = time (NULL);
+      ntime = localtime (&ntimer);
+      pthread_mutex_lock (&notify->mutex);
+      notify->time_in_sec = ntimer;
+      pthread_mutex_lock (&nbar->mutex);
+      strftime (notify->time, NOTIFY_FIELD_LENGTH, nbar->timefmt, ntime);
+      strftime (notify->date, NOTIFY_FIELD_LENGTH, nbar->datefmt, ntime);
+      pthread_mutex_unlock (&nbar->mutex);
+      pthread_mutex_unlock (&notify->mutex);
+      notify_update_bar ();
+      sleep (thread_sleep);
+      elapse += thread_sleep;
+      if (elapse >= check_app)
+	{
+	  elapse = 0;
+	  pthread_mutex_lock (&notify_app->mutex);
+	  got_app = notify_app->got_app;
+	  pthread_mutex_unlock (&notify_app->mutex);
+	  if (!got_app)
+	    notify_check_next_app ();
 	}
-	pthread_exit((void*) 0);
+    }
+  pthread_exit ((void *) 0);
 }
 
 /* Look for the next appointment within the next 24 hours. */
 static void *
-notify_thread_app(void *arg)
+notify_thread_app (void *arg)
 {
-	struct notify_app_s *tmp_app;
-	time_t current_time;
-
-	current_time = time(NULL);
-
-	/* Use a temporary structure not to lock the mutex for a too
-	 * long time while looking for next appointment. */
-	tmp_app = (struct notify_app_s *) malloc(sizeof(struct notify_app_s));
-	tmp_app->time = current_time + DAYINSEC;
-	tmp_app->got_app = 0;
-	tmp_app->txt = NULL;
-	tmp_app = recur_apoint_check_next(tmp_app, current_time, get_today());
-	tmp_app = apoint_check_next(tmp_app, current_time);
-
-	pthread_mutex_lock(&notify_app->mutex);
-	if (tmp_app->got_app) {
-		notify_app->got_app = 1;
-		notify_app->time = tmp_app->time;
-		notify_app->txt = mycpy(tmp_app->txt);
-		notify_app->state = tmp_app->state;
-	} else {
-		notify_app->got_app = 0;
-	}
-	pthread_mutex_unlock(&notify_app->mutex);
-
-	if (tmp_app->txt != NULL)
-		free(tmp_app->txt);
-	free(tmp_app);
-	notify_update_bar();
-
-	pthread_exit((void*) 0);
+  struct notify_app_s *tmp_app;
+  time_t current_time;
+
+  current_time = time (NULL);
+
+  /* Use a temporary structure not to lock the mutex for a too
+   * long time while looking for next appointment. */
+  tmp_app = (struct notify_app_s *) malloc (sizeof (struct notify_app_s));
+  tmp_app->time = current_time + DAYINSEC;
+  tmp_app->got_app = 0;
+  tmp_app->txt = NULL;
+  tmp_app = recur_apoint_check_next (tmp_app, current_time, get_today ());
+  tmp_app = apoint_check_next (tmp_app, current_time);
+
+  pthread_mutex_lock (&notify_app->mutex);
+  if (tmp_app->got_app)
+    {
+      notify_app->got_app = 1;
+      notify_app->time = tmp_app->time;
+      notify_app->txt = mycpy (tmp_app->txt);
+      notify_app->state = tmp_app->state;
+    }
+  else
+    {
+      notify_app->got_app = 0;
+    }
+  pthread_mutex_unlock (&notify_app->mutex);
+
+  if (tmp_app->txt != NULL)
+    free (tmp_app->txt);
+  free (tmp_app);
+  notify_update_bar ();
+
+  pthread_exit ((void *) 0);
 }
 
 /* Launch the thread notify_thread_app to look for next appointment. */
-void 
-notify_check_next_app(void)
+void
+notify_check_next_app (void)
 {
-	pthread_t notify_t_app;
+  pthread_t notify_t_app;
 
-	pthread_create(&notify_t_app, NULL, notify_thread_app, NULL);
-	return;
+  pthread_create (&notify_t_app, NULL, notify_thread_app, NULL);
+  return;
 }
 
 /* Check if the newly created appointment is to be notified. */
-void 
-notify_check_added(char *mesg, long start, char state)
+void
+notify_check_added (char *mesg, long start, char state)
 {
-	time_t current_time;
-	int update_notify = 0;
-	long gap;
-
-	current_time = time(NULL);
-	pthread_mutex_lock(&notify_app->mutex);
-	if (!notify_app->got_app) {
-		gap = start - current_time;
-		if (gap >= 0 && gap <= DAYINSEC) 
-			update_notify = 1;
-	} else if (start < notify_app->time && start >= current_time) {
-		update_notify = 1;
-	} else if (start == notify_app->time && state != notify_app->state)
-		update_notify = 1;
-
-	if (update_notify) {
-		notify_app->got_app = 1;
-		notify_app->time = start;
-		notify_app->txt = mycpy(mesg);	
-		notify_app->state = state;
-	}
-	pthread_mutex_unlock(&notify_app->mutex);
-	notify_update_bar();
+  time_t current_time;
+  int update_notify = 0;
+  long gap;
+
+  current_time = time (NULL);
+  pthread_mutex_lock (&notify_app->mutex);
+  if (!notify_app->got_app)
+    {
+      gap = start - current_time;
+      if (gap >= 0 && gap <= DAYINSEC)
+	update_notify = 1;
+    }
+  else if (start < notify_app->time && start >= current_time)
+    {
+      update_notify = 1;
+    }
+  else if (start == notify_app->time && state != notify_app->state)
+    update_notify = 1;
+
+  if (update_notify)
+    {
+      notify_app->got_app = 1;
+      notify_app->time = start;
+      notify_app->txt = mycpy (mesg);
+      notify_app->state = state;
+    }
+  pthread_mutex_unlock (&notify_app->mutex);
+  notify_update_bar ();
 }
 
 /* Check if the newly repeated appointment is to be notified. */
-void 
-notify_check_repeated(recur_apoint_llist_node_t *i)
+void
+notify_check_repeated (recur_apoint_llist_node_t *i)
 {
-	long real_app_time;
-	int update_notify = 0;
-	time_t current_time;
-
-	current_time = time(NULL);
-	pthread_mutex_lock(&notify_app->mutex);
-	if ((real_app_time = recur_item_inday(i->start, i->exc, i->rpt->type,
-	    i->rpt->freq, i->rpt->until, get_today()) > current_time)) {
-		if (!notify_app->got_app) {
-			if (real_app_time - current_time <= DAYINSEC) 
-				update_notify = 1;
-		} else if (real_app_time < notify_app->time && 
-		    real_app_time >= current_time) {
-			update_notify = 1;
-		} else if (real_app_time == notify_app->time &&
-		    i->state != notify_app->state)
-			update_notify = 1;
+  long real_app_time;
+  int update_notify = 0;
+  time_t current_time;
+
+  current_time = time (NULL);
+  pthread_mutex_lock (&notify_app->mutex);
+  if ((real_app_time = recur_item_inday (i->start, i->exc, i->rpt->type,
+					 i->rpt->freq, i->rpt->until,
+					 get_today ()) > current_time))
+    {
+      if (!notify_app->got_app)
+	{
+	  if (real_app_time - current_time <= DAYINSEC)
+	    update_notify = 1;
 	}
-	if (update_notify) {
-		notify_app->got_app = 1;
-		notify_app->time = real_app_time;
-		notify_app->txt = mycpy(i->mesg);	
-		notify_app->state = i->state;
+      else if (real_app_time < notify_app->time &&
+	       real_app_time >= current_time)
+	{
+	  update_notify = 1;
 	}
-	pthread_mutex_unlock(&notify_app->mutex);
-	notify_update_bar();
+      else if (real_app_time == notify_app->time &&
+	       i->state != notify_app->state)
+	update_notify = 1;
+    }
+  if (update_notify)
+    {
+      notify_app->got_app = 1;
+      notify_app->time = real_app_time;
+      notify_app->txt = mycpy (i->mesg);
+      notify_app->state = i->state;
+    }
+  pthread_mutex_unlock (&notify_app->mutex);
+  notify_update_bar ();
 }
 
-int 
-notify_same_item(long time)
+int
+notify_same_item (long time)
 {
-	int same = 0;
-	
-	pthread_mutex_lock(&(notify_app->mutex));
-	if (notify_app->got_app && notify_app->time == time)
-		same = 1;
-	pthread_mutex_unlock(&(notify_app->mutex));
-
-	return same;
+  int same = 0;
+
+  pthread_mutex_lock (&(notify_app->mutex));
+  if (notify_app->got_app && notify_app->time == time)
+    same = 1;
+  pthread_mutex_unlock (&(notify_app->mutex));
+
+  return (same);
 }
 
-int 
-notify_same_recur_item(recur_apoint_llist_node_t *i)
+int
+notify_same_recur_item (recur_apoint_llist_node_t *i)
 {
-	int same = 0;
-	long item_start = 0;
+  int same = 0;
+  long item_start = 0;
 
-	item_start = recur_item_inday(i->start, i->exc, i->rpt->type,
-		i->rpt->freq, i->rpt->until, get_today());
-	pthread_mutex_lock(&notify_app->mutex);
-	if (notify_app->got_app && item_start == notify_app->time)
-		same = 1;
-	pthread_mutex_unlock(&(notify_app->mutex));
+  item_start = recur_item_inday (i->start, i->exc, i->rpt->type,
+				 i->rpt->freq, i->rpt->until, get_today ());
+  pthread_mutex_lock (&notify_app->mutex);
+  if (notify_app->got_app && item_start == notify_app->time)
+    same = 1;
+  pthread_mutex_unlock (&(notify_app->mutex));
 
-	return same;
+  return (same);
 }
 
 /* Launch the notify-bar main thread. */
-void 
-notify_start_main_thread(void) 
+void
+notify_start_main_thread (void)
 {
-	pthread_create(&notify_t_main, NULL, notify_main_thread, NULL);
-	notify_check_next_app();
-	return;
+  pthread_create (&notify_t_main, NULL, notify_main_thread, NULL);
+  notify_check_next_app ();
+  return;
 }
 
 /* Print options related to the notify-bar. */
-static void 
-notify_print_options(WINDOW *optwin, int col)
+static void
+notify_print_options (WINDOW *optwin, int col)
 {
-	enum {SHOW, DATE, CLOCK, WARN, CMD, NB_OPT};
-
-	struct opt_s {
-		char name[BUFSIZ];
-		char desc[BUFSIZ];
-		char value[BUFSIZ];
-	} opt[NB_OPT];
-
-	int i, y, x, l, x_pos, y_pos, x_offset, y_offset, maxcol, maxlen;
-	char buf[BUFSIZ];
-
-	x_pos = 3;
-	x_offset = 4;
-	y_pos = 4;
-	y_offset = 3;
-	maxcol = col - 2;
-
-	strncpy(opt[SHOW].name, _("notify-bar_show = "), BUFSIZ);
-	strncpy(opt[DATE].name, _("notify-bar_date = "), BUFSIZ);
-	strncpy(opt[CLOCK].name, _("notify-bar_clock = "), BUFSIZ);
-	strncpy(opt[WARN].name, _("notify-bar_warning = "), BUFSIZ);
-	strncpy(opt[CMD].name, _("notify-bar_command = "), BUFSIZ);
-
-	strncpy(opt[SHOW].desc, 
-	    _("(if set to YES, notify-bar will be displayed)"), 
-	    BUFSIZ);
-	strncpy(opt[DATE].desc, 
-	    _("(Format of the date to be displayed inside notify-bar)"), 
-	    BUFSIZ);
-	strncpy(opt[CLOCK].desc, 
-	    _("(Format of the time to be displayed inside notify-bar)"),
-	    BUFSIZ);
-	strncpy(opt[WARN].desc, 
-	    _("(Warn user if an appointment is within next 'notify-bar_warning'"
-	    " seconds)"),
-	    BUFSIZ);
-	strncpy(opt[CMD].desc, 
-	    _("(Command used to notify user of an upcoming appointment)"),
-	    BUFSIZ);
-
-	pthread_mutex_lock(&nbar->mutex);
-
-	strncpy(opt[DATE].value, nbar->datefmt, BUFSIZ);
-	strncpy(opt[CLOCK].value, nbar->timefmt, BUFSIZ);
-	snprintf(opt[WARN].value, BUFSIZ, "%d", nbar->cntdwn);
-	strncpy(opt[CMD].value, nbar->cmd, BUFSIZ);
-
-	l = strlen(opt[SHOW].name);
-	x = x_pos + x_offset + l;
-	mvwprintw(optwin, y_pos, x_pos, "[1] %s", opt[SHOW].name);
-	erase_window_part(optwin, x, y_pos, maxcol, y_pos);
-	print_option_incolor(optwin, nbar->show, y_pos, x);
-	mvwprintw(optwin, y_pos + 1, x_pos, opt[SHOW].desc);
-
-	for (i = 1; i < NB_OPT; i++) {
-		l = strlen(opt[i].name);
-		y = y_pos + i * y_offset;
-		x = x_pos + x_offset + l;
-		maxlen = maxcol - x - 2;
-
-		mvwprintw(optwin, y, x_pos, "[%d] %s", i + 1, opt[i].name);
-		erase_window_part(optwin, x, y, maxcol, y);
-		custom_apply_attr(optwin, ATTR_HIGHEST);
-		if (strlen(opt[i].value) < maxlen)
-			mvwprintw(optwin, y, x, "%s", opt[i].value);
-		else {
-			strncpy(buf, opt[i].value, maxlen - 1);
-			buf[maxlen - 1] = '\0';
-			mvwprintw(optwin, y, x, "%s...", buf);
-		}
-		custom_remove_attr(optwin, ATTR_HIGHEST);
-		mvwprintw(optwin, y + 1, x_pos, opt[i].desc);
+  enum
+  { SHOW, DATE, CLOCK, WARN, CMD, NB_OPT };
+
+  struct opt_s
+  {
+    char name[BUFSIZ];
+    char desc[BUFSIZ];
+    char value[BUFSIZ];
+  }
+  opt[NB_OPT];
+
+  int i, y, x, l, x_pos, y_pos, x_offset, y_offset, maxcol, maxlen;
+  char buf[BUFSIZ];
+
+  x_pos = 3;
+  x_offset = 4;
+  y_pos = 4;
+  y_offset = 3;
+  maxcol = col - 2;
+
+  strncpy (opt[SHOW].name, _("notify-bar_show = "), BUFSIZ);
+  strncpy (opt[DATE].name, _("notify-bar_date = "), BUFSIZ);
+  strncpy (opt[CLOCK].name, _("notify-bar_clock = "), BUFSIZ);
+  strncpy (opt[WARN].name, _("notify-bar_warning = "), BUFSIZ);
+  strncpy (opt[CMD].name, _("notify-bar_command = "), BUFSIZ);
+
+  strncpy (opt[SHOW].desc,
+	   _("(if set to YES, notify-bar will be displayed)"), BUFSIZ);
+  strncpy (opt[DATE].desc,
+	   _("(Format of the date to be displayed inside notify-bar)"),
+	   BUFSIZ);
+  strncpy (opt[CLOCK].desc,
+	   _("(Format of the time to be displayed inside notify-bar)"),
+	   BUFSIZ);
+  strncpy (opt[WARN].desc,
+	   _("(Warn user if an appointment is within next 'notify-bar_warning'"
+             " seconds)"), BUFSIZ);
+  strncpy (opt[CMD].desc,
+	   _("(Command used to notify user of an upcoming appointment)"),
+	   BUFSIZ);
+
+  pthread_mutex_lock (&nbar->mutex);
+
+  strncpy (opt[DATE].value, nbar->datefmt, BUFSIZ);
+  strncpy (opt[CLOCK].value, nbar->timefmt, BUFSIZ);
+  snprintf (opt[WARN].value, BUFSIZ, "%d", nbar->cntdwn);
+  strncpy (opt[CMD].value, nbar->cmd, BUFSIZ);
+
+  l = strlen (opt[SHOW].name);
+  x = x_pos + x_offset + l;
+  mvwprintw (optwin, y_pos, x_pos, "[1] %s", opt[SHOW].name);
+  erase_window_part (optwin, x, y_pos, maxcol, y_pos);
+  print_option_incolor (optwin, nbar->show, y_pos, x);
+  mvwprintw (optwin, y_pos + 1, x_pos, opt[SHOW].desc);
+
+  for (i = 1; i < NB_OPT; i++)
+    {
+      l = strlen (opt[i].name);
+      y = y_pos + i * y_offset;
+      x = x_pos + x_offset + l;
+      maxlen = maxcol - x - 2;
+
+      mvwprintw (optwin, y, x_pos, "[%d] %s", i + 1, opt[i].name);
+      erase_window_part (optwin, x, y, maxcol, y);
+      custom_apply_attr (optwin, ATTR_HIGHEST);
+      if (strlen (opt[i].value) < maxlen)
+	mvwprintw (optwin, y, x, "%s", opt[i].value);
+      else
+	{
+	  strncpy (buf, opt[i].value, maxlen - 1);
+	  buf[maxlen - 1] = '\0';
+	  mvwprintw (optwin, y, x, "%s...", buf);
 	}
-
-	pthread_mutex_unlock(&nbar->mutex);
-	wmove(win[STA].p, 1, 0);
-	wnoutrefresh(optwin);
-	doupdate();
+      custom_remove_attr (optwin, ATTR_HIGHEST);
+      mvwprintw (optwin, y + 1, x_pos, opt[i].desc);
+    }
+
+  pthread_mutex_unlock (&nbar->mutex);
+  wmove (win[STA].p, 1, 0);
+  wnoutrefresh (optwin);
+  doupdate ();
 }
 
 /* Notify-bar configuration. */
-void 
-notify_config_bar(void)
+void
+notify_config_bar (void)
 {
-	window_t conf_win;
-	char label[BUFSIZ];
-	char *buf;
-	char *number_str = 
-	    _("Enter an option number to change its value [Q to quit] ");
-	char *date_str = 
-	    _("Enter the date format (see 'man 3 strftime' for possible formats) ");
-	char *time_str = 
-	    _("Enter the time format (see 'man 3 strftime' for possible formats) ");
-	char *count_str = 
-	    _("Enter the number of seconds (0 not to be warned before an appointment)");
-	char *cmd_str = _("Enter the notification command ");
-	int ch = 0 , change_win = 1;
-
-	buf = (char *)malloc(BUFSIZ);
-	snprintf(label, BUFSIZ, _("CalCurse %s | notify-bar options"), VERSION);
-	custom_confwin_init(&conf_win, label);
-
-	while (ch != 'q') {
-		if (change_win)
-			custom_confwin_init(&conf_win, label);
-		status_mesg(number_str, "");
-		notify_print_options(conf_win.p, col);
-		*buf = '\0';
-		ch = wgetch(win[STA].p);
-
-		switch (ch) {
-		case KEY_RESIZE:
-			endwin();
-			refresh();
-			curs_set(0);
-			delwin(conf_win.p);
-			custom_confwin_init(&conf_win, label);
-			break;
-		case '1':	
-			pthread_mutex_lock(&nbar->mutex);
-			nbar->show = !nbar->show;
-			pthread_mutex_unlock(&nbar->mutex);
-			if (notify_bar())
-				notify_start_main_thread();
-			else
-				notify_stop_main_thread();
-			delwin(conf_win.p);
-			change_win = 1;
-			break;
-		case '2':
-			status_mesg(date_str, "");
-			pthread_mutex_lock(&nbar->mutex);
-			strncpy(buf, nbar->datefmt, strlen(nbar->datefmt) + 1);
-			pthread_mutex_unlock(&nbar->mutex);
-			if (updatestring(win[STA].p, &buf, 0, 1) == 0) {
-				pthread_mutex_lock(&nbar->mutex);
-				strncpy(nbar->datefmt, buf, strlen(buf) + 1);
-				pthread_mutex_unlock(&nbar->mutex);
-			}
-			change_win = 0;
-			break;
-		case '3':
-			status_mesg(time_str, "");
-			pthread_mutex_lock(&nbar->mutex);
-			strncpy(buf, nbar->timefmt, strlen(nbar->timefmt) + 1);
-			pthread_mutex_unlock(&nbar->mutex);
-			if (updatestring(win[STA].p, &buf, 0, 1) == 0) {
-				pthread_mutex_lock(&nbar->mutex);
-				strncpy(nbar->timefmt, buf, strlen(buf) + 1);
-				pthread_mutex_unlock(&nbar->mutex);
-			}
-			change_win = 0;
-			break;
-                case '4':
-			status_mesg(count_str, "");
-			pthread_mutex_lock(&nbar->mutex);
-			printf(buf, "%d", nbar->cntdwn);
-			pthread_mutex_unlock(&nbar->mutex);
-			if (updatestring(win[STA].p, &buf, 0, 1) == 0 && 
-				is_all_digit(buf) && 
-				atoi(buf) >= 0 && atoi(buf) <= DAYINSEC) {
-				pthread_mutex_lock(&nbar->mutex);
-				nbar->cntdwn = atoi(buf);
-				pthread_mutex_unlock(&nbar->mutex);
-			}
-			change_win = 0;
-                        break;
-		case '5':
-			status_mesg(cmd_str, "");
-			pthread_mutex_lock(&nbar->mutex);
-			strncpy(buf, nbar->cmd, strlen(nbar->cmd) + 1);
-			pthread_mutex_unlock(&nbar->mutex);
-			if (updatestring(win[STA].p, &buf, 0, 1) == 0) {
-				pthread_mutex_lock(&nbar->mutex);
-				strncpy(nbar->cmd, buf, strlen(buf) + 1);
-				pthread_mutex_unlock(&nbar->mutex);
-			}
-			change_win = 0;
-                        break;
-		}
+  window_t conf_win;
+  char label[BUFSIZ];
+  char *buf;
+  char *number_str =
+    _("Enter an option number to change its value [Q to quit] ");
+  char *date_str =
+    _("Enter the date format (see 'man 3 strftime' for possible formats) ");
+  char *time_str =
+    _("Enter the time format (see 'man 3 strftime' for possible formats) ");
+  char *count_str =
+    _("Enter the number of seconds (0 not to be warned before an appointment)");
+  char *cmd_str = _("Enter the notification command ");
+  int ch = 0, change_win = 1;
+
+  buf = (char *) malloc (BUFSIZ);
+  snprintf (label, BUFSIZ, _("CalCurse %s | notify-bar options"), VERSION);
+  custom_confwin_init (&conf_win, label);
+
+  while (ch != 'q')
+    {
+      if (change_win)
+	custom_confwin_init (&conf_win, label);
+      status_mesg (number_str, "");
+      notify_print_options (conf_win.p, col);
+      *buf = '\0';
+      ch = wgetch (win[STA].p);
+
+      switch (ch)
+	{
+	case KEY_RESIZE:
+	  endwin ();
+	  refresh ();
+	  curs_set (0);
+	  delwin (conf_win.p);
+	  custom_confwin_init (&conf_win, label);
+	  break;
+	case '1':
+	  pthread_mutex_lock (&nbar->mutex);
+	  nbar->show = !nbar->show;
+	  pthread_mutex_unlock (&nbar->mutex);
+	  if (notify_bar ())
+	    notify_start_main_thread ();
+	  else
+	    notify_stop_main_thread ();
+	  delwin (conf_win.p);
+	  change_win = 1;
+	  break;
+	case '2':
+	  status_mesg (date_str, "");
+	  pthread_mutex_lock (&nbar->mutex);
+	  strncpy (buf, nbar->datefmt, strlen (nbar->datefmt) + 1);
+	  pthread_mutex_unlock (&nbar->mutex);
+	  if (updatestring (win[STA].p, &buf, 0, 1) == 0)
+	    {
+	      pthread_mutex_lock (&nbar->mutex);
+	      strncpy (nbar->datefmt, buf, strlen (buf) + 1);
+	      pthread_mutex_unlock (&nbar->mutex);
+	    }
+	  change_win = 0;
+	  break;
+	case '3':
+	  status_mesg (time_str, "");
+	  pthread_mutex_lock (&nbar->mutex);
+	  strncpy (buf, nbar->timefmt, strlen (nbar->timefmt) + 1);
+	  pthread_mutex_unlock (&nbar->mutex);
+	  if (updatestring (win[STA].p, &buf, 0, 1) == 0)
+	    {
+	      pthread_mutex_lock (&nbar->mutex);
+	      strncpy (nbar->timefmt, buf, strlen (buf) + 1);
+	      pthread_mutex_unlock (&nbar->mutex);
+	    }
+	  change_win = 0;
+	  break;
+	case '4':
+	  status_mesg (count_str, "");
+	  pthread_mutex_lock (&nbar->mutex);
+	  printf (buf, "%d", nbar->cntdwn);
+	  pthread_mutex_unlock (&nbar->mutex);
+	  if (updatestring (win[STA].p, &buf, 0, 1) == 0 &&
+	      is_all_digit (buf) && atoi (buf) >= 0 && atoi (buf) <= DAYINSEC)
+	    {
+	      pthread_mutex_lock (&nbar->mutex);
+	      nbar->cntdwn = atoi (buf);
+	      pthread_mutex_unlock (&nbar->mutex);
+	    }
+	  change_win = 0;
+	  break;
+	case '5':
+	  status_mesg (cmd_str, "");
+	  pthread_mutex_lock (&nbar->mutex);
+	  strncpy (buf, nbar->cmd, strlen (nbar->cmd) + 1);
+	  pthread_mutex_unlock (&nbar->mutex);
+	  if (updatestring (win[STA].p, &buf, 0, 1) == 0)
+	    {
+	      pthread_mutex_lock (&nbar->mutex);
+	      strncpy (nbar->cmd, buf, strlen (buf) + 1);
+	      pthread_mutex_unlock (&nbar->mutex);
+	    }
+	  change_win = 0;
+	  break;
 	}
-	free(buf);
-	delwin(conf_win.p);
+    }
+  free (buf);
+  delwin (conf_win.p);
 }