Use GString for appending strings
[dana/openbox.git] / tools / obxprop / obxprop.c
1 #include <X11/Xlib.h>
2 #include <X11/cursorfont.h>
3 #include <stdlib.h>
4 #include <string.h>
5 #include <stdio.h>
6 #include <assert.h>
7 #include <glib.h>
8
9 gint fail(const gchar *s) {
10     if (s)
11         fprintf(stderr, "%s\n", s);
12     else
13         fprintf
14             (stderr,
15              "Usage: obxprop [OPTIONS] [--] [PROPERTIES ...]\n\n"
16              "Options:\n"
17              "    --help              Display this help and exit\n"
18              "    --display DISPLAY   Connect to this X display\n"
19              "    --id ID             Show the properties for this window\n"
20              "    --root              Show the properties for the root window\n");
21     return 1;
22 }
23
24 gint parse_hex(gchar *s) {
25     gint result = 0;
26     while (*s) {
27         gint add;
28         if (*s >= '0' && *s <='9')
29             add = *s-'0';
30         else if (*s >= 'A' && *s <='F')
31             add = *s-'A'+10;
32         else if (*s >= 'a' && *s <='f')
33             add = *s-'a'+10;
34         else
35             break;
36
37         result *= 16;
38         result += add;
39         ++s;
40     }
41     return result;
42 }
43
44 Window find_client(Display *d, Window win)
45 {
46     Window r, *children;
47     guint n, i;
48     Atom state = XInternAtom(d, "WM_STATE", True);
49     Atom ret_type;
50     gint ret_format, res;
51     gulong ret_items, ret_bytesleft, *xdata;
52
53     XQueryTree(d, win, &r, &r, &children, &n);
54     for (i = 0; i < n; ++i) {
55         Window w = find_client(d, children[i]);
56         if (w) return w;
57     }
58
59     // try me
60     res = XGetWindowProperty(d, win, state, 0, 1,
61                        False, state, &ret_type, &ret_format,
62                        &ret_items, &ret_bytesleft,
63                        (unsigned char**) &xdata);
64     XFree(xdata);
65     if (res != Success || ret_type == None || ret_items < 1)
66         return None;
67     return win; // found it!
68 }
69
70 static gboolean get_all(Display *d, Window win, Atom prop,
71                         Atom *type, gint *size,
72                         guchar **data, guint *num)
73 {
74     gboolean ret = FALSE;
75     gint res;
76     guchar *xdata = NULL;
77     gulong ret_items, bytes_left;
78
79     res = XGetWindowProperty(d, win, prop, 0l, G_MAXLONG,
80                              FALSE, AnyPropertyType, type, size,
81                              &ret_items, &bytes_left, &xdata);
82     if (res == Success) {
83         if (ret_items > 0) {
84             guint i;
85
86             *data = g_malloc(ret_items * (*size / 8));
87             for (i = 0; i < ret_items; ++i)
88                 switch (*size) {
89                 case 8:
90                     (*data)[i] = xdata[i];
91                     break;
92                 case 16:
93                     ((guint16*)*data)[i] = ((gushort*)xdata)[i];
94                     break;
95                 case 32:
96                     ((guint32*)*data)[i] = ((gulong*)xdata)[i];
97                     break;
98                 default:
99                     g_assert_not_reached(); /* unhandled size */
100                 }
101         }
102         *num = ret_items;
103         ret = TRUE;
104         XFree(xdata);
105     }
106     return ret;
107 }
108
109 GString *append_string(GString *before, gchar *after, gboolean quote)
110 {
111     const gchar *q = quote ? "\"" : "";
112     if (before)
113         g_string_append_printf(before, ", %s%s%s", q, after, q);
114     else
115         g_string_append_printf(before = g_string_new(NULL), "%s%s%s", q, after, q);
116     return before;
117 }
118
119 GString *append_int(GString *before, guint after)
120 {
121     if (before)
122         g_string_append_printf(before, ", %u", after);
123     else
124         g_string_append_printf(before = g_string_new(NULL), "%u", after);
125     return before;
126 }
127
128 gchar* read_strings(gchar *val, guint n, gboolean utf8)
129 {
130     GSList *strs = NULL, *it;
131     GString *ret;
132     gchar *p;
133     guint i;
134
135     p = val;
136     while (p < val + n) {
137         strs = g_slist_append(strs, g_strndup(p, n - (p - val)));
138         p += strlen(p) + 1; /* next string */
139     }
140
141     ret = NULL;
142     for (i = 0, it = strs; it; ++i, it = g_slist_next(it)) {
143         char *data;
144
145         if (utf8) {
146             if (g_utf8_validate(it->data, -1, NULL))
147                 data = g_strdup(it->data);
148             else
149                 data = g_strdup("");
150         }
151         else
152             data = g_locale_to_utf8(it->data, -1, NULL, NULL, NULL);
153
154         ret = append_string(ret, data, TRUE);
155         g_free(data);
156     }
157
158     while (strs) {
159         g_free(strs->data);
160         strs = g_slist_delete_link(strs, strs);
161     }
162     if (ret)
163         return g_string_free(ret, FALSE);
164     return NULL;
165 }
166
167 gchar* read_atoms(Display *d, guchar *val, guint n)
168 {
169     GString *ret;
170     guint i;
171
172     ret = NULL;
173     for (i = 0; i < n; ++i)
174         ret = append_string(ret, XGetAtomName(d, ((guint32*)val)[i]), FALSE);
175     if (ret)
176         return g_string_free(ret, FALSE);
177     return NULL;
178 }
179
180 gchar* read_numbers(guchar *val, guint n, guint size)
181 {
182     GString *ret;
183     guint i;
184
185     ret = NULL;
186     for (i = 0; i < n; ++i)
187         switch (size) {
188         case 8:
189             ret = append_int(ret, ((guint8*)val)[i]);
190             break;
191         case 16:
192             ret = append_int(ret, ((guint16*)val)[i]);
193             break;
194         case 32:
195             ret = append_int(ret, ((guint32*)val)[i]);
196             break;
197         default:
198             g_assert_not_reached(); /* unhandled size */
199         }
200
201     if (ret)
202         return g_string_free(ret, FALSE);
203     return NULL;
204 }
205
206 gboolean read_prop(Display *d, Window w, Atom prop, const gchar **type, gchar **val)
207 {
208     guchar *ret;
209     guint nret;
210     gint size;
211     Atom ret_type;
212
213     ret = NULL;
214     if (get_all(d, w, prop, &ret_type, &size, &ret, &nret)) {
215         *type = XGetAtomName(d, ret_type);
216
217         if (strcmp(*type, "STRING") == 0)
218             *val = read_strings((gchar*)ret, nret, FALSE);
219         else if (strcmp(*type, "UTF8_STRING") == 0)
220             *val = read_strings((gchar*)ret, nret, TRUE);
221         else if (strcmp(*type, "ATOM") == 0) {
222             g_assert(size == 32);
223             *val = read_atoms(d, ret, nret);
224         }
225        else
226             *val = read_numbers(ret, nret, size);
227
228         g_free(ret);
229         return TRUE;
230     }
231     return FALSE;
232 }
233
234 void show_properties(Display *d, Window w, int argc, char **argv)
235 {
236     Atom* props;
237     int i, n;
238
239     props = XListProperties(d, w, &n);
240
241     for (i = 0; i < n; ++i) {
242         const char *type;
243         char *name, *val;
244
245         name = XGetAtomName(d, props[i]);
246
247         if (read_prop(d, w, props[i], &type, &val)) {
248             int found = 1;
249             if (argc) {
250                 int i;
251
252                 found = 0;
253                 for (i = 0; i < argc; i++)
254                     if (!strcmp(name, argv[i])) {
255                         found = 1;
256                         break;
257                     }
258             }
259             if (found)
260                 g_print("%s(%s) = %s\n", name, type, (val ? val : ""));
261             g_free(val);
262         }
263
264         XFree(name);
265     }
266
267     XFree(props);
268 }
269
270 int main(int argc, char **argv)
271 {
272     Display *d;
273     Window id, userid = None;
274     int i;
275     char *dname = NULL;
276     gboolean root = FALSE;
277
278     for (i = 1; i < argc; ++i) {
279         if (!strcmp(argv[i], "--help")) {
280             return fail(NULL);
281         }
282         else if (!strcmp(argv[i], "--root"))
283             root = TRUE;
284         else if (!strcmp(argv[i], "--id")) {
285             if (++i == argc)
286                 return fail(NULL);
287             if (argv[i][0] == '0' && argv[i][1] == 'x') {
288                 /* hex */
289                 userid = parse_hex(argv[i]+2);
290             }
291             else {
292                 /* decimal */
293                 userid = atoi(argv[i]);
294             }
295             if (!userid)
296                 return fail("Unable to parse argument to --id.");
297         }
298         else if (!strcmp(argv[i], "--display")) {
299             if (++i == argc)
300                 return fail(NULL);
301             dname = argv[i];
302         }
303         else if (*argv[i] != '-')
304             break;
305         else if (!strcmp(argv[i], "--")) {
306             i++;
307             break;
308         }
309         else
310             return fail(NULL);
311     }
312
313     d = XOpenDisplay(dname);
314     if (!d) {
315         return fail("Unable to find an X display. "
316                     "Ensure you have permission to connect to the display.");
317     }
318
319     if (root)
320         userid = RootWindow(d, DefaultScreen(d));
321
322     if (userid == None) {
323         int j;
324         j = XGrabPointer(d, RootWindow(d, DefaultScreen(d)),
325                          False, ButtonPressMask,
326                          GrabModeAsync, GrabModeAsync,
327                          None, XCreateFontCursor(d, XC_crosshair),
328                          CurrentTime);
329         if (j != GrabSuccess)
330             return fail("Unable to grab the pointer device");
331         while (1) {
332             XEvent ev;
333
334             XNextEvent(d, &ev);
335             if (ev.type == ButtonPress) {
336                 XUngrabPointer(d, CurrentTime);
337                 userid = ev.xbutton.subwindow;
338                 break;
339             }
340         }
341         id = find_client(d, userid);
342     }
343     else
344         id = userid; /* they picked this one */
345
346     if (id == None)
347         return fail("Unable to find window with the requested ID");
348
349     show_properties(d, id, argc - i, &argv[i]);
350     
351     XCloseDisplay(d);
352
353     return 0;
354 }