prefix and capitalize ObMenu ObMenuEntry and ObMenuEntryRenderType
[mikachu/openbox.git] / plugins / menu / timed_menu.c
1 #include <glib.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <errno.h>
5 #include <string.h>
6 #include <stdio.h>
7 #include <sys/types.h>
8 #include <sys/wait.h>
9 #include <unistd.h>
10 #include <sys/stat.h>
11
12 #include "kernel/menu.h"
13 #include "kernel/timer.h"
14 #include "timed_menu.h"
15 #include "kernel/action.h"
16 #include "kernel/event.h"
17
18 #define TIMED_MENU(m) ((ObMenu *)m)
19 #define TIMED_MENU_DATA(m) ((Timed_Menu_Data *)((ObMenu *)m)->plugin_data)
20 static char *PLUGIN_NAME = "timed_menu";
21
22 typedef enum {
23     TIMED_MENU_PIPE, /* read entries from a child process' output */
24     TIMED_MENU_STAT  /* reread entries from file when timestamp changes */
25 } Timed_Menu_Type;
26
27 typedef struct {
28     Timed_Menu_Type type;
29     ObTimer *timer;
30     char *command; /* for the PIPE */
31     char *buf; /* buffer to hold partially read menu */
32     unsigned long buflen; /* how many bytes are in the buffer */
33     int fd; /* file descriptor to read menu from */
34     pid_t pid; /* pid of child process in PIPE */
35     time_t mtime; /* time of last modification */
36 } Timed_Menu_Data;
37
38
39 void plugin_setup_config() { }
40 void plugin_startup()
41 { }
42 void plugin_shutdown() { }
43
44 void timed_menu_clean_up(ObMenu *m) {
45     if (TIMED_MENU_DATA(m)->buf != NULL) {
46         fprintf(stderr, "%s", TIMED_MENU_DATA(m)->buf);
47         g_free(TIMED_MENU_DATA(m)->buf);
48         TIMED_MENU_DATA(m)->buf = NULL;
49     }
50
51     TIMED_MENU_DATA(m)->buflen = 0;
52
53     if (TIMED_MENU_DATA(m)->fd != -1) {
54         event_remove_fd(TIMED_MENU_DATA(m)->fd);
55         close(TIMED_MENU_DATA(m)->fd);
56         TIMED_MENU_DATA(m)->fd = -1;
57     }
58
59     if (TIMED_MENU_DATA(m)->pid != -1) {
60         waitpid(TIMED_MENU_DATA(m)->pid, NULL, 0);
61         TIMED_MENU_DATA(m)->pid = -1;
62     }
63
64     TIMED_MENU_DATA(m)->mtime = 0;
65 }
66
67 void timed_menu_read_pipe(int fd, void *d)
68 {
69     ObMenu *menu = d;
70     char *tmpbuf = NULL;
71     unsigned long num_read;
72 #ifdef DEBUG
73     /* because gdb is dumb */
74 #if 0
75     Timed_Menu_Data *d = TIMED_MENU_DATA(menu);
76 #endif
77 #endif
78
79     unsigned long num_realloc;
80     /* if we have less than a quarter BUFSIZ left, allocate more */
81     num_realloc = (BUFSIZ - (TIMED_MENU_DATA(menu)->buflen % BUFSIZ) <
82                    BUFSIZ >> 2) ?
83                   0 : BUFSIZ;
84     
85     tmpbuf = g_try_realloc(TIMED_MENU_DATA(menu)->buf,             
86                            TIMED_MENU_DATA(menu)->buflen + num_realloc);
87
88     if (tmpbuf == NULL) {
89         g_warning("Unable to allocate memory for read()");
90         return;
91     }
92     
93     TIMED_MENU_DATA(menu)->buf = tmpbuf;
94     
95     num_read = read(fd,
96                     TIMED_MENU_DATA(menu)->buf + TIMED_MENU_DATA(menu)->buflen,
97                     num_realloc);
98     if (num_read == 0) {
99         unsigned long count = 0;
100         char *found = NULL;
101         menu->invalid = TRUE;
102         menu_clear(menu);
103
104         /* TEMP: list them */
105         while (NULL !=
106                (found = strchr(&TIMED_MENU_DATA(menu)->buf[count], '\n'))) {
107             TIMED_MENU_DATA(menu)->buf
108                 [found - TIMED_MENU_DATA(menu)->buf] = '\0';
109             menu_add_entry(menu,
110                 menu_entry_new_separator
111                 (&TIMED_MENU_DATA(menu)->buf[count]));
112             count = found - TIMED_MENU_DATA(menu)->buf + 1;
113         }
114
115         TIMED_MENU_DATA(menu)->buf[TIMED_MENU_DATA(menu)->buflen] = '\0';
116         timed_menu_clean_up(menu);
117     } else if (num_read > 0) {
118         TIMED_MENU_DATA(menu)->buflen += num_read;
119         TIMED_MENU_DATA(menu)->buf[TIMED_MENU_DATA(menu)->buflen] = '\0';
120     } else { /* num_read < 1 */
121         g_warning("Error on read %s", strerror(errno));
122         timed_menu_clean_up(menu);
123     }
124 }
125
126 void timed_menu_timeout_handler(void *d)
127 {
128     ObMenu *data = d;
129     if (!data->shown && TIMED_MENU_DATA(data)->fd == -1) {
130         switch (TIMED_MENU_DATA(data)->type) {
131             case (TIMED_MENU_PIPE): {
132                 /* if the menu is not shown, run a process and use its output
133                    as menu */
134
135                 /* I hate you glib in all your hideous forms */
136                 char *args[4];
137                 int child_stdout;
138                 int child_pid;
139                 args[0] = "/bin/sh";
140                 args[1] = "-c";
141                 args[2] = TIMED_MENU_DATA(data)->command;
142                 args[3] = NULL;
143                 if (g_spawn_async_with_pipes(
144                         NULL,
145                         args,
146                         NULL,
147                         G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
148                         NULL,
149                         NULL,
150                         &child_pid,
151                         NULL,
152                         &child_stdout,
153                         NULL,
154                         NULL)) {
155                     event_fd_handler *h = g_new(event_fd_handler, 1);
156                     TIMED_MENU_DATA(data)->fd = h->fd = child_stdout;
157                     TIMED_MENU_DATA(data)->pid = child_pid;
158                     h->handler = timed_menu_read_pipe;
159                     h->data = data;
160                     event_add_fd_handler(h);
161                 } else {
162                     g_warning("unable to spawn child");
163                 }
164                 break;
165             }
166
167             case (TIMED_MENU_STAT): {
168                 struct stat stat_buf;
169
170                 if (stat(TIMED_MENU_DATA(data)->command, &stat_buf) == -1) {
171                     g_warning("Unable to stat %s: %s",
172                               TIMED_MENU_DATA(data)->command,
173                               strerror(errno));
174                     break;
175                 }
176
177                 if (stat_buf.st_mtime > TIMED_MENU_DATA(data)->mtime) {
178                     g_warning("file changed");
179                     TIMED_MENU_DATA(data)->mtime = stat_buf.st_mtime;
180                     /* TODO: parse */
181                 }
182             }
183         }
184     }
185 }
186
187 void *plugin_create()
188 {
189     Timed_Menu_Data *d = g_new(Timed_Menu_Data, 1);
190     ObMenu *m = menu_new("", PLUGIN_NAME, NULL);
191     
192     m->plugin = PLUGIN_NAME;
193
194     d->type = TIMED_MENU_STAT;
195     d->timer = timer_start(6000000, &timed_menu_timeout_handler, m);
196     d->command = "/home/woodblock/timed_menu_stat";
197     d->buf = NULL;
198     d->buflen = 0;
199     d->fd = -1;
200     d->pid = -1;
201     d->mtime = 0;
202     
203     m->plugin_data = (void *)d;
204
205     timed_menu_timeout_handler(m);
206     return (void *)m;
207 }
208
209 void plugin_destroy (void *m)
210 {
211     timed_menu_clean_up(m);
212     /* this will be freed by timer_* */
213     timer_stop( ((Timed_Menu_Data *)TIMED_MENU(m)->plugin_data)->timer);
214     
215     g_free( TIMED_MENU(m)->plugin_data );
216 }