#include <errno.h>
#include <string.h>
#include <stdio.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <sys/stat.h>
#include "kernel/menu.h"
#include "kernel/timer.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;
- unsigned long buflen;
- int fd;
- pid_t pid;
+ 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;
{ }
void plugin_shutdown() { }
-void timed_menu_clean_up(Menu *m) {
+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);
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, Menu *menu)
+void timed_menu_read_pipe(int fd, void *d)
{
+ 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;
TIMED_MENU_DATA(menu)->buf + TIMED_MENU_DATA(menu)->buflen,
num_realloc);
if (num_read == 0) {
- unsigned long count = 0;
- char *found = NULL;
+ xmlDocPtr doc;
+ xmlNodePtr node;
+
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';
+
+ 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_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;
}
}
-void timed_menu_timeout_handler(Menu *data)
+void timed_menu_timeout_handler(ObTimer *t, void *d)
{
- Action *a;
-
+ 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 */
/* I hate you glib in all your hideous forms */
- char *args[] = {"/bin/sh", "-c", TIMED_MENU_DATA(data)->command,
- NULL};
+ 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,
- &TIMED_MENU_DATA(data)->pid,
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(60000000, &timed_menu_timeout_handler, m);
- d->command = "find /media -name *.m3u";
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);
+ timed_menu_timeout_handler(NULL, 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);
projects / chaz / openbox / blobdiff