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

notify_update_bar() updated to call notify_launch_cmd()

Browse Source 
notify_launch_cmd() created
notify_thread_app() notify_check_added() and notify_check_repeated()
updated to handle item state
notify_catch_children() and notify_thread_children() created, to avoid
zombie processes when launching user-defined commands to get notified
This commit is contained in:
Frederic Culot 2007-02-25 19:30:33 +00:00
parent 5ec7a1565f
commit f7d672093f
1 changed files with 98 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
src/notify.c
View File

@ -1,8 +1,8 @@
/* $calcurse: notify.c,v 1.7 2007/02/24 17:38:40 culot Exp $ */
/* $calcurse: notify.c,v 1.8 2007/02/25 19:30:33 culot Exp $ */
/*
* Calcurse - text-based organizer
* Copyright (c) 2004-2006 Frederic Culot
* Copyright (c) 2004-2007 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
@ -30,6 +30,7 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include "i18n.h"
#include "utils.h"
@ -42,6 +43,7 @@
static struct notify_vars_s *notify = NULL;
static struct notify_app_s *notify_app = NULL;
static pthread_t notify_t_main;
static pthread_t notify_t_children;
/* Return 1 if we need to display the notify-bar, else 0. */
int notify_bar(void)
@ -69,14 +71,6 @@ void notify_init_bar(int l, int c, int y, int x)
notify_extract_aptsfile();
}
/* Launch the notify-bar main thread. */
void notify_start_main_thread(void)
{
pthread_create(&notify_t_main, NULL, notify_main_thread, NULL);
notify_check_next_app();
return;
}
/* Stop the notify-bar main thread. */
void notify_stop_main_thread(void)
{
@ -144,6 +138,14 @@ void notify_update_bar(void)
notify_app->txt);
if (time_left < nbar->cntdwn)
wattroff(notify->win, A_BLINK);
if (time_left < nbar->cntdwn &&
(notify_app->state & APOINT_NOTIFY) &&
!(notify_app->state & APOINT_NOTIFIED)) {
notify_app->state |= APOINT_NOTIFIED;
notify_launch_cmd(nbar->cmd, nbar->shell);
}
pthread_mutex_unlock(&nbar->mutex);
} else {
notify_app->got_app = 0;
@ -170,7 +172,8 @@ void notify_extract_aptsfile(void)
}
/* Update the notication bar content */
void *notify_main_thread(void *arg)
static void *
notify_main_thread(void *arg)
{
unsigned thread_sleep = 1, check_app = 60;
int elapse = 0, got_app = 0;
@ -201,17 +204,9 @@ void *notify_main_thread(void *arg)
pthread_exit((void*) 0);
}
/* Launch the thread notify_thread_app to look for next appointment. */
void notify_check_next_app(void)
{
pthread_t notify_t_app;
pthread_create(&notify_t_app, NULL, notify_thread_app, NULL);
return;
}
/* Look for the next appointment within the next 24 hours. */
void *notify_thread_app(void *arg)
static void *
notify_thread_app(void *arg)
{
struct notify_app_s *tmp_app;
time_t current_time;
@ -231,6 +226,7 @@ void *notify_thread_app(void *arg)
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;
}
@ -242,8 +238,33 @@ void *notify_thread_app(void *arg)
pthread_exit((void*) 0);
}
/*
* Catch return values from children (user-defined notification commands).
* This is needed to avoid zombie processes running on system.
*/
static void *
notify_thread_children(void *arg)
{
for (;;) {
waitpid(WAIT_MYPGRP, NULL, WNOHANG);
sleep(1);
}
pthread_exit((void *)0);
}
/* Launch the thread notify_thread_app to look for next appointment. */
void notify_check_next_app(void)
{
pthread_t notify_t_app;
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)
void
notify_check_added(char *mesg, long start, char state)
{
time_t current_time;
int update_notify = 0;
@ -253,21 +274,26 @@ void notify_check_added(char *mesg, long start)
pthread_mutex_lock(&notify_app->mutex);
if (!notify_app->got_app) {
gap = start - current_time;
if (gap >= 0 && gap <= DAYINSEC) update_notify = 1;
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;
@ -280,14 +306,18 @@ void notify_check_repeated(recur_apoint_llist_node_t *i)
if (!notify_app->got_app) {
if (real_app_time - current_time <= DAYINSEC)
update_notify = 1;
} else if (real_app_time < notify_app->time) {
} 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;
}
}
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();
@ -319,3 +349,44 @@ int notify_same_recur_item(recur_apoint_llist_node_t *i)
return same;
}
/* Launch user defined command as a notification. */
void
notify_launch_cmd(char *cmd, char *shell)
{
int pid;
pid = fork();
if (pid < 0) {
fputs(_("FATAL ERROR in notify_launch_cmd: could not fork\n"),
stderr);
exit(EXIT_FAILURE);
} else if (pid == 0) { /* Child: launch user defined command */
if (execlp(shell, shell, "-c", cmd, (char *)NULL) < 0)
fputs(_("FATAL ERROR in notify_launch_cmd: could not "
"launch user command\n"), stderr);
exit(EXIT_FAILURE);
}
}
/* Launch the notify-bar main thread. */
void
notify_start_main_thread(void)
{
pthread_create(&notify_t_main, NULL, notify_main_thread, NULL);
notify_check_next_app();
return;
}
/*
* Launch the catch_children thread.
* This is useful to avoid zombie processes when launching user-defined command
* to get notified.
*/
void
notify_catch_children(void)
{
pthread_create(&notify_t_children, NULL, notify_thread_children, NULL);
return;
}