static void lxynth_atevent (s_window_t *window, s_event_t *event)
{
s_event_t *e;
if (lxynth_root == NULL) {
return;
}
switch (event->type & EVENT_MASK) {
case QUIT_EVENT:
case MOUSE_EVENT:
case KEYBD_EVENT:
case EXPOSE_EVENT:
case CONFIG_EVENT:
case FOCUS_EVENT:
if (!s_event_init(&e)) {
e->type = event->type;
memcpy(e->mouse, event->mouse, sizeof(s_mouse_t));
memcpy(e->keybd, event->keybd, sizeof(s_keybd_t));
memcpy(e->expose->rect, event->expose->rect, sizeof(s_rect_t));
s_thread_mutex_lock(lxynth_root->eventq->mut);
s_list_add(lxynth_root->eventq->list, e, -1);
s_thread_mutex_unlock(lxynth_root->eventq->mut);
}
break;
default:
break;
}
}
int s_eventq_wait (s_window_t *window, s_event_t **event)
{
int ret;
s_event_t *e;
s_thread_mutex_lock(window->eventq->mut);
while (window->eventq->queue->nb_elt <= 0) {
if (s_thread_cond_wait(window->eventq->cond, window->eventq->mut)) {
debugf(DSYS, "s_thread_cond_wait failed");
return -1;
}
}
e = (s_event_t *) s_list_get(window->eventq->queue, 0);
if (e == NULL) {
ret = -1;
} else {
s_list_remove(window->eventq->queue, 0);
*event = e;
ret = 0;
}
s_thread_mutex_unlock(window->eventq->mut);
return ret;
}
static void lxynth_timer (void *arg)
{
int x = 0;
int y = 0;
int k = 0;
int flag = 0;
s_event_t *event;
s_thread_mutex_lock(lxynth_root->eventq->mut);
while (!s_list_eol(lxynth_root->eventq->list, 0)) {
event = (s_event_t *) s_list_get(lxynth_root->eventq->list, 0);
s_list_remove(lxynth_root->eventq->list, 0);
switch (event->type & EVENT_MASK) {
case QUIT_EVENT: break;
case MOUSE_EVENT: lxynth_event_parse_mouse(event); break;
case KEYBD_EVENT: lxynth_event_parse_keybd(event); break;
case CONFIG_EVENT: lxynth_event_parse_config(event); break;
}
s_event_uninit(event);
}
s_thread_mutex_unlock(lxynth_root->eventq->mut);
if (lxynth_root->running) {
lxynth_root->timerid = install_timer(20, lxynth_timer, NULL);
}
}
void s_event_parse_mouse (s_window_t *window, s_event_t *event)
{
int pos;
s_handler_t *work;
pos = 0;
s_thread_mutex_lock(window->handlers->mut);
while (!s_list_eol(window->handlers->list, pos)) {
work = (s_handler_t *) s_list_get(window->handlers->list, pos++);
if (work->type != MOUSE_HANDLER) {
continue;
}
if (s_event_parse_handler_over(window, event, work) == 0) {
break;
}
}
pos = 0;
while (!s_list_eol(window->handlers->list, pos)) {
work = (s_handler_t *) s_list_get(window->handlers->list, pos++);
if (work->type != MOUSE_HANDLER) {
continue;
}
if (s_event_parse_handler_notover(window, event, work) == 0) {
break;
}
}
s_thread_mutex_unlock(window->handlers->mut);
return;
}
/**
* \brief Checks if an effect is running
*
* \return Returns true if a window effect is currently running
*/
bool GuiEffectWindow::effectInProgress()
{
s_thread_mutex_lock(effectMutex);
bool ret = effectTimer != NULL;
s_thread_mutex_unlock(effectMutex);
return ret;
}
int s_handler_del (s_window_t *window, s_handler_t *handler)
{
int ret = 0;
s_thread_mutex_lock(window->handlers->mut);
ret = s_list_remove(window->handlers->list, s_list_get_pos(window->handlers->list, handler));
s_thread_mutex_unlock(window->handlers->mut);
return ret;
}
/**
* \brief Set effect speed
*
* Updates the speed of window effects or animations in both vertical and
* horizontal direction.
*
* \param vertSpeed Specifies the step of a vertical slide animation,
* in pixels
* \param horzSpeed Specifies the step of a horizontal slide animation,
* in pixels
*/
void GuiEffectWindow::setEffectSpeed(int vertSpeed, int horzSpeed)
{
s_thread_mutex_lock(effectMutex);
effectVertSpeed = vertSpeed;
effectHorzSpeed = horzSpeed;
s_thread_mutex_unlock(effectMutex);
}
static void timer1_cb (s_window_t *window, s_timer_t *timer)
{
debugf(DCLI, "[%d]", window->id);
s_thread_mutex_lock(window->timers->mut);
if (s_list_get_pos(window->timers->timers, timer) >= 0) {
debugf(DCLI, "[%d] found!", window->id);
}
s_thread_mutex_unlock(window->timers->mut);
}
int s_pollfd_del (s_window_t *window, s_pollfd_t *pfd)
{
int ret;
s_thread_mutex_lock(window->pollfds->mut);
ret = s_list_remove(window->pollfds->list, s_list_get_pos(window->pollfds->list, pfd));
s_thread_mutex_unlock(window->pollfds->mut);
s_window_wakeup(window);
return ret;
}
/**
* \brief Set window effects
*
* Specifies the type of window opening and closing effects. Can also disable
* effects completely.
*
* \param openEffect Sets the window opening effect, slide-in animations are
* currently supported.
* \param closeEffect Sets the window closing effect, slide-out animations are
* currently supported.
*/
void GuiEffectWindow::setEffects(OPEN_EFFECT_TYPE openEffect, CLOSE_EFFECT_TYPE closeEffect)
{
s_thread_mutex_lock(effectMutex);
openEffectType = openEffect;
closeEffectType = closeEffect;
s_thread_mutex_unlock(effectMutex);
}
int s_eventq_add (s_window_t *window, s_event_t *event)
{
int ret;
s_thread_mutex_lock(window->eventq->mut);
event->window = window;
ret = s_list_add(window->eventq->queue, event, -1);
s_thread_cond_signal(window->eventq->cond);
s_thread_mutex_unlock(window->eventq->mut);
return ret;
}
s_thread_t * s_thread_create (void * (*f) (void *), void *farg)
{
s_thread_t *tid;
s_thread_arg_t *arg;
if ((s_thread_api == NULL) ||
(s_thread_api->thread_create == NULL)) {
return NULL;
}
tid = (s_thread_t *) s_malloc(sizeof(s_thread_t));
arg = (s_thread_arg_t *) s_malloc(sizeof(s_thread_arg_t));
arg->r = &s_thread_run;
arg->f = f;
arg->arg = farg;
s_thread_cond_init(&arg->cond);
s_thread_mutex_init(&arg->mut);
s_thread_mutex_lock(arg->mut);
arg->flag = 0;
s_thread_cond_signal(arg->cond);
s_thread_mutex_unlock(arg->mut);
s_thread_api->thread_create(tid, arg);
s_thread_mutex_lock(arg->mut);
while (arg->flag != 1)
{
if (s_thread_cond_wait(arg->cond, arg->mut)) {
debugf(DSYS, "s_thread_cond_wait failed");
return NULL;
}
}
s_thread_mutex_unlock(arg->mut);
s_thread_cond_destroy(arg->cond);
s_thread_mutex_destroy(arg->mut);
s_free(arg);
arg = NULL;
return tid;
}
int s_handler_add (s_window_t *window, s_handler_t *handler)
{
int ret = 0;
s_thread_mutex_lock(window->handlers->mut);
if (s_list_get_pos(window->handlers->list, handler) < 0) {
ret = s_list_add(window->handlers->list, handler, -1);
}
s_thread_mutex_unlock(window->handlers->mut);
return ret;
}
static void lxynth_surface_register_update (void *dev)
{
lxynth_device_t *wd;
if (lxynth_root->running == 0) return;
s_thread_mutex_lock(lxynth_root->gd->mut);
if (lxynth_root->gd->active != dev) {
s_thread_mutex_unlock(lxynth_root->gd->mut);
return;
}
wd = (lxynth_device_t *) ((struct graphics_device *) dev)->driver_data;
s_putboxpart(lxynth_root->window->surface, wd->update.x, wd->update.y, wd->update.w, wd->update.h, wd->surface->width, wd->surface->height, wd->surface->vbuf, wd->update.x, wd->update.y);
wd->update = (s_rect_t) {-1, -1, -1, -1};
s_thread_mutex_unlock(lxynth_root->gd->mut);
}
int s_event_parse_handler_over (s_window_t *window, s_event_t *event, s_handler_t *work)
{
switch (s_event_mouse_handler_state(window, event, &(work->mouse), 1)) {
case MOUSE_OVER:
if (work->mouse.o != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.o(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
case MOUSE_PRESSED:
if (work->mouse.p != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.p(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
case MOUSE_CLICKED:
if (work->mouse.c != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.c(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
work = (s_handler_t *) s_list_get(window->handlers->list, s_list_get_pos(window->handlers->list, work));
if (work == NULL) {
goto not_over;
}
}
/* no break */
case MOUSE_RELEASED:
if (work->mouse.r != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.r(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
case (MOUSE_RELEASED | MOUSE_HINT):
/* mouse button released, but the prev. press was not on us */
if (work->mouse.hr != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.hr(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
case (MOUSE_OVER | MOUSE_HINT):
/* on over, but mouse button is still pressed */
if (work->mouse.ho != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.ho(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
}
return -1;
not_over:
return 0;
}
static void * s_thread_run (void *farg)
{
s_thread_arg_t *arg = (s_thread_arg_t *) farg;
void *p = arg->arg;
void * (*f) (void *) = arg->f;
s_thread_mutex_lock(arg->mut);
arg->flag = 1;
s_thread_cond_signal(arg->cond);
s_thread_mutex_unlock(arg->mut);
f(p);
return NULL;
}
int s_event_parse_keybd_handler (s_window_t *window, s_event_t *event, s_handler_t *work)
{
if (((work->keybd.flag & event->keybd->flag) == (event->keybd->flag & ~KEYBD_MASL)) &&
!(work->keybd.flag & ~event->keybd->flag) &&
(event->keybd->button == work->keybd.button)) {
if (event->type & KEYBD_PRESSED) {
if (work->keybd.p != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->keybd.p(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
return 0;
}
if (event->type & KEYBD_RELEASED) {
if (work->keybd.r != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->keybd.r(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
return 0;
}
}
return -1;
}
static void lxynth_atexit (s_window_t *window)
{
if (lxynth_root == NULL) {
return;
}
if (lxynth_root->running) {
struct graphics_device *gd = lxynth_root->gd->active;
s_thread_mutex_lock(lxynth_root->gd->mut);
lxynth_root->running = 0;
lxynth_root->gd->active = NULL;
s_thread_mutex_unlock(lxynth_root->gd->mut);
gd->keyboard_handler(gd, KBD_CLOSE, 0);
}
}
int s_pollfd_add (s_window_t *window, s_pollfd_t *pfd)
{
int ret = 0;
s_thread_mutex_lock(window->pollfds->mut);
if (s_list_get_pos(window->pollfds->list, pfd) < 0) {
#if 1
ret = s_list_add(window->pollfds->list, pfd, -1);
#else
ret = s_list_add(window->pollfds->list, pfd, 2);
#endif
}
s_thread_mutex_unlock(window->pollfds->mut);
s_window_wakeup(window);
return ret;
}
int s_handlers_uninit (s_window_t *window)
{
s_handler_t *hndl;
s_thread_mutex_lock(window->handlers->mut);
while (!s_list_eol(window->handlers->list, 0)) {
hndl = (s_handler_t *) s_list_get(window->handlers->list, 0);
s_list_remove(window->handlers->list, 0);
s_handler_uninit(hndl);
}
s_thread_mutex_unlock(window->handlers->mut);
s_thread_mutex_destroy(window->handlers->mut);
s_list_uninit(window->handlers->list);
s_free(window->handlers);
return 0;
}
static void lxynth_shutdown_device (struct graphics_device *dev)
{
int acc = 0;
int pos = 0;
lxynth_device_t *wd;
struct graphics_device *gd;
DEBUGF ("%s (%s:%d)\n", __FUNCTION__, __FILE__, __LINE__);
s_thread_mutex_lock(lxynth_root->gd->mut);
while (!s_list_eol(lxynth_root->gd->list, pos)) {
gd = (struct graphics_device *) s_list_get(lxynth_root->gd->list, pos);
if (gd == dev) {
s_list_remove(lxynth_root->gd->list, pos);
if (lxynth_root->gd->list->nb_elt > 0) {
lxynth_root->gd->active = (struct graphics_device *) s_list_get(lxynth_root->gd->list, 0);
acc = 1;
} else {
lxynth_root->gd->active = NULL;
}
break;
}
pos++;
}
unregister_bottom_half(lxynth_surface_register_update, dev);
wd = (lxynth_device_t *) dev->driver_data;
s_free(wd->title);
s_surface_destroy(wd->surface);
s_free(wd);
s_free(dev);
s_thread_mutex_unlock(lxynth_root->gd->mut);
if (acc && lxynth_root->running) {
char *title;
struct rect r;
r.x1 = 0;
r.y1 = 0;
r.x2 = lxynth_root->window->surface->buf->w;
r.y2 = lxynth_root->window->surface->buf->h;
title = strdup(((lxynth_device_t *) lxynth_root->gd->active->driver_data)->title);
lxynth_set_title(lxynth_root->gd->active, title);
lxynth_root->gd->active->resize_handler(lxynth_root->gd->active);
lxynth_root->gd->active->redraw_handler(lxynth_root->gd->active, &r);
s_free(title);
}
}
s_pollfd_t * s_pollfd_find (s_window_t *window, int fd)
{
int pos;
s_pollfd_t *pfd;
s_pollfd_t *ret;
s_thread_mutex_lock(window->pollfds->mut);
pos = 0;
ret = NULL;
while (!s_list_eol(window->pollfds->list, pos)) {
pfd = (s_pollfd_t *) s_list_get(window->pollfds->list, pos);
if (pfd->fd == fd) {
ret = pfd;
break;
}
pos++;
}
s_thread_mutex_unlock(window->pollfds->mut);
return ret;
}
int s_pollfds_uninit (s_window_t *window)
{
s_pollfd_t *pfd;
s_thread_mutex_lock(window->pollfds->mut);
while (!s_list_eol(window->pollfds->list, 0)) {
pfd = (s_pollfd_t *) s_list_get(window->pollfds->list, 0);
s_list_remove(window->pollfds->list, 0);
if (pfd->pf_close != NULL) {
pfd->pf_close(window, pfd);
}
s_pollfd_uninit(pfd);
}
s_thread_mutex_unlock(window->pollfds->mut);
s_thread_mutex_destroy(window->pollfds->mut);
s_list_uninit(window->pollfds->list);
s_free(window->pollfds);
return 0;
}
int s_eventq_get (s_window_t *window, s_event_t **event)
{
int ret;
s_event_t *e;
s_thread_mutex_lock(window->eventq->mut);
e = (s_event_t *) s_list_get(window->eventq->queue, 0);
if (e == NULL) {
ret = 1;
} else {
s_list_remove(window->eventq->queue, 0);
*event = e;
ret = 0;
}
s_thread_mutex_unlock(window->eventq->mut);
return ret;
}
static void lxynth_set_title (struct graphics_device *dev, unsigned char *title)
{
lxynth_device_t *wd;
DEBUGF ("%s (%s:%d)\n", __FUNCTION__, __FILE__, __LINE__);
wd = (lxynth_device_t *) dev->driver_data;
s_free(wd->title);
wd->title = strdup(title);
s_thread_mutex_lock(lxynth_root->gd->mut);
if (lxynth_root->gd->active != dev) {
s_thread_mutex_unlock(lxynth_root->gd->mut);
return;
}
s_window_set_title(lxynth_root->window, title);
s_thread_mutex_unlock(lxynth_root->gd->mut);
}
static void lxynth_draw_vline (struct graphics_device *dev, int x, int top, int bottom, long color)
{
lxynth_device_t *wd;
DEBUGF ("%s (%s:%d)\n", __FUNCTION__, __FILE__, __LINE__);
VLINE_CLIP_PREFACE;
if (lxynth_root->running == 0) return;
s_thread_mutex_lock(lxynth_root->gd->mut);
if (lxynth_root->gd->active != dev) {
s_thread_mutex_unlock(lxynth_root->gd->mut);
return;
}
wd = (lxynth_device_t *) dev->driver_data;
s_vline(wd->surface, x, top, bottom, color);
lxynth_surface_update(dev, x, top, 1, bottom - top);
s_thread_mutex_unlock(lxynth_root->gd->mut);
}
static void lxynth_draw_hline (struct graphics_device *dev, int left, int y, int right, long color)
{
lxynth_device_t *wd;
DEBUGF ("%s (%s:%d)\n", __FUNCTION__, __FILE__, __LINE__);
HLINE_CLIP_PREFACE;
if (lxynth_root->running == 0) return;
s_thread_mutex_lock(lxynth_root->gd->mut);
if (lxynth_root->gd->active != dev) {
s_thread_mutex_unlock(lxynth_root->gd->mut);
return;
}
wd = (lxynth_device_t *) dev->driver_data;
s_hline(wd->surface, left, y, right, color);
lxynth_surface_update(dev, left, y, right - left, 1);
s_thread_mutex_unlock(lxynth_root->gd->mut);
}
void w_signal_delete (w_object_t *object)
{
int pos = 0;
s_event_t *event;
w_signal_t *signal;
s_thread_mutex_lock(object->window->window->eventq->mut);
while (!s_list_eol(object->window->window->eventq->queue, pos)) {
event = (s_event_t *) s_list_get(object->window->window->eventq->queue, pos);
signal = (w_signal_t *) event->data;
if ((event->type == SIGNAL_EVENT) &&
((signal->from == object) || (signal->to == object))) {
s_list_remove(object->window->window->eventq->queue, pos);
s_free(signal);
s_event_uninit(event);
} else {
pos++;
}
}
s_thread_mutex_unlock(object->window->window->eventq->mut);
}
static void lxynth_fill_area (struct graphics_device *dev, int left, int top, int right, int bottom, long color)
{
lxynth_device_t *wd;
DEBUGF ("%s (%s:%d)\n", __FUNCTION__, __FILE__, __LINE__);
FILL_CLIP_PREFACE;
if (lxynth_root->running == 0) return;
s_thread_mutex_lock(lxynth_root->gd->mut);
if (lxynth_root->gd->active != dev) {
s_thread_mutex_unlock(lxynth_root->gd->mut);
return;
}
wd = (lxynth_device_t *) dev->driver_data;
s_fillbox(wd->surface, left, top, right - left, bottom - top, color);
lxynth_surface_update(dev, left, top, right - left, bottom - top);
s_thread_mutex_unlock(lxynth_root->gd->mut);
}
int s_event_parse_keybd (s_window_t *window, s_event_t *event)
{
int pos;
int ret = 1;
s_handler_t *work;
pos = 0;
s_thread_mutex_lock(window->handlers->mut);
while (!s_list_eol(window->handlers->list, pos)) {
work = (s_handler_t *) s_list_get(window->handlers->list, pos++);
if (work->type != KEYBD_HANDLER) {
continue;
}
if (s_event_parse_keybd_handler(window, event, work) == 0) {
ret = 0;
break;
}
}
s_thread_mutex_unlock(window->handlers->mut);
return ret;
}