M openbox/event.c → openbox/event.c

@@ -14,10 +14,13 @@ #include "stacking.h"
 #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
@@ -51,6 +54,12 @@ Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
 };
 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]);
@@ -77,18 +86,22 @@ if (scroll_lock == modmap->modifiermap[cnt])
 		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;
 
@@ -117,15 +130,19 @@ }
 	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();
     }
 }
 
@@ -930,6 +947,40 @@ case LeaveNotify:
         slit_hide(s, TRUE);
         break;
     }
+}
+
+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)

M openbox/event.h → openbox/event.h

@@ -14,6 +14,15 @@ 
 void event_startup();
 void event_shutdown();
 
+typedef struct event_fd_handler {
+    int fd;
+    void *data;
+    void (*handler)(int fd, void *data);
+} event_fd_handler;
+
+void event_add_fd_handler(event_fd_handler *handler);
+void event_remove_fd(int n);
+
 void event_loop();
 
 #endif

M openbox/menu.c → openbox/menu.c

@@ -92,13 +92,11 @@ menu_add_entry(s, menu_entry_new("xclock", a));
 
     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));
@@ -121,7 +119,7 @@ a = action_from_string("exit");
     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));
@@ -312,6 +310,7 @@ MenuEntry *entry = it->data;
 	menu_entry_free(entry);
     }
     self->entries = NULL;
+    self->invalid = TRUE;
 }
 
 

M plugins/menu/timed_menu.c → plugins/menu/timed_menu.c

@@ -1,9 +1,14 @@ 
 #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)
@@ -22,6 +27,9 @@ typedef struct {
     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;
 
 
@@ -30,55 +38,116 @@ void plugin_startup()
 { }
 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;
+                    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");
                 }
-
-                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);
-                }
+                    
                 break;
             }
         }
@@ -93,11 +162,15 @@ 
     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;
 }