/*
* Init the now and next module.
*/
void osd_channellist_event_init(struct osd_t* osd, int channel)
{
struct event_t* event;
uint32_t eventids[CHANNELLIST_NUM_EVENTS];
uint32_t eventid;
int server;
int i;
channels_geteventid(channel, &osd->event, &server);
eventid = osd->event;
for (i = 0; i < CHANNELLIST_NUM_EVENTS; i++) {
eventids[i] = eventid;
if (eventid > 0) {
event = event_copy(eventid, server);
if (event != NULL) {
eventid = event->nextEventId;
event_free(event);
}
else {
eventid = 0;
}
}
}
osd_model_nownext_set(&osd->model_now_next, eventids, server);
}
void event_fire(event_t *event)
{
if (event && (event->type == EVENT_SIGNAL))
{
event_fire_signal(event->param1.signal);
}
else
{
is_event++;
/*
Fire events triggered by signals
*/
event_fire_delayed();
if (event)
{
if (event_is_blocked(event))
{
blocked.push_back(event_copy(event, 1));
}
else
{
event_fire_internal(event);
}
}
is_event--;
}
}
static void osd_channellist_nownext_title(struct osd_t* osd)
{
uint32_t row_space_y = 50;
uint32_t x = nownext_win_x + PADDING_X;
uint32_t y = nownext_win_y + PADDING_Y + row_space_y;
uint32_t w = nownext_win_w - 2 * PADDING_X;
uint32_t h = nownext_win_h - 2 * PADDING_Y;
uint32_t color;
uint32_t bg_color = COLOR_BACKGROUND;
uint32_t date_y = nownext_win_y + PADDING_Y;
struct tm start_time;
struct tm stop_time;
struct event_t* event;
char str[128];
int i;
int update_all;
update_all = osd->model_now_next.event[0] != osd->model_now_next_current.event[0];
if (update_all) {
// clear window
graphics_resource_fill(osd->img, x - 2, date_y - 5, w + 5, h + 20, COLOR_BACKGROUND);
}
/* Fixa scroll i nn window. Och endast uppdatera ändringar!! */
for (i = 0; i < 11; i++) {
if (osd->model_now_next.event[i] > 0) {
event = event_copy(osd->model_now_next.event[i], osd->model_now_next.server);
if (event != NULL) {
if (osd->model_now_next.selectedIndex == i) {
color = COLOR_SELECTED_TEXT;
if (osd->model_channellist.active == 0) {
bg_color = COLOR_SELECTED_BACKGROUND;
}
}
else {
color = COLOR_TEXT;
bg_color = COLOR_BACKGROUND;
}
if(update_all || i == osd->model_now_next.selectedIndex || i == osd->model_now_next_current.selectedIndex) {
localtime_r((time_t*)&event->start, &start_time);
localtime_r((time_t*)&event->stop, &stop_time);
snprintf(str, sizeof(str),"%02d:%02d - %02d:%02d %s", start_time.tm_hour,start_time.tm_min,stop_time.tm_hour,stop_time.tm_min, event->title);
osd_text(osd, x, y, w, row_space_y, color, bg_color, str);
printf("Now: %s\n", str);
if (i == osd->model_now_next.selectedIndex) {
graphics_resource_fill(osd->img, x - 2, date_y - 5, w + 5, row_space_y, COLOR_BACKGROUND);
snprintf(str, sizeof(str),"%s %d", day_str[start_time.tm_wday], start_time.tm_mday);
osd_text(osd, x, date_y, w, row_space_y, COLOR_SELECTED_TEXT, COLOR_BACKGROUND, str);
}
}
y += row_space_y;
}
}
}
}
void osd_show_info(struct osd_t* osd, int channel_id, int timeout)
{
char str[128];
int server;
channels_geteventid(channel_id,&osd->event,&server);
channels_getnexteventid(channel_id,&osd->nextEvent,&server);
struct event_t* event = event_copy(osd->event,server);
struct event_t* nextEvent = event_copy(osd->nextEvent,server);
fprintf(stderr,"***OSD: event=%d\n",(event ? event->eventId : -1));
event_dump(event);
fprintf(stderr,"***OSD: nextEvent=%d\n",(nextEvent ? nextEvent->eventId : -1));
event_dump(nextEvent);
fprintf(stderr,"******\n");
snprintf(str,sizeof(str),"%03d - %s",channels_getlcn(channel_id),channels_getname(channel_id));
char* iso_text = malloc(strlen(str)+1);
utf8decode(str,iso_text);
pthread_mutex_lock(&osd->osd_mutex);
osd_show_channelname(osd,iso_text);
osd_show_time(osd);
osd_show_eventinfo(osd,event,nextEvent);
graphics_update_displayed_resource(osd->img, 0, 0, 0, 0);
pthread_mutex_unlock(&osd->osd_mutex);
free(iso_text);
osd->osd_state = OSD_INFO;
if (timeout) {
osd->osd_cleartime = get_time() + timeout;
}
event_free(event);
event_free(nextEvent);
}
espeak_ERROR event_declare (espeak_EVENT* event)
{
ENTER("event_declare");
event_display(event);
if (!event)
{
return EE_INTERNAL_ERROR;
}
int a_status = pthread_mutex_lock(&my_mutex);
espeak_ERROR a_error = EE_OK;
if (!a_status)
{
SHOW_TIME("event_declare > locked\n");
espeak_EVENT* a_event = event_copy(event);
a_error = push(a_event);
if (a_error != EE_OK)
{
event_delete(a_event);
}
SHOW_TIME("event_declare > unlocking\n");
a_status = pthread_mutex_unlock(&my_mutex);
}
// TBD: remove the comment
// reminder: code in comment.
// This wait can lead to an underrun
//
// if (!a_status && !my_event_is_running && (a_error == EE_OK))
// {
// // quit when command is actually started
// // (for possible forthcoming 'end of command' checks)
SHOW_TIME("event_declare > post my_sem_start_is_required\n");
sem_post(&my_sem_start_is_required);
// int val=1;
// while (val)
// {
// usleep(50000); // TBD: event?
// sem_getvalue(&my_sem_start_is_required, &val);
// }
// }
if (a_status != 0)
{
a_error = EE_INTERNAL_ERROR;
}
return a_error;
}
void event_add_handler(const event_t *event)
{
event_t *e;
CHECK(event,);
e = event_copy(event, 0);
if (e->type == EVENT_SIGNAL)
{
signal_handle(e->param1.signal, 1);
}
// Block around updating the events vector
signal_block();
events.push_back(e);
signal_unblock();
}
static void osd_channellist_event_info(struct osd_t* osd)
{
uint32_t x = eventinfo_win_x + PADDING_X;
uint32_t y = eventinfo_win_y + PADDING_Y;
uint32_t w = eventinfo_win_w - 2 * PADDING_X;
uint32_t h = eventinfo_win_h - 2 * PADDING_Y;
struct event_t* event;
uint32_t event_id;
// clear window
graphics_resource_fill(osd->img, x - 2, y - 5, w + 5, h + 20, COLOR_BACKGROUND);
event_id = osd->model_now_next.event[osd->model_now_next.selectedIndex];
if (event_id > 0) {
event = event_copy(event_id, osd->model_now_next.server);
if (event != NULL) {
// printf("eventinfo: %s\n", event->title);
// printf("eventinfo: %s\n", event->description);
osd_text(osd, x, y, w, 50, COLOR_SELECTED_TEXT, COLOR_BACKGROUND, event->title);
osd_paragraph(osd, event->description, 40, x, y + 50, w, h - 50);
}
}
}
espeak_ng_STATUS event_declare(espeak_EVENT *event)
{
if (!event)
return EINVAL;
espeak_ng_STATUS status;
if ((status = pthread_mutex_lock(&my_mutex)) != ENS_OK) {
my_start_is_required = 1;
return status;
}
espeak_EVENT *a_event = event_copy(event);
if ((status = push(a_event)) != ENS_OK) {
event_delete(a_event);
pthread_mutex_unlock(&my_mutex);
} else {
my_start_is_required = 1;
pthread_cond_signal(&my_cond_start_is_required);
status = pthread_mutex_unlock(&my_mutex);
}
return status;
}
/**
Handle all pending signal events
*/
static void event_fire_delayed()
{
size_t i;
/*
If is_event is one, we are running the event-handler non-recursively.
When the event handler has called a piece of code that triggers
another event, we do not want to fire delayed events because of
concurrency problems.
*/
if (! blocked.empty() && is_event==1)
{
event_list_t new_blocked;
for (i=0; i<blocked.size(); i++)
{
event_t *e = blocked.at(i);
if (event_is_blocked(e))
{
new_blocked.push_back(e);
}
else
{
event_fire_internal(e);
event_free(e);
}
}
blocked.swap(new_blocked);
}
while (sig_list[active_list].count > 0)
{
signal_list_t *lst;
/*
Switch signal lists
*/
sig_list[1-active_list].count=0;
sig_list[1-active_list].overflow=0;
active_list=1-active_list;
/*
Set up
*/
event_t e = event_t::signal_event(0);
e.arguments.reset(new wcstring_list_t(1)); //one element
lst = &sig_list[1-active_list];
if (lst->overflow)
{
debug(0, _(L"Signal list overflow. Signals have been ignored."));
}
/*
Send all signals in our private list
*/
for (int i=0; i < lst->count; i++)
{
e.param1.signal = lst->signal[i];
e.arguments->at(0) = sig2wcs(e.param1.signal);
if (event_is_blocked(&e))
{
blocked.push_back(event_copy(&e, 1));
}
else
{
event_fire_internal(&e);
}
}
e.arguments.reset(NULL);
}
}
