#include "extensions.h"
#include "timer.h"
#include "dispatch.h"
+#include "event.h"
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
+#include <glib.h>
+
#ifdef HAVE_SYS_SELECT_H
# include <sys/select.h>
#endif
};
static int mask_table_size;
+static fd_set selset, allset;
+static int max_fd, x_fd;
+static GData *fd_handler_list;
+
+void fd_event_handle();
+
void event_startup()
{
mask_table_size = sizeof(mask_table) / sizeof(mask_table[0]);
ScrollLockMask = mask_table[cnt / modmap->max_keypermod];
}
}
+
+ FD_ZERO(&allset);
+ max_fd = x_fd = ConnectionNumber(ob_display);
+ FD_SET(x_fd, &allset);
+ g_datalist_init(&fd_handler_list);
}
void event_shutdown()
{
XFreeModifiermap(modmap);
+ g_datalist_clear(&fd_handler_list);
}
void event_loop()
{
- fd_set selset;
XEvent e;
- int x_fd;
struct timeval *wait;
gboolean had_event = FALSE;
XNextEvent(ob_display, &e);
event_process(&e);
- had_event = TRUE;
+ had_event = TRUE;
}
if (!had_event) {
timer_dispatch((GTimeVal**)&wait);
- x_fd = ConnectionNumber(ob_display);
- FD_ZERO(&selset);
- FD_SET(x_fd, &selset);
- select(x_fd + 1, &selset, NULL, NULL, wait);
+ selset = allset;
+ select(max_fd + 1, &selset, NULL, NULL, wait);
+
+ /* handle the X events as soon as possible? */
+ if (FD_ISSET(x_fd, &selset))
+ return;
+
+ fd_event_handle();
}
}
}
}
+void event_add_fd_handler(event_fd_handler *h) {
+ g_datalist_id_set_data(&fd_handler_list, h->fd, h);
+ FD_SET(h->fd, &allset);
+ max_fd = MAX(max_fd, h->fd);
+}
+
+void find_max_fd_foreach(GQuark n, gpointer data, gpointer max)
+{
+ *((unsigned int *)max) = MAX(*((unsigned int *)max), n);
+}
+
+void event_remove_fd(int n)
+{
+ int tmpmax = 0;
+ FD_CLR(n, &allset);
+ g_datalist_id_remove_data(&fd_handler_list, (GQuark)n);
+ g_datalist_foreach(&fd_handler_list, find_max_fd_foreach, (gpointer)&tmpmax);
+ max_fd = MAX(x_fd, tmpmax);
+}
+
+void fd_event_handle_foreach(GQuark n, gpointer data, gpointer user_data)
+{
+ if (FD_ISSET( (int)n, &selset)) {
+ event_fd_handler *h = (event_fd_handler *)data;
+ g_assert(h->fd == (int)n);
+ h->handler(h->fd, h->data);
+ }
+}
+
+void fd_event_handle()
+{
+ g_datalist_foreach(&fd_handler_list, fd_event_handle_foreach, NULL);
+}
+
static void event_handle_slitapp(SlitApp *app, XEvent *e)
{
switch (e->type) {
menu_add_entry(m, menu_entry_new_submenu("subz", s));
- /*
t = (Menu *)plugin_create("timed_menu");
a = action_from_string("execute");
a->data.execute.path = g_strdup("xeyes");
menu_add_entry(t, menu_entry_new("xeyes", a));
menu_add_entry(m, menu_entry_new_submenu("timed", t));
- */
s = menu_new("empty", "chub", m);
menu_add_entry(m, menu_entry_new_submenu("empty", s));
menu_add_entry(s, menu_entry_new("exit", a));
menu_add_entry(m, menu_entry_new_submenu("long", s));
-
+
m = menu_new(NULL, "client", NULL);
a = action_from_string("iconify");
menu_add_entry(m, menu_entry_new("iconify", a));
menu_entry_free(entry);
}
self->entries = NULL;
+ self->invalid = TRUE;
}
#include <glib.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
#include "kernel/menu.h"
#include "kernel/timer.h"
#include "timed_menu.h"
#include "kernel/action.h"
+#include "kernel/event.h"
#define TIMED_MENU(m) ((Menu *)m)
#define TIMED_MENU_DATA(m) ((Timed_Menu_Data *)((Menu *)m)->plugin_data)
Timed_Menu_Type type;
Timer *timer; /* timer code handles free */
char *command; /* for the PIPE */
+ char *buf;
+ unsigned long buflen;
+ int fd;
} Timed_Menu_Data;
{ }
void plugin_shutdown() { }
-void timed_menu_timeout_handler(void *data)
+void timed_menu_clean_up(Menu *m) {
+ if (TIMED_MENU_DATA(m)->buf != NULL) {
+ fprintf(stderr, "%s", TIMED_MENU_DATA(m)->buf);
+ g_free(TIMED_MENU_DATA(m)->buf);
+ TIMED_MENU_DATA(m)->buf = NULL;
+ }
+
+ TIMED_MENU_DATA(m)->buflen = 0;
+
+ if (TIMED_MENU_DATA(m)->fd != -1) {
+ event_remove_fd(TIMED_MENU_DATA(m)->fd);
+ close(TIMED_MENU_DATA(m)->fd);
+ TIMED_MENU_DATA(m)->fd = -1;
+ }
+
+ /* child is reaped by glib ? */
+}
+
+void timed_menu_read_pipe(int fd, Menu *menu)
+{
+ char *tmpbuf = NULL;
+ unsigned long num_read;
+#ifdef DEBUG
+ Timed_Menu_Data *d = TIMED_MENU_DATA(menu);
+#endif
+
+ unsigned long num_realloc;
+ /* if we have less than a quarter BUFSIZ left, allocate more */
+ num_realloc = (BUFSIZ - (TIMED_MENU_DATA(menu)->buflen % BUFSIZ) <
+ BUFSIZ >> 2) ?
+ 0 : BUFSIZ;
+
+ tmpbuf = g_try_realloc(TIMED_MENU_DATA(menu)->buf,
+ TIMED_MENU_DATA(menu)->buflen + num_realloc);
+
+ if (tmpbuf == NULL) {
+ g_warning("Unable to allocate memory for read()");
+ return;
+ }
+
+ TIMED_MENU_DATA(menu)->buf = tmpbuf;
+
+ num_read = read(fd,
+ TIMED_MENU_DATA(menu)->buf + TIMED_MENU_DATA(menu)->buflen,
+ num_realloc);
+ if (num_read == 0) {
+ unsigned long count = 0;
+ char *found = NULL;
+ menu->invalid = TRUE;
+ menu_clear(menu);
+
+ /* TEMP: list them */
+ while (NULL !=
+ (found = strchr(&TIMED_MENU_DATA(menu)->buf[count], '\n'))) {
+ TIMED_MENU_DATA(menu)->buf
+ [found - TIMED_MENU_DATA(menu)->buf] = '\0';
+ menu_add_entry(menu,
+ menu_entry_new_separator
+ (&TIMED_MENU_DATA(menu)->buf[count]));
+ count = found - TIMED_MENU_DATA(menu)->buf + 1;
+ }
+
+
+ TIMED_MENU_DATA(menu)->buf[TIMED_MENU_DATA(menu)->buflen] = '\0';
+ timed_menu_clean_up(menu);
+ } else if (num_read > 0) {
+ TIMED_MENU_DATA(menu)->buflen += num_read;
+ TIMED_MENU_DATA(menu)->buf[TIMED_MENU_DATA(menu)->buflen] = '\0';
+ } else { /* num_read < 1 */
+ g_warning("Error on read %s", strerror(errno));
+ timed_menu_clean_up(menu);
+ }
+}
+
+void timed_menu_timeout_handler(Menu *data)
{
Action *a;
- ((Menu *)data)->invalid = TRUE;
- if (!TIMED_MENU(data)->shown) {
+ if (!data->shown && TIMED_MENU_DATA(data)->fd == -1) {
switch (TIMED_MENU_DATA(data)->type) {
case (TIMED_MENU_PIPE):
{
/* if the menu is not shown, run a process and use its output
as menu */
+
+ /* I hate you glib in all your hideous forms */
char *args[] = {"/bin/sh", "-c", TIMED_MENU_DATA(data)->command,
NULL};
- GIOChannel *io;
- char *line;
- gint child, c_stdout, line_len, terminator_pos;
- GIOStatus status;
- /* this blocks for now, until the event stuff can handle it */
- if (!g_spawn_async_with_pipes(NULL,
+ int child_stdout;
+ if (g_spawn_async_with_pipes(
+ NULL,
args,
NULL,
- G_SPAWN_DO_NOT_REAP_CHILD,
- NULL, NULL,
- &child, NULL, &c_stdout, NULL,
+ G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ &child_stdout,
+ NULL,
NULL)) {
- g_warning("%s: Unable to run timed_menu program",
- __FUNCTION__);
- break;
- }
-
- io = g_io_channel_unix_new(c_stdout);
- if (io == NULL) {
- g_error("%s: Unable to get IO channel", __FUNCTION__);
- break;
- }
-
- menu_clear(TIMED_MENU(data));
-
- while ( G_IO_STATUS_NORMAL == (status =
- g_io_channel_read_line
- (io, &line, &line_len, &terminator_pos, NULL))
- ) {
- /* the \n looks ugly */
- line[terminator_pos] = '\0';
- menu_add_entry(TIMED_MENU(data),
- menu_entry_new_separator(line));
- g_message("%s", line);
- g_free(line);
+ event_fd_handler *h = g_new(event_fd_handler, 1);
+ TIMED_MENU_DATA(data)->fd = h->fd = child_stdout;
+ h->handler = timed_menu_read_pipe;
+ h->data = data;
+ event_add_fd_handler(h);
+ } else {
+ g_warning("unable to spawn child");
}
+
break;
}
}
m->plugin = PLUGIN_NAME;
d->type = TIMED_MENU_PIPE;
- d->timer = timer_start(1000000, &timed_menu_timeout_handler, m);
- d->command = "ls";
+ d->timer = timer_start(60000000, &timed_menu_timeout_handler, m);
+ d->command = "find /media -name *.m3u";
+ d->buf = NULL;
+ d->buflen = 0;
+ d->fd = -1;
m->plugin_data = (void *)d;
-
+
+ timed_menu_timeout_handler(m);
return (void *)m;
}
projects / chaz / openbox / commitdiff
