X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=plugins%2Fmenu%2Ftimed_menu.c;h=3bf820a7ce6da5793e37558ffa2c44536c4f4c7d;hb=d987d339512083d2fe2fddeee7dc23a6a140e13b;hp=2c2643474425f203abcea8aecb24a67e95f4aeb7;hpb=a8a4a2cca30602b66b7a7f68bb9f3fffd34e92c9;p=chaz%2Fopenbox diff --git a/plugins/menu/timed_menu.c b/plugins/menu/timed_menu.c index 2c264347..3bf820a7 100644 --- a/plugins/menu/timed_menu.c +++ b/plugins/menu/timed_menu.c @@ -1,22 +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) ((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; @@ -25,49 +41,205 @@ 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; - printf("woop timer %s\n", ((Menu *)data)->name); - ((Menu *)data)->invalid = TRUE; - - if (((Menu *)data)->shown) { - a = action_from_string("execute"); - a->data.execute.path = g_strdup("xeyes"); - menu_add_entry((Menu *)data, menu_entry_new("xeyes", a)); - - menu_show_full( (Menu *)data, ((Menu *)data)->location.x, - ((Menu *)data)->location.y, NULL); - } else { - GList *it; - - for (it = ((Menu *)data)->entries; it; it = it->next) { - MenuEntry *entry = it->data; - menu_entry_free(entry); - } - ((Menu *)data)->entries = NULL; + 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 (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) { + xmlDocPtr doc; + xmlNodePtr node; + + menu->invalid = TRUE; + menu_clear(menu); + + TIMED_MENU_DATA(menu)->buf[TIMED_MENU_DATA(menu)->buflen] = '\0'; + + doc = xmlParseMemory(TIMED_MENU_DATA(menu)->buf, + TIMED_MENU_DATA(menu)->buflen); + + 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): { + /* 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[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_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, + NULL, + NULL, + &child_pid, + NULL, + &child_stdout, + NULL, + NULL)) { + 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"); + } + 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; + } + + 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 */ + } + } + } } } -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 *)((Menu *)m)->plugin_data)->timer); + timer_stop( ((Timed_Menu_Data *)TIMED_MENU(m)->plugin_data)->timer); - g_free( ((Menu *)m)->plugin_data ); + g_free( TIMED_MENU(m)->plugin_data ); }