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

remove the last of the plugin stuff

Browse source
This commit is contained in:
Dana Jansens 2003-08-30 19:07:26 +00:00
parent e10b4aacc3
commit d0b9c28dc1
10 changed files with 0 additions and 727 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
plugins/.cvsignore
View file

@ -1,2 +0,0 @@
.libs
.deps

15
plugins/interface.h
View file

@ -1,15 +0,0 @@
#ifndef __plugins_interface_h
#define __plugins_interface_h
struct _ObParseInst;
/* plugin_setup_config() */
typedef void (*PluginSetupConfig)(struct _ObParseInst *i);
/* plugin_startup() */
typedef void (*PluginStartup)(void);
/* plugin_shutdown() */
typedef void (*PluginShutdown)(void);
#endif

13
plugins/menu/.cvsignore
View file

@ -1,13 +0,0 @@
.deps
.libs
timed_menu.la
fifo_menu.la
client_menu.la
client_list_menu.la
include_menu.la
.dirstamp
plugins_menu_client_menu_la-client_menu.lo
plugins_menu_client_list_menu_la-client_list_menu.lo
plugins_menu_fifo_menu_la-fifo_menu.lo
plugins_menu_timed_menu_la-timed_menu.lo
plugins_menu_include_menu_la-include_menu.lo

4
plugins/menu/Makefile
View file

@ -1,4 +0,0 @@
all clean install:
$(MAKE) -C ../.. -$(MAKEFLAGS) $@
.PHONY: all clean install

279
plugins/menu/fifo_menu.c
View file

@ -1,279 +0,0 @@
/*
* $Header$
*
* FFIO menu plugin
* Provides a menu from a FIFO located in ~/.openbox/fifo_menu/id
* Example:
* rc3:
* <menu id="fonk" label="fonk" plugin="fifo_menu"></menu>
* Menu format
* <fifo_menu>
* <item label="GLOVE.png">
* <action name="execute">
* <execute>
* bsetbg "/home/woodblock/.openbox/backgrounds/GLOVE.png"
* </execute>
* </action>
* </item>
* </fifo_menu>
*
* If the attribute pid="true" is in the <menu>
*/
#include <glib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include "kernel/menu.h"
#include "kernel/event.h"
static char *PLUGIN_NAME = "fifo_menu";
typedef struct Fifo_Menu_Data {
char *fifo;
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 */
gboolean use_pid;
event_fd_handler *handler;
} Fifo_Menu_Data;
#define FIFO_MENU(m) ((ObMenu *)m)
#define FIFO_MENU_DATA(m) ((Fifo_Menu_Data *)((ObMenu *)m)->plugin_data)
void fifo_menu_clean_up(ObMenu *m) {
if (FIFO_MENU_DATA(m)->buf != NULL) {
g_free(FIFO_MENU_DATA(m)->buf);
FIFO_MENU_DATA(m)->buf = NULL;
FIFO_MENU_DATA(m)->buflen = 0;
}
if (FIFO_MENU_DATA(m)->fd != -1) {
close(FIFO_MENU_DATA(m)->fd);
FIFO_MENU_DATA(m)->fd = -1;
}
}
void plugin_setup_config() { }
void plugin_startup()
{ }
void plugin_shutdown() { }
void fifo_menu_handler(int fd, void *d) {
ObMenu *menu = d;
char *tmpbuf = NULL;
unsigned long num_read;
#ifdef DEBUG
/* because gdb is dumb */
#if 0
Fifo_Menu_Data *d = FIFO_MENU_DATA(menu);
#endif
#endif
/* if the menu is shown this will go into busy loop :(
fix me*/
if (!menu->shown) {
unsigned long num_realloc;
/* if we have less than a quarter BUFSIZ left, allocate more */
num_realloc = (BUFSIZ - (FIFO_MENU_DATA(menu)->buflen % BUFSIZ) <
BUFSIZ >> 2) ?
0 : BUFSIZ;
tmpbuf = g_try_realloc(FIFO_MENU_DATA(menu)->buf,
FIFO_MENU_DATA(menu)->buflen + num_realloc);
if (tmpbuf == NULL) {
g_warning("Unable to allocate memory for read()");
return;
}
FIFO_MENU_DATA(menu)->buf = tmpbuf;
num_read = read(fd,
FIFO_MENU_DATA(menu)->buf +
FIFO_MENU_DATA(menu)->buflen,
num_realloc);
if (num_read == 0) { /* eof */
ObParseInst *i;
xmlDocPtr doc;
xmlNodePtr node;
menu->invalid = TRUE;
menu_clear(menu);
FIFO_MENU_DATA(menu)->buf[FIFO_MENU_DATA(menu)->buflen] = '\0';
i = parse_startup();
if (parse_load_mem(FIFO_MENU_DATA(menu)->buf,
FIFO_MENU_DATA(menu)->buflen,
"fifo_menu", &doc, &node))
parse_menu_full(i, doc, node, menu, FALSE);
parse_shutdown(i);
fifo_menu_clean_up(menu);
event_remove_fd(FIFO_MENU_DATA(menu)->handler->fd);
if ((FIFO_MENU_DATA(menu)->fd =
open(FIFO_MENU_DATA(menu)->fifo,
O_NONBLOCK | O_RDONLY)) == -1) {
g_warning("Can't reopen FIFO");
fifo_menu_clean_up(menu);
return;
}
FIFO_MENU_DATA(menu)->handler->fd = FIFO_MENU_DATA(menu)->fd;
event_add_fd_handler(FIFO_MENU_DATA(menu)->handler);
} else if (num_read > 0) {
FIFO_MENU_DATA(menu)->buflen += num_read;
FIFO_MENU_DATA(menu)->buf[FIFO_MENU_DATA(menu)->buflen] = '\0';
}
}
}
void plugin_destroy (ObMenu *m)
{
fifo_menu_clean_up(m);
if (FIFO_MENU_DATA(m)->handler != NULL) {
g_free(FIFO_MENU_DATA(m)->handler);
FIFO_MENU_DATA(m)->handler = NULL;
}
if (FIFO_MENU_DATA(m)->fifo != NULL) {
g_free(FIFO_MENU_DATA(m)->fifo);
FIFO_MENU_DATA(m)->fifo = NULL;
}
if (FIFO_MENU_DATA(m)->buf != NULL) {
g_free(FIFO_MENU_DATA(m)->buf);
FIFO_MENU_DATA(m)->buf = NULL;
}
g_free(m->plugin_data);
menu_free(m->name);
}
void *plugin_create(PluginMenuCreateData *data)
{
char *fifo;
char *dir;
event_fd_handler *h;
Fifo_Menu_Data *d;
ObMenu *m;
char *label = NULL, *id = NULL;
char *attr_pid = NULL;
d = g_new(Fifo_Menu_Data, 1);
parse_attr_string("id", data->node, &id);
parse_attr_string("label", data->node, &label);
if (parse_attr_string("pid", data->node, &attr_pid) &&
g_strcasecmp(attr_pid, "true") == 0) {
d->use_pid = TRUE;
} else
d->use_pid = FALSE;
m = menu_new( (label != NULL ? label : ""),
(id != NULL ? id : PLUGIN_NAME),
data->parent);
if (data->parent)
menu_add_entry(data->parent, menu_entry_new_submenu(
(label != NULL ? label : ""),
m));
g_free(label);
g_free(id);
d->fd = -1;
d->buf = NULL;
d->buflen = 0;
d->handler = NULL;
m->plugin = PLUGIN_NAME;
d->fd = -1;
m->plugin_data = (void *)d;
dir = g_build_filename(g_get_home_dir(), ".openbox",
PLUGIN_NAME, NULL);
if (mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO) == -1 && errno != EEXIST) {
/* technically, if ~/.openbox/fifo_menu exists and isn't a directory
this will fail, but we don't care because mkfifo will fail and warn
anyway */
g_warning("Can't create %s: %s", dir, strerror(errno));
g_free(dir);
plugin_destroy(m);
return NULL;
}
if (d->use_pid)
{
char *pid = g_strdup_printf("%s.%d", m->name, getpid());
fifo = g_build_filename(g_get_home_dir(), ".openbox",
PLUGIN_NAME,
pid, NULL);
g_free(pid);
} else {
fifo = g_build_filename(g_get_home_dir(), ".openbox",
PLUGIN_NAME,
m->name, NULL);
}
if (mkfifo(fifo, S_IRUSR | S_IWUSR |
S_IRGRP | S_IWGRP | /* let umask do its thing */
S_IROTH | S_IWOTH) == -1 && errno != EEXIST) {
g_warning("Can't create FIFO %s: %s", fifo, strerror(errno));
g_free(fifo);
g_free(d);
menu_free(m->name);
return NULL;
}
/* open in non-blocking mode so we don't wait for a process to open FIFO
for writing */
if ((d->fd = open(fifo, O_NONBLOCK | O_RDONLY)) == -1) {
g_warning("Can't open FIFO %s: %s", fifo, strerror(errno));
g_free(fifo);
g_free(d);
menu_free(m->name);
return NULL;
}
d->fifo = fifo;
h = g_new(event_fd_handler, 1);
if (h == NULL) {
g_warning("Out of memory");
close(d->fd);
g_free(fifo);
g_free(d);
menu_free(m->name);
return NULL;
}
h->fd = d->fd;
h->data = m;
h->handler = fifo_menu_handler;
d->handler = h;
event_add_fd_handler(h);
g_free(dir);
return (void *)m;
}

4
plugins/menu/fifo_menu.h
View file

@ -1,4 +0,0 @@
#ifndef __FIFO_MENU_H
#define __FIFO_MENU_H
#endif

65
plugins/menu/include_menu.c
View file

@ -1,65 +0,0 @@
#include <glib.h>
#include <stdlib.h>
#include <unistd.h>
#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"
static char *PLUGIN_NAME = "include_menu";
void plugin_setup_config() { }
void plugin_startup()
{ }
void plugin_shutdown() { }
void include_menu_clean_up(ObMenu *m) { }
void *plugin_create(PluginMenuCreateData *data)
{
char *id;
char *label;
char *filename;
ObMenu *m;
xmlDocPtr doc;
parse_attr_string("id", data->node, &id);
parse_attr_string("label", data->node, &label);
m = menu_new( (label != NULL ? label : ""),
(id != NULL ? id : PLUGIN_NAME),
data->parent);
m->plugin = PLUGIN_NAME;
parse_attr_string("filename", data->node, &filename);
doc = xmlParseFile(filename);
if (doc) {
xmlNodePtr node = xmlDocGetRootElement(doc);
if (node) {
parse_menu_full(data->parse_inst, doc, node, m, FALSE);
}
xmlFreeDoc(doc);
}
if (data->parent)
menu_add_entry(data->parent, menu_entry_new_submenu(
(label != NULL ? label : ""),
m));
return (void *)m;
}
void plugin_destroy (void *m)
{
include_menu_clean_up(m);
}

301
plugins/menu/timed_menu.c
View file

@ -1,301 +0,0 @@
/*
* $Header$
*
* Timed menu plugin
* Provides a menu from either a periodically executing process or by
* periodically checking the timestamp of a file and loading if it has changed.
*
* Examples:
* Piped timed menu:
* rc3:
* <menu id="name" label="Piped menu" plugin="timed_menu" timeout="120"
* command="obcommand.py -c bsetbg -d ~/.openbox/backgrounds/" />
* timeout is in seconds
*
* Output of command:
* <timed_menu>
* <item label="GLOVE.png">
* <action name="execute">
* <execute>
* bsetbg "/home/woodblock/.openbox/backgrounds/GLOVE.png"
* </execute>
* </action>
* </item>
* </fifo_menu>
*
* stat() menu:
* <menu id="name" label="Stat menu" plugin="timed_menu" type="stat"
* timeout="120" file="~/.openbox/stat_menu" />
* stat_menu contents: same as timed menu
*
*/
#include <glib.h>
#include <stdlib.h>
#include <unistd.h>
#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 "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, /* read entries from a child process' output */
TIMED_MENU_STAT /* reread entries from file when timestamp changes */
} Timed_Menu_Type;
typedef struct {
Timed_Menu_Type type;
ObTimer *timer;
char *command; /* command to run or file to stat() */
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_setup_config() { }
void plugin_startup()
{ }
void plugin_shutdown() { }
void timed_menu_clean_up(ObMenu *m) {
if (TIMED_MENU_DATA(m)->buf != NULL) {
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;
}
}
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;
/* 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) {
ObParseInst *i;
xmlDocPtr doc;
xmlNodePtr node;
menu->invalid = TRUE;
menu_clear(menu);
TIMED_MENU_DATA(menu)->buf[TIMED_MENU_DATA(menu)->buflen] = '\0';
i = parse_startup();
if (parse_load_mem(TIMED_MENU_DATA(menu)->buf,
TIMED_MENU_DATA(menu)->buflen,
"timed_menu", &doc, &node))
parse_menu_full(i, doc, node, menu, FALSE);
parse_shutdown(i);
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(ObTimer *t, 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) {
ObParseInst *i;
xmlDocPtr doc;
xmlNodePtr node;
g_warning("file changed");
TIMED_MENU_DATA(data)->mtime = stat_buf.st_mtime;
data->invalid = TRUE;
menu_clear(data);
i = parse_startup();
if (parse_load(TIMED_MENU_DATA(data)->command,
"timed_menu", &doc, &node))
parse_menu_full(i, doc, node, data, FALSE);
parse_shutdown(i);
timed_menu_clean_up(data);
}
}
}
}
}
void *plugin_create(PluginMenuCreateData *data)
{
char *id;
char *label;
char *timeout;
char *type;
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));
d->type = TIMED_MENU_PIPE;
if (parse_attr_string("type", data->node, &type) &&
!g_strcasecmp(type, "stat")) {
d->type = TIMED_MENU_STAT;
if (!parse_attr_string("file", data->node, &d->command)) {
d->command = g_strdup("");
}
} else
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->buf = NULL;
d->buflen = 0;
d->fd = -1;
d->pid = -1;
d->mtime = 0;
m->plugin_data = (void *)d;
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);
g_free( TIMED_MENU(m)->plugin_data );
}

4
plugins/menu/timed_menu.h
View file

@ -1,4 +0,0 @@
#ifndef __TIMED_MENU_H
#define __TIMED_MENU_H
#endif

40
plugins/obconf_interface.h
View file

@ -1,40 +0,0 @@
#ifndef __obconf_plugin_interface_h
#define __obconf_plugin_interface_h
#include "parser/parse.h"
struct GtkWidget;
#define OBCONF_INTERFACE_VERSION 1
/* plugin_interface_version() */
typedef int (*PluginInterfaceVersionFunc)(void);
/* plugin_startup() */
typedef void (*PluginStartupFunc)(void);
/* plugin_shutdown() */
typedef void (*PluginShutdownFunc)(void);
/* plugin_name() - user friendly name of the plugin */
typedef char* (*PluginNameFunc)(void);
/* plugin_plugin_name() - the name of the plugin to load with openbox */
typedef char* (*PluginPluginNameFunc)(void);
/* plugin_icon() XXX FIXME */
typedef void (*PluginIconFunc)(void);
/* plugin_toplevel_widget() */
typedef struct _GtkWidget* (*PluginToplevelWidgetFunc)(void);
/* plugin_edited() */
typedef gboolean (*PluginEditedFunc)(void);
/* plugin_load() */
typedef void (*PluginLoadFunc)(xmlDocPtr doc, xmlNodePtr root);
/* plugin_save() */
typedef void (*PluginSaveFunc)(xmlDocPtr doc, xmlNodePtr root);
#endif