nilix/openbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added a menu to read from a pipe.

Browse source 
File descriptors added to the event loop.
This commit is contained in:
Scott Moynes 2003-05-14 03:34:29 +00:00
parent 80dfe9cbe8
commit 78a8680cd7
4 changed files with 180 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

65
openbox/event.c
View file

@ -14,10 +14,13 @@
#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 @@ static const int mask_table[] = {
};
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 @@ void event_startup()
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 @@ void event_loop()
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();
}
}
@ -932,6 +949,40 @@ static void event_handle_slit(Slit *s, XEvent *e)
}
}
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) {

9
openbox/event.h
View file

@ -14,6 +14,15 @@ extern unsigned int ScrollLockMask;
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

5
openbox/menu.c
View file

@ -92,13 +92,11 @@ void menu_startup()
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 @@ void menu_startup()
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 @@ void menu_clear(Menu *self) {
menu_entry_free(entry);
}
self->entries = NULL;
self->invalid = TRUE;
}

149
plugins/menu/timed_menu.c
View file

@ -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;
}
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;
}
}
@ -93,11 +162,15 @@ void *plugin_create()
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;
}