1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
/* $calcurse: notify.c,v 1.2 2006/09/11 13:38:56 culot Exp $ */
/*
* Calcurse - text-based organizer
* Copyright (c) 2004-2006 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
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*
* Send your feedback or comments to : calcurse@culot.org
* Calcurse home page : http://culot.org/calcurse
*
*/
#include <ncurses.h>
#include <pthread.h>
#include <time.h>
#include "i18n.h"
#include "custom.h"
#include "vars.h"
#include "recur.h"
#include "apoint.h"
#include "notify.h"
static struct notify_vars_s *notify = NULL;
static struct notify_app_s *notify_app = NULL;
/*
* Create the notification bar, by initializing all the variables and
* 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(int l, int c, int y, int x)
{
pthread_t notify_t_time;
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(¬ify->mutex, NULL);
pthread_mutex_init(¬ify_app->mutex, NULL);
notify->win = newwin(l, c, y, x);
notify_extract_aptsfile();
pthread_create(¬ify_t_time, NULL, notify_thread_time, NULL);
}
/*
* The calcurse window geometry as changed so we need to reset the
* notification window.
*/
void notify_reinit_bar(int l, int c, int y, int x)
{
delwin(notify->win);
notify->win = newwin(l, c, y, x);
}
/*
* Update the notification bar. This is useful when changing color theme
* for example.
*/
void notify_update_bar(void)
{
int file_pos, date_pos, app_pos;
date_pos = 3;
file_pos = date_pos + strlen(notify->date) + strlen(notify->time) + 9;
app_pos = file_pos + strlen(notify->apts_file) + 9;
pthread_mutex_lock(¬ify->mutex);
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(¬ify_app->mutex);
mvwprintw(notify->win, 0, app_pos, ">%s<", notify_app->txt);
pthread_mutex_unlock(¬ify_app->mutex);
wattroff(notify->win, A_UNDERLINE | A_REVERSE);
custom_remove_attr(notify->win, ATTR_HIGHEST);
wrefresh(notify->win);
pthread_mutex_unlock(¬ify->mutex);
}
/* Extract the appointment file name from the complete file path. */
void notify_extract_aptsfile(void)
{
notify->apts_file = strrchr(path_apts, '/');
notify->apts_file++;
}
/* Update the notication bar content */
void *notify_thread_time(void *arg)
{
unsigned thread_sleep = 1;
struct tm *ntime;
time_t ntimer;
char *time_format = "%T";
char *date_format = "%a %F";
for (;;) {
ntimer = time(NULL);
ntime = localtime(&ntimer);
pthread_mutex_lock(¬ify->mutex);
strftime(notify->time, NOTIFY_FIELD_LENGTH, time_format, ntime);
strftime(notify->date, NOTIFY_FIELD_LENGTH, date_format, ntime);
pthread_mutex_unlock(¬ify->mutex);
notify_update_bar();
sleep(thread_sleep);
}
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(¬ify_t_app, NULL, notify_thread_app, NULL);
return;
}
/* Look for the next appointment within the next 24 hours. */
void *notify_thread_app(void *arg)
{
struct notify_app_s *tmp_app;
char *no_app = _("no app. within 24h");
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;
strncpy(tmp_app->txt, no_app, strlen(no_app));
tmp_app = recur_apoint_check_next(tmp_app, current_time);
tmp_app = apoint_check_next(tmp_app, current_time);
pthread_mutex_lock(¬ify_app->mutex);
notify_app->time = tmp_app->time;
strncpy(notify_app->txt, tmp_app->txt, strlen(tmp_app->txt) + 1);
pthread_mutex_unlock(¬ify_app->mutex);
free(tmp_app);
notify_update_bar();
pthread_exit((void*) 0);
}
|
