tell what signal is going to be sent to the client when killing through the dialog
[mikachu/openbox.git] / openbox / menu.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    menu.c for the Openbox window manager
4    Copyright (c) 2006        Mikael Magnusson
5    Copyright (c) 2003-2007   Dana Jansens
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    See the COPYING file for a copy of the GNU General Public License.
18 */
19
20 #include "debug.h"
21 #include "menu.h"
22 #include "openbox.h"
23 #include "mainloop.h"
24 #include "stacking.h"
25 #include "grab.h"
26 #include "client.h"
27 #include "config.h"
28 #include "actions.h"
29 #include "screen.h"
30 #include "menuframe.h"
31 #include "keyboard.h"
32 #include "geom.h"
33 #include "misc.h"
34 #include "client_menu.h"
35 #include "client_list_menu.h"
36 #include "client_list_combined_menu.h"
37 #include "gettext.h"
38 #include "parser/parse.h"
39
40 typedef struct _ObMenuParseState ObMenuParseState;
41
42 struct _ObMenuParseState
43 {
44     ObMenu *parent;
45     ObMenu *pipe_creator;
46 };
47
48 static GHashTable *menu_hash = NULL;
49 static ObParseInst *menu_parse_inst;
50 static ObMenuParseState menu_parse_state;
51 static gboolean menu_can_hide = FALSE;
52
53 static void menu_destroy_hash_value(ObMenu *self);
54 static void parse_menu_item(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node,
55                             gpointer data);
56 static void parse_menu_separator(ObParseInst *i,
57                                  xmlDocPtr doc, xmlNodePtr node,
58                                  gpointer data);
59 static void parse_menu(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node,
60                        gpointer data);
61 static gunichar parse_shortcut(const gchar *label, gboolean allow_shortcut,
62                                gchar **strippedlabel, guint *position,
63                                gboolean *always_show);
64
65
66 static void client_dest(ObClient *client, gpointer data)
67 {
68     /* menus can be associated with a client, so close any that are since
69        we are disappearing now */
70     menu_frame_hide_all_client(client);
71 }
72
73 void menu_startup(gboolean reconfig)
74 {
75     xmlDocPtr doc;
76     xmlNodePtr node;
77     gboolean loaded = FALSE;
78     GSList *it;
79
80     menu_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
81                                       (GDestroyNotify)menu_destroy_hash_value);
82
83     client_list_menu_startup(reconfig);
84     client_list_combined_menu_startup(reconfig);
85     client_menu_startup();
86
87     menu_parse_inst = parse_startup();
88
89     menu_parse_state.parent = NULL;
90     menu_parse_state.pipe_creator = NULL;
91     parse_register(menu_parse_inst, "menu", parse_menu, &menu_parse_state);
92     parse_register(menu_parse_inst, "item", parse_menu_item,
93                    &menu_parse_state);
94     parse_register(menu_parse_inst, "separator",
95                    parse_menu_separator, &menu_parse_state);
96
97     for (it = config_menu_files; it; it = g_slist_next(it)) {
98         if (parse_load_menu(it->data, &doc, &node)) {
99             loaded = TRUE;
100             parse_tree(menu_parse_inst, doc, node->children);
101             xmlFreeDoc(doc);
102         } else
103             g_message(_("Unable to find a valid menu file '%s'"),
104                       (const gchar*)it->data);
105     }
106     if (!loaded) {
107         if (parse_load_menu("menu.xml", &doc, &node)) {
108             parse_tree(menu_parse_inst, doc, node->children);
109             xmlFreeDoc(doc);
110         } else
111             g_message(_("Unable to find a valid menu file '%s'"),
112                       "menu.xml");
113     }
114
115     g_assert(menu_parse_state.parent == NULL);
116
117     if (!reconfig)
118         client_add_destroy_notify(client_dest, NULL);
119 }
120
121 void menu_shutdown(gboolean reconfig)
122 {
123     if (!reconfig)
124         client_remove_destroy_notify(client_dest);
125
126     parse_shutdown(menu_parse_inst);
127     menu_parse_inst = NULL;
128
129     client_list_menu_shutdown(reconfig);
130     client_list_combined_menu_shutdown(reconfig);
131
132     menu_frame_hide_all();
133     g_hash_table_destroy(menu_hash);
134     menu_hash = NULL;
135 }
136
137 static gboolean menu_pipe_submenu(gpointer key, gpointer val, gpointer data)
138 {
139     ObMenu *menu = val;
140     return menu->pipe_creator != NULL;
141 }
142
143 static void clear_cache(gpointer key, gpointer val, gpointer data)
144 {
145     ObMenu *menu = val;
146     if (menu->execute)
147         menu_clear_entries(menu);
148 }
149
150 void menu_clear_pipe_caches(void)
151 {
152     /* delete any pipe menus' submenus */
153     g_hash_table_foreach_remove(menu_hash, menu_pipe_submenu, NULL);
154     /* empty the top level pipe menus */
155     g_hash_table_foreach(menu_hash, clear_cache, NULL);
156 }
157
158 void menu_pipe_execute(ObMenu *self)
159 {
160     xmlDocPtr doc;
161     xmlNodePtr node;
162     gchar *output;
163     GError *err = NULL;
164
165     if (!self->execute)
166         return;
167     if (self->entries) /* the entries are already created and cached */
168         return;
169
170     if (!g_spawn_command_line_sync(self->execute, &output, NULL, NULL, &err)) {
171         g_message(_("Failed to execute command for pipe-menu '%s': %s"),
172                   self->execute, err->message);
173         g_error_free(err);
174         return;
175     }
176
177     if (parse_load_mem(output, strlen(output),
178                        "openbox_pipe_menu", &doc, &node))
179     {
180         menu_parse_state.pipe_creator = self;
181         menu_parse_state.parent = self;
182         parse_tree(menu_parse_inst, doc, node->children);
183         xmlFreeDoc(doc);
184     } else {
185         g_message(_("Invalid output from pipe-menu '%s'"), self->execute);
186     }
187
188     g_free(output);
189 }
190
191 static ObMenu* menu_from_name(gchar *name)
192 {
193     ObMenu *self = NULL;
194
195     g_assert(name != NULL);
196
197     if (!(self = g_hash_table_lookup(menu_hash, name)))
198         g_message(_("Attempted to access menu '%s' but it does not exist"),
199                   name);
200     return self;
201 }
202
203 #define VALID_SHORTCUT(c) (((c) >= '0' && (c) <= '9') || \
204                            ((c) >= 'A' && (c) <= 'Z') || \
205                            ((c) >= 'a' && (c) <= 'z'))
206
207 static gunichar parse_shortcut(const gchar *label, gboolean allow_shortcut,
208                                gchar **strippedlabel, guint *position,
209                                gboolean *always_show)
210 {
211     gunichar shortcut = 0;
212
213     *position = 0;
214     *always_show = FALSE;
215
216     g_assert(strippedlabel != NULL);
217
218     if (label == NULL) {
219         *strippedlabel = NULL;
220     } else {
221         gchar *i;
222
223         *strippedlabel = g_strdup(label);
224
225         /* if allow_shortcut is false, then you can't use the '_', instead you
226            have to just use the first valid character
227         */
228
229         i = strchr(*strippedlabel, '_');
230         if (allow_shortcut && i != NULL) {
231             /* there is an underscore in the string */
232
233             /* you have to use a printable ascii character for shortcuts
234                don't allow space either, so you can have like "a _ b"
235             */
236             if (VALID_SHORTCUT(*(i+1))) {
237                 shortcut = g_unichar_tolower(g_utf8_get_char(i+1));
238                 *position = i - *strippedlabel;
239                 *always_show = TRUE;
240
241                 /* remove the '_' from the string */
242                 for (; *i != '\0'; ++i)
243                     *i = *(i+1);
244             } else if (*(i+1) == '\0') {
245                 /* no default shortcut if the '_' is the last character
246                    (eg. "Exit_") for menu entries that you don't want
247                    to be executed by mistake
248                 */
249                     *i = '\0';
250             }
251         } else {
252             /* there is no underscore, so find the first valid character to use
253                instead */
254
255             for (i = *strippedlabel; *i != '\0'; ++i)
256                 if (VALID_SHORTCUT(*i)) {
257                     *position = i - *strippedlabel;
258                     shortcut = g_unichar_tolower(g_utf8_get_char(i));
259                     break;
260                 }
261         }
262     }
263     return shortcut;
264 }
265
266 static void parse_menu_item(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node,
267                             gpointer data)
268 {
269     ObMenuParseState *state = data;
270     gchar *label;
271
272     if (state->parent) {
273         if (parse_attr_string("label", node, &label)) {
274             GSList *acts = NULL;
275
276             for (node = node->children; node; node = node->next)
277                 if (!xmlStrcasecmp(node->name, (const xmlChar*) "action")) {
278                     ObActionsAct *a = actions_parse(i, doc, node);
279                     if (a)
280                         acts = g_slist_append(acts, a);
281                 }
282             menu_add_normal(state->parent, -1, label, acts, TRUE);
283             g_free(label);
284         }
285     }
286 }
287
288 static void parse_menu_separator(ObParseInst *i,
289                                  xmlDocPtr doc, xmlNodePtr node,
290                                  gpointer data)
291 {
292     ObMenuParseState *state = data;
293
294     if (state->parent) {
295         gchar *label;
296
297         if (!parse_attr_string("label", node, &label))
298             label = NULL;
299
300         menu_add_separator(state->parent, -1, label);
301         g_free(label);
302     }
303 }
304
305 static void parse_menu(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node,
306                        gpointer data)
307 {
308     ObMenuParseState *state = data;
309     gchar *name = NULL, *title = NULL, *script = NULL;
310     ObMenu *menu;
311
312     if (!parse_attr_string("id", node, &name))
313         goto parse_menu_fail;
314
315     if (!g_hash_table_lookup(menu_hash, name)) {
316         if (!parse_attr_string("label", node, &title))
317             goto parse_menu_fail;
318
319         if ((menu = menu_new(name, title, TRUE, NULL))) {
320             menu->pipe_creator = state->pipe_creator;
321             if (parse_attr_string("execute", node, &script)) {
322                 menu->execute = parse_expand_tilde(script);
323             } else {
324                 ObMenu *old;
325
326                 old = state->parent;
327                 state->parent = menu;
328                 parse_tree(i, doc, node->children);
329                 state->parent = old;
330             }
331         }
332     }
333
334     if (state->parent)
335         menu_add_submenu(state->parent, -1, name);
336
337 parse_menu_fail:
338     g_free(name);
339     g_free(title);
340     g_free(script);
341 }
342
343 ObMenu* menu_new(const gchar *name, const gchar *title,
344                  gboolean allow_shortcut_selection, gpointer data)
345 {
346     ObMenu *self;
347
348     self = g_new0(ObMenu, 1);
349     self->name = g_strdup(name);
350     self->data = data;
351
352     self->shortcut = parse_shortcut(title, allow_shortcut_selection,
353                                     &self->title, &self->shortcut_position,
354                                     &self->shortcut_always_show);
355
356     g_hash_table_replace(menu_hash, self->name, self);
357
358     /* Each menu has a single more_menu.  When the menu spills past what
359        can fit on the screen, a new menu frame entry is created from this
360        more_menu, and a new menu frame for the submenu is created for this
361        menu, also pointing to the more_menu.
362
363        This can be done multiple times using the same more_menu.
364
365        more_menu->more_menu will always be NULL, since there is only 1 for
366        each menu. */
367     self->more_menu = g_new0(ObMenu, 1);
368     self->more_menu->name = _("More...");
369     self->more_menu->title = _("More...");
370     self->more_menu->data = data;
371     self->more_menu->shortcut = g_unichar_tolower(g_utf8_get_char("M"));
372
373     return self;
374 }
375
376 static void menu_destroy_hash_value(ObMenu *self)
377 {
378     /* make sure its not visible */
379     {
380         GList *it;
381         ObMenuFrame *f;
382
383         for (it = menu_frame_visible; it; it = g_list_next(it)) {
384             f = it->data;
385             if (f->menu == self)
386                 menu_frame_hide_all();
387         }
388     }
389
390     if (self->destroy_func)
391         self->destroy_func(self, self->data);
392
393     menu_clear_entries(self);
394     g_free(self->name);
395     g_free(self->title);
396     g_free(self->execute);
397     g_free(self->more_menu);
398
399     g_free(self);
400 }
401
402 void menu_free(ObMenu *menu)
403 {
404     if (menu)
405         g_hash_table_remove(menu_hash, menu->name);
406 }
407
408 static gboolean menu_hide_delay_func(gpointer data)
409 {
410     menu_can_hide = TRUE;
411     return FALSE; /* no repeat */
412 }
413
414 void menu_show(gchar *name, gint x, gint y, gboolean mouse, ObClient *client)
415 {
416     ObMenu *self;
417     ObMenuFrame *frame;
418
419     if (!(self = menu_from_name(name)) ||
420         grab_on_keyboard() || grab_on_pointer()) return;
421
422     /* if the requested menu is already the top visible menu, then don't
423        bother */
424     if (menu_frame_visible) {
425         frame = menu_frame_visible->data;
426         if (frame->menu == self)
427             return;
428     }
429
430     menu_frame_hide_all();
431
432     /* clear the pipe menus when showing a new menu */
433     menu_clear_pipe_caches();
434
435     frame = menu_frame_new(self, 0, client);
436     if (!menu_frame_show_topmenu(frame, x, y, mouse))
437         menu_frame_free(frame);
438     else {
439         if (!mouse) {
440             /* select the first entry if it's not a submenu and we opened
441              * the menu with the keyboard, and skip all headers */
442             GList *it = frame->entries;
443             while (it) {
444                 ObMenuEntryFrame *e = it->data;
445                 if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL) {
446                     menu_frame_select(frame, e, FALSE);
447                     break;
448                 } else if (e->entry->type == OB_MENU_ENTRY_TYPE_SEPARATOR)
449                     it = g_list_next(it);
450                 else
451                     break;
452             }
453         }
454
455         /* reset the hide timer */
456         if (!mouse)
457             menu_can_hide = TRUE;
458         else {
459             menu_can_hide = FALSE;
460             ob_main_loop_timeout_add(ob_main_loop,
461                                      config_menu_hide_delay * 1000,
462                                      menu_hide_delay_func,
463                                      NULL, g_direct_equal, NULL);
464         }
465     }
466 }
467
468 gboolean menu_hide_delay_reached(void)
469 {
470     return menu_can_hide;
471 }
472
473 static ObMenuEntry* menu_entry_new(ObMenu *menu, ObMenuEntryType type, gint id)
474 {
475     ObMenuEntry *self;
476
477     g_assert(menu);
478
479     self = g_new0(ObMenuEntry, 1);
480     self->ref = 1;
481     self->type = type;
482     self->menu = menu;
483     self->id = id;
484
485     switch (type) {
486     case OB_MENU_ENTRY_TYPE_NORMAL:
487         self->data.normal.enabled = TRUE;
488         break;
489     case OB_MENU_ENTRY_TYPE_SUBMENU:
490     case OB_MENU_ENTRY_TYPE_SEPARATOR:
491         break;
492     }
493
494     return self;
495 }
496
497 void menu_entry_ref(ObMenuEntry *self)
498 {
499     ++self->ref;
500 }
501
502 void menu_entry_unref(ObMenuEntry *self)
503 {
504     if (self && --self->ref == 0) {
505         switch (self->type) {
506         case OB_MENU_ENTRY_TYPE_NORMAL:
507             g_free(self->data.normal.label);
508             while (self->data.normal.actions) {
509                 actions_act_unref(self->data.normal.actions->data);
510                 self->data.normal.actions =
511                     g_slist_delete_link(self->data.normal.actions,
512                                         self->data.normal.actions);
513             }
514             break;
515         case OB_MENU_ENTRY_TYPE_SUBMENU:
516             g_free(self->data.submenu.name);
517             break;
518         case OB_MENU_ENTRY_TYPE_SEPARATOR:
519             g_free(self->data.separator.label);
520             break;
521         }
522
523         g_free(self);
524     }
525 }
526
527 void menu_clear_entries(ObMenu *self)
528 {
529 #ifdef DEBUG
530     /* assert that the menu isn't visible */
531     {
532         GList *it;
533         ObMenuFrame *f;
534
535         for (it = menu_frame_visible; it; it = g_list_next(it)) {
536             f = it->data;
537             g_assert(f->menu != self);
538         }
539     }
540 #endif
541
542     while (self->entries) {
543         menu_entry_unref(self->entries->data);
544         self->entries = g_list_delete_link(self->entries, self->entries);
545     }
546     self->more_menu->entries = self->entries; /* keep it in sync */
547 }
548
549 void menu_entry_remove(ObMenuEntry *self)
550 {
551     self->menu->entries = g_list_remove(self->menu->entries, self);
552     menu_entry_unref(self);
553 }
554
555 ObMenuEntry* menu_add_normal(ObMenu *self, gint id, const gchar *label,
556                              GSList *actions, gboolean allow_shortcut)
557 {
558     ObMenuEntry *e;
559
560     e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_NORMAL, id);
561     e->data.normal.actions = actions;
562
563     menu_entry_set_label(e, label, allow_shortcut);
564
565     self->entries = g_list_append(self->entries, e);
566     self->more_menu->entries = self->entries; /* keep it in sync */
567     return e;
568 }
569
570 ObMenuEntry* menu_get_more(ObMenu *self, guint show_from)
571 {
572     ObMenuEntry *e;
573     e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_SUBMENU, -1);
574     /* points to itself */
575     e->data.submenu.name = g_strdup(self->name);
576     e->data.submenu.submenu = self;
577     e->data.submenu.show_from = show_from;
578     return e;
579 }
580
581 ObMenuEntry* menu_add_submenu(ObMenu *self, gint id, const gchar *submenu)
582 {
583     ObMenuEntry *e;
584
585     e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_SUBMENU, id);
586     e->data.submenu.name = g_strdup(submenu);
587
588     self->entries = g_list_append(self->entries, e);
589     self->more_menu->entries = self->entries; /* keep it in sync */
590     return e;
591 }
592
593 ObMenuEntry* menu_add_separator(ObMenu *self, gint id, const gchar *label)
594 {
595     ObMenuEntry *e;
596
597     e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_SEPARATOR, id);
598
599     menu_entry_set_label(e, label, FALSE);
600
601     self->entries = g_list_append(self->entries, e);
602     self->more_menu->entries = self->entries; /* keep it in sync */
603     return e;
604 }
605
606 void menu_set_show_func(ObMenu *self, ObMenuShowFunc func)
607 {
608     self->show_func = func;
609 }
610
611 void menu_set_hide_func(ObMenu *self, ObMenuHideFunc func)
612 {
613     self->hide_func = func;
614 }
615
616 void menu_set_update_func(ObMenu *self, ObMenuUpdateFunc func)
617 {
618     self->update_func = func;
619 }
620
621 void menu_set_execute_func(ObMenu *self, ObMenuExecuteFunc func)
622 {
623     self->execute_func = func;
624     self->more_menu->execute_func = func; /* keep it in sync */
625 }
626
627 void menu_set_destroy_func(ObMenu *self, ObMenuDestroyFunc func)
628 {
629     self->destroy_func = func;
630 }
631
632 void menu_set_place_func(ObMenu *self, ObMenuPlaceFunc func)
633 {
634     self->place_func = func;
635 }
636
637 ObMenuEntry* menu_find_entry_id(ObMenu *self, gint id)
638 {
639     ObMenuEntry *ret = NULL;
640     GList *it;
641
642     for (it = self->entries; it; it = g_list_next(it)) {
643         ObMenuEntry *e = it->data;
644
645         if (e->id == id) {
646             ret = e;
647             break;
648         }
649     }
650     return ret;
651 }
652
653 void menu_find_submenus(ObMenu *self)
654 {
655     GList *it;
656
657     for (it = self->entries; it; it = g_list_next(it)) {
658         ObMenuEntry *e = it->data;
659
660         if (e->type == OB_MENU_ENTRY_TYPE_SUBMENU)
661             e->data.submenu.submenu = menu_from_name(e->data.submenu.name);
662     }
663 }
664
665 void menu_entry_set_label(ObMenuEntry *self, const gchar *label,
666                           gboolean allow_shortcut)
667 {
668     switch (self->type) {
669     case OB_MENU_ENTRY_TYPE_SEPARATOR:
670         g_free(self->data.separator.label);
671         self->data.separator.label = g_strdup(label);
672         break;
673     case OB_MENU_ENTRY_TYPE_NORMAL:
674         g_free(self->data.normal.label);
675         self->data.normal.shortcut =
676             parse_shortcut(label, allow_shortcut, &self->data.normal.label,
677                            &self->data.normal.shortcut_position,
678                            &self->data.normal.shortcut_always_show);
679         break;
680     default:
681         g_assert_not_reached();
682     }
683 }
684
685 void menu_show_all_shortcuts(ObMenu *self, gboolean show)
686 {
687     self->show_all_shortcuts = show;
688 }