X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=plugins%2Fmenu%2Ftimed_menu.c;h=db642fc173152b8d486904d702188a62120c71ab;hb=b52b5a6fc0f57bf27ba885b85fdd63a9419f4383;hp=34d71e73c3ff19a192a4b20e53c7d6a29058f080;hpb=03d42b5d8253ad2de94df20b12b9fb22ce51eb3d;p=chaz%2Fopenbox diff --git a/plugins/menu/timed_menu.c b/plugins/menu/timed_menu.c index 34d71e73..db642fc1 100644 --- a/plugins/menu/timed_menu.c +++ b/plugins/menu/timed_menu.c @@ -1,27 +1,38 @@ #include +#include +#include +#include +#include +#include +#include +#include +#include +#include #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) +#define TIMED_MENU(m) ((ObMenu *)m) +#define TIMED_MENU_DATA(m) ((Timed_Menu_Data *)((ObMenu *)m)->plugin_data) static char *PLUGIN_NAME = "timed_menu"; typedef enum { - TIMED_MENU_PIPE + TIMED_MENU_PIPE, /* read entries from a child process' output */ + TIMED_MENU_STAT /* reread entries from file when timestamp changes */ } Timed_Menu_Type; -/* we can use various GIO channels to support reading menus (can we add them to - the event loop? ) - stat() based update - exec() based read -*/ typedef struct { Timed_Menu_Type type; - Timer *timer; /* timer code handles free */ + ObTimer *timer; char *command; /* for the PIPE */ + char *buf; /* buffer to hold partially read menu */ + unsigned long buflen; /* how many bytes are in the buffer */ + int fd; /* file descriptor to read menu from */ + pid_t pid; /* pid of child process in PIPE */ + time_t mtime; /* time of last modification */ } Timed_Menu_Data; @@ -30,77 +41,200 @@ void plugin_startup() { } void plugin_shutdown() { } -void timed_menu_timeout_handler(void *data) +void timed_menu_clean_up(ObMenu *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; + } + + if (TIMED_MENU_DATA(m)->pid != -1) { + waitpid(TIMED_MENU_DATA(m)->pid, NULL, 0); + TIMED_MENU_DATA(m)->pid = -1; + } + + TIMED_MENU_DATA(m)->mtime = 0; +} + +void timed_menu_read_pipe(int fd, void *d) { - Action *a; - ((Menu *)data)->invalid = TRUE; + ObMenu *menu = d; + char *tmpbuf = NULL; + unsigned long num_read; +#ifdef DEBUG + /* because gdb is dumb */ +#if 0 + Timed_Menu_Data *d = TIMED_MENU_DATA(menu); +#endif +#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 (!TIMED_MENU(data)->shown) { + 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) { + menu->invalid = TRUE; + menu_clear(menu); + + TIMED_MENU_DATA(menu)->buf[TIMED_MENU_DATA(menu)->buflen] = '\0'; + + xmlDocPtr doc = xmlParseMemory(TIMED_MENU_DATA(menu)->buf, + TIMED_MENU_DATA(menu)->buflen); + + xmlNodePtr node = xmlDocGetRootElement(doc); + + if (!xmlStrcasecmp(node->name, (const xmlChar*) "timed_menu")) { + if ((node = parse_find_node("item", node->xmlChildrenNode))) + parse_menu_full(doc, node, menu, FALSE); + } + + 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(void *d) +{ + ObMenu *data = d; + if (!data->shown && TIMED_MENU_DATA(data)->fd == -1) { switch (TIMED_MENU_DATA(data)->type) { - case (TIMED_MENU_PIPE): - { + case (TIMED_MENU_PIPE): { /* if the menu is not shown, run a process and use its output as menu */ - char *args[] = {"/bin/sh", "-c", "ls", 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, + + /* I hate you glib in all your hideous forms */ + char *args[4]; + int child_stdout; + int child_pid; + args[0] = "/bin/sh"; + args[1] = "-c"; + args[2] = TIMED_MENU_DATA(data)->command; + args[3] = NULL; + 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, + &child_pid, + NULL, + &child_stdout, + NULL, NULL)) { - g_warning("%s: Unable to run timed_menu program", - __FUNCTION__); - break; + event_fd_handler *h = g_new(event_fd_handler, 1); + TIMED_MENU_DATA(data)->fd = h->fd = child_stdout; + TIMED_MENU_DATA(data)->pid = child_pid; + h->handler = timed_menu_read_pipe; + h->data = data; + event_add_fd_handler(h); + } else { + g_warning("unable to spawn child"); } - - io = g_io_channel_unix_new(c_stdout); - if (io == NULL) { - g_error("%s: Unable to get IO channel", __FUNCTION__); + break; + } + + case (TIMED_MENU_STAT): { + struct stat stat_buf; + + if (stat(TIMED_MENU_DATA(data)->command, &stat_buf) == -1) { + g_warning("Unable to stat %s: %s", + TIMED_MENU_DATA(data)->command, + strerror(errno)); 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); + if (stat_buf.st_mtime > TIMED_MENU_DATA(data)->mtime) { + g_warning("file changed"); + TIMED_MENU_DATA(data)->mtime = stat_buf.st_mtime; + /* TODO: parse */ } - break; } } } } -void *plugin_create() +void *plugin_create(PluginMenuCreateData *data) { - Timed_Menu_Data *d = g_new(Timed_Menu_Data, 1); - Menu *m = menu_new("", PLUGIN_NAME, NULL); + char *id; + char *label; + char *timeout; + Timed_Menu_Data *d; + ObMenu *m; + parse_attr_string("id", data->node, &id); + parse_attr_string("label", data->node, &label); + + d = g_new(Timed_Menu_Data, 1); + + m = menu_new( (label != NULL ? label : ""), + (id != NULL ? id : PLUGIN_NAME), + data->parent); + m->plugin = PLUGIN_NAME; + if (data->parent) + menu_add_entry(data->parent, menu_entry_new_submenu( + (label != NULL ? label : ""), + m)); + + if (!parse_attr_string("command", data->node, &d->command)) { + d->command = g_strdup(""); + } + + if (parse_attr_string("timeout", data->node, &timeout)) { + char *endptr; + gdouble timeout_val = g_strtod(timeout, &endptr); + g_free(timeout); + d->timer = timer_start(timeout_val * 1000000, + &timed_menu_timeout_handler, m); + } else + d->timer = timer_start(600 * 1000000, &timed_menu_timeout_handler, m); + d->type = TIMED_MENU_PIPE; - d->timer = timer_start(1000000, &timed_menu_timeout_handler, m); + d->buf = NULL; + d->buflen = 0; + d->fd = -1; + d->pid = -1; + d->mtime = 0; m->plugin_data = (void *)d; - + + timed_menu_timeout_handler(m); return (void *)m; } void plugin_destroy (void *m) { + timed_menu_clean_up(m); /* this will be freed by timer_* */ timer_stop( ((Timed_Menu_Data *)TIMED_MENU(m)->plugin_data)->timer);