unhilite the entry for the submenu when it is closed
[mikachu/openbox.git] / openbox / menu.c
1 #include "menu.h"
2 #include "openbox.h"
3 #include "stacking.h"
4 #include "client.h"
5 #include "grab.h"
6 #include "screen.h"
7 #include "geom.h"
8 #include "plugin.h"
9 #include "misc.h"
10
11 GHashTable *menu_hash = NULL;
12 GList *menu_visible = NULL;
13
14 #define FRAME_EVENTMASK (ButtonPressMask |ButtonMotionMask | EnterWindowMask |\
15                          LeaveWindowMask)
16 #define TITLE_EVENTMASK (ButtonPressMask | ButtonMotionMask)
17 #define ENTRY_EVENTMASK (EnterWindowMask | LeaveWindowMask | \
18                          ButtonPressMask | ButtonReleaseMask)
19
20 static void parse_menu(xmlDocPtr doc, xmlNodePtr node, void *data)
21 {
22     parse_menu_full(doc, node, data, TRUE);
23 }
24
25
26 void parse_menu_full(xmlDocPtr doc, xmlNodePtr node, void *data,
27                        gboolean newmenu)
28 {
29     Action *act;
30     xmlNodePtr nact;
31
32     gchar *id = NULL, *title = NULL, *label = NULL, *plugin;
33     ObMenu *menu = NULL, *parent;
34
35     if (newmenu == TRUE) {
36         if (!parse_attr_string("id", node, &id))
37             goto parse_menu_fail;
38         if (!parse_attr_string("label", node, &title))
39             goto parse_menu_fail;
40         g_message("menu label %s", title);
41
42         if (parse_attr_string("plugin", node, &plugin)) {
43             PluginMenuCreateData data;
44             data.doc = doc;
45             data.node = node;
46             data.parent = menu;
47             parent = plugin_create(plugin, &data);
48             g_free(plugin);
49         } else
50             menu = menu_new(title, id, data ? *((ObMenu**)data) : NULL);
51             
52         if (data)
53             *((ObMenu**)data) = menu;
54     } else {
55         menu = (ObMenu *)data;
56     }
57
58     node = node->xmlChildrenNode;
59     
60     while (node) {
61         if (!xmlStrcasecmp(node->name, (const xmlChar*) "menu")) {
62             if (parse_attr_string("plugin", node, &plugin)) {
63                 PluginMenuCreateData data;
64                 data.doc = doc;
65                 data.node = node;
66                 data.parent = menu;
67                 parent = plugin_create(plugin, &data);
68                 g_free(plugin);
69             } else {
70                 parent = menu;
71                 parse_menu(doc, node, &parent);
72                 menu_add_entry(menu, menu_entry_new_submenu(parent->label,
73                                                             parent));
74             }
75
76         }
77         else if (!xmlStrcasecmp(node->name, (const xmlChar*) "item")) {
78             if (parse_attr_string("label", node, &label)) {
79                 if ((nact = parse_find_node("action", node->xmlChildrenNode)))
80                     act = action_parse(doc, nact);
81                 else
82                     act = NULL;
83                 if (act)
84                     menu_add_entry(menu, menu_entry_new(label, act));
85                 else
86                     menu_add_entry(menu, menu_entry_new_separator(label));
87                 g_free(label);
88             }
89         }
90         node = node->next;
91     }
92
93 parse_menu_fail:
94     g_free(id);
95     g_free(title);
96 }
97
98 void menu_control_show(ObMenu *self, int x, int y, ObClient *client);
99
100 void menu_destroy_hash_key(ObMenu *menu)
101 {
102     g_free(menu);
103 }
104
105 void menu_destroy_hash_value(ObMenu *self)
106 {
107     GList *it;
108
109     for (it = self->entries; it; it = it->next)
110         menu_entry_free(it->data);
111     g_list_free(self->entries);
112
113     g_free(self->label);
114     g_free(self->name);
115
116     g_hash_table_remove(window_map, &self->title);
117     g_hash_table_remove(window_map, &self->frame);
118     g_hash_table_remove(window_map, &self->items);
119
120     stacking_remove(self);
121
122     RrAppearanceFree(self->a_title);
123     RrAppearanceFree(self->a_items);
124     XDestroyWindow(ob_display, self->title);
125     XDestroyWindow(ob_display, self->frame);
126     XDestroyWindow(ob_display, self->items);
127
128     g_free(self);
129 }
130
131 void menu_entry_free(ObMenuEntry *self)
132 {
133     g_free(self->label);
134     action_free(self->action);
135
136     g_hash_table_remove(window_map, &self->item);
137
138     RrAppearanceFree(self->a_item);
139     RrAppearanceFree(self->a_disabled);
140     RrAppearanceFree(self->a_hilite);
141     XDestroyWindow(ob_display, self->item);
142
143     g_free(self);
144 }
145     
146 void menu_startup()
147 {
148 /*
149     ObMenu *m;
150     ObMenu *s;
151     ObMenu *t;
152     Action *a;
153 */
154
155     menu_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
156                                       (GDestroyNotify)menu_destroy_hash_key,
157                                       (GDestroyNotify)menu_destroy_hash_value);
158
159     parse_register("menu", parse_menu, NULL);
160
161 /*
162     m = menu_new("sex menu", "root", NULL);
163  
164     a = action_from_string("execute");
165     a->data.execute.path = g_strdup("xterm");
166     menu_add_entry(m, menu_entry_new("xterm", a));
167     a = action_from_string("restart");
168     menu_add_entry(m, menu_entry_new("restart", a));
169     menu_add_entry(m, menu_entry_new_separator("--"));
170     a = action_from_string("exit");
171     menu_add_entry(m, menu_entry_new("exit", a));
172 */
173
174     /*
175     s = menu_new("subsex menu", "submenu", m);
176     a = action_from_string("execute");
177     a->data.execute.path = g_strdup("xclock");
178     menu_add_entry(s, menu_entry_new("xclock", a));
179
180     menu_add_entry(m, menu_entry_new_submenu("subz", s));
181
182     s = menu_new("empty", "chub", m);
183     menu_add_entry(m, menu_entry_new_submenu("empty", s));
184
185     s = menu_new("", "s-club", m);
186     menu_add_entry(m, menu_entry_new_submenu("empty", s));
187
188     s = menu_new(NULL, "h-club", m);
189     menu_add_entry(m, menu_entry_new_submenu("empty", s));
190
191     s = menu_new(NULL, "g-club", m);
192
193     a = action_from_string("execute");
194     a->data.execute.path = g_strdup("xterm");
195     menu_add_entry(s, menu_entry_new("xterm", a));
196     a = action_from_string("restart");
197     menu_add_entry(s, menu_entry_new("restart", a));
198     menu_add_entry(s, menu_entry_new_separator("--"));
199     a = action_from_string("exit");
200     menu_add_entry(s, menu_entry_new("exit", a));
201
202     menu_add_entry(m, menu_entry_new_submenu("long", s));
203     */
204 }
205
206 void menu_shutdown()
207 {
208     g_hash_table_destroy(menu_hash);
209 }
210
211 static Window createWindow(Window parent, unsigned long mask,
212                            XSetWindowAttributes *attrib)
213 {
214     return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
215                          RrDepth(ob_rr_inst), InputOutput,
216                          RrVisual(ob_rr_inst), mask, attrib);
217                        
218 }
219
220 ObMenu *menu_new_full(char *label, char *name, ObMenu *parent, 
221                     menu_controller_show show, menu_controller_update update)
222 {
223     XSetWindowAttributes attrib;
224     ObMenu *self;
225
226     self = g_new0(ObMenu, 1);
227     self->obwin.type = Window_Menu;
228     self->label = g_strdup(label);
229     self->name = g_strdup(name);
230     self->parent = parent;
231     self->open_submenu = NULL;
232
233     self->entries = NULL;
234     self->shown = FALSE;
235     self->invalid = TRUE;
236
237     /* default controllers */
238     self->show = show;
239     self->hide = NULL;
240     self->update = update;
241     self->mouseover = NULL;
242     self->selected = NULL;
243
244     self->plugin = NULL;
245     self->plugin_data = NULL;
246
247     attrib.override_redirect = TRUE;
248     attrib.event_mask = FRAME_EVENTMASK;
249     self->frame = createWindow(RootWindow(ob_display, ob_screen),
250                                CWOverrideRedirect|CWEventMask, &attrib);
251     attrib.event_mask = TITLE_EVENTMASK;
252     self->title = createWindow(self->frame, CWEventMask, &attrib);
253     self->items = createWindow(self->frame, 0, &attrib);
254
255     self->a_title = self->a_items = NULL;
256
257     XMapWindow(ob_display, self->title);
258     XMapWindow(ob_display, self->items);
259
260     g_hash_table_insert(window_map, &self->frame, self);
261     g_hash_table_insert(window_map, &self->title, self);
262     g_hash_table_insert(window_map, &self->items, self);
263     g_hash_table_insert(menu_hash, g_strdup(name), self);
264
265     stacking_add(MENU_AS_WINDOW(self));
266     stacking_raise(MENU_AS_WINDOW(self));
267
268     return self;
269 }
270
271 void menu_free(char *name)
272 {
273     g_hash_table_remove(menu_hash, name);
274 }
275
276 ObMenuEntry *menu_entry_new_full(char *label, Action *action,
277                                ObMenuEntryRenderType render_type,
278                                gpointer submenu)
279 {
280     ObMenuEntry *menu_entry = g_new0(ObMenuEntry, 1);
281
282     menu_entry->label = g_strdup(label);
283     menu_entry->render_type = render_type;
284     menu_entry->action = action;
285
286     menu_entry->hilite = FALSE;
287     menu_entry->enabled = TRUE;
288
289     menu_entry->submenu = submenu;
290
291     return menu_entry;
292 }
293
294 void menu_entry_set_submenu(ObMenuEntry *entry, ObMenu *submenu)
295 {
296     g_assert(entry != NULL);
297     
298     entry->submenu = submenu;
299
300     if(entry->parent != NULL)
301         entry->parent->invalid = TRUE;
302 }
303
304 void menu_add_entry(ObMenu *menu, ObMenuEntry *entry)
305 {
306     XSetWindowAttributes attrib;
307
308     g_assert(menu != NULL);
309     g_assert(entry != NULL);
310     g_assert(entry->item == None);
311
312     menu->entries = g_list_append(menu->entries, entry);
313     entry->parent = menu;
314
315     attrib.event_mask = ENTRY_EVENTMASK;
316     entry->item = createWindow(menu->items, CWEventMask, &attrib);
317     XMapWindow(ob_display, entry->item);
318
319     entry->a_item = entry->a_disabled = entry->a_hilite = NULL;
320
321     menu->invalid = TRUE;
322
323     g_hash_table_insert(window_map, &entry->item, menu);
324 }
325
326 void menu_show(char *name, int x, int y, ObClient *client)
327 {
328     ObMenu *self;
329   
330     self = g_hash_table_lookup(menu_hash, name);
331     if (!self) {
332         g_warning("Attempted to show menu '%s' but it does not exist.",
333                   name);
334         return;
335     }
336
337     menu_show_full(self, x, y, client);
338 }  
339
340 void menu_show_full(ObMenu *self, int x, int y, ObClient *client)
341 {
342     g_assert(self != NULL);
343        
344     menu_render(self);
345     
346     self->client = client;
347
348     if (!self->shown) {
349         if (!(self->parent && self->parent->shown)) {
350             grab_pointer(TRUE, None);
351             grab_keyboard(TRUE);
352         }
353         menu_visible = g_list_append(menu_visible, self);
354     }
355
356     if (self->show) {
357         self->show(self, x, y, client);
358     } else {
359       menu_control_show(self, x, y, client);
360     }
361 }
362
363 void menu_hide(ObMenu *self) {
364     if (self->shown) {
365         XUnmapWindow(ob_display, self->frame);
366         self->shown = FALSE;
367         if (self->open_submenu)
368             menu_hide(self->open_submenu);
369         if (self->parent && self->parent->open_submenu == self) {
370             ObMenuEntry *e;
371
372             self->parent->open_submenu = NULL;
373
374             e = menu_find_entry_by_submenu(self->parent, self);
375             if (self->parent->mouseover)
376                 self->parent->mouseover(e, FALSE);
377             else
378                 menu_control_mouseover(e, FALSE);
379             menu_entry_render(e);
380         }
381
382         if (!(self->parent && self->parent->shown)) {
383             grab_keyboard(FALSE);
384             grab_pointer(FALSE, None);
385         }
386         menu_visible = g_list_remove(menu_visible, self);
387     }
388 }
389
390 void menu_clear(ObMenu *self) {
391     GList *it;
392   
393     for (it = self->entries; it; it = it->next) {
394         ObMenuEntry *entry = it->data;
395         menu_entry_free(entry);
396     }
397     self->entries = NULL;
398     self->invalid = TRUE;
399 }
400
401
402 ObMenuEntry *menu_find_entry(ObMenu *menu, Window win)
403 {
404     GList *it;
405
406     for (it = menu->entries; it; it = it->next) {
407         ObMenuEntry *entry = it->data;
408         if (entry->item == win)
409             return entry;
410     }
411     return NULL;
412 }
413
414 ObMenuEntry *menu_find_entry_by_submenu(ObMenu *menu, ObMenu *submenu)
415 {
416     GList *it;
417
418     for (it = menu->entries; it; it = it->next) {
419         ObMenuEntry *entry = it->data;
420         if (entry->submenu == submenu)
421             return entry;
422     }
423     return NULL;
424 }
425
426 ObMenuEntry *menu_find_entry_by_pos(ObMenu *menu, int x, int y)
427 {
428     if (x < 0 || x >= menu->size.width || y < 0 || y >= menu->size.height)
429         return NULL;
430
431     y -= menu->title_h + ob_rr_theme->bwidth;
432     if (y < 0) return NULL;
433     
434     g_message ("%d %p", y/menu->item_h, g_list_nth_data(menu->entries, y / menu->item_h));
435     return g_list_nth_data(menu->entries, y / menu->item_h);
436 }
437
438 void menu_entry_fire(ObMenuEntry *self)
439 {
440     ObMenu *m;
441
442     if (self->action) {
443         self->action->data.any.c = self->parent->client;
444         self->action->func(&self->action->data);
445
446         /* hide the whole thing */
447         m = self->parent;
448         while (m->parent) m = m->parent;
449         menu_hide(m);
450     }
451 }
452
453 /* 
454    Default menu controller action for showing.
455 */
456
457 void menu_control_show(ObMenu *self, int x, int y, ObClient *client)
458 {
459     guint i;
460     Rect *a = NULL;
461
462     g_assert(!self->invalid);
463     
464     for (i = 0; i < screen_num_monitors; ++i) {
465         a = screen_physical_area_monitor(i);
466         if (RECT_CONTAINS(*a, x, y))
467             break;
468     }
469     g_assert(a != NULL);
470     self->xin_area = i;
471
472     POINT_SET(self->location,
473               MIN(x, a->x + a->width - 1 - self->size.width), 
474               MIN(y, a->y + a->height - 1 - self->size.height));
475     XMoveWindow(ob_display, self->frame, self->location.x, self->location.y);
476
477     if (!self->shown) {
478         XMapWindow(ob_display, self->frame);
479         stacking_raise(MENU_AS_WINDOW(self));
480         self->shown = TRUE;
481     } else if (self->shown && self->open_submenu) {
482         menu_hide(self->open_submenu);
483     }
484 }
485
486 void menu_control_mouseover(ObMenuEntry *self, gboolean enter)
487 {
488     int x;
489     Rect *a;
490     ObMenuEntry *e;
491
492     if (enter) {
493         if (self->parent->open_submenu && self->submenu 
494             != self->parent->open_submenu)
495         {
496             e = menu_find_entry_by_submenu(self->parent,
497                                            self->parent->open_submenu);
498             e->hilite = FALSE;
499             menu_entry_render(e);
500             menu_hide(self->parent->open_submenu);
501         }
502         
503         if (self->submenu && self->parent->open_submenu != self->submenu) {
504             self->parent->open_submenu = self->submenu;
505
506             /* shouldn't be invalid since it must be displayed */
507             g_assert(!self->parent->invalid);
508             /* TODO: I don't understand why these bevels should be here.
509                Something must be wrong in the width calculation */
510             x = self->parent->location.x + self->parent->size.width + 
511                 ob_rr_theme->bwidth - ob_rr_theme->menu_overlap;
512
513             /* need to get the width. is this bad?*/
514             menu_render(self->submenu);
515
516             a = screen_physical_area_monitor(self->parent->xin_area);
517
518             if (self->submenu->size.width + x >= a->x + a->width)
519                 x = self->parent->location.x - self->submenu->size.width - 
520                     ob_rr_theme->bwidth + ob_rr_theme->menu_overlap;
521             
522             menu_show_full(self->submenu, x,
523                            self->parent->location.y + self->y,
524                            self->parent->client);
525         } 
526     }
527
528     if (enter || !self->submenu ||
529         menu_find_entry_by_submenu(self->parent,
530                                    self->parent->open_submenu) != self)
531         self->hilite = enter;
532 }
533
534 ObMenuEntry *menu_control_keyboard_nav(ObMenuEntry *over, ObKey key)
535 {
536     GList *it = NULL;
537         
538     switch (key) {
539     case OB_KEY_DOWN: {
540         if (over != NULL) {
541             if (over->parent->mouseover)
542                 over->parent->mouseover(over, FALSE);
543             else
544                 menu_control_mouseover(over, FALSE);
545             menu_entry_render(over);
546                 
547             it = over->parent->entries;
548             while (it != NULL && it->data != over)
549                 it = it->next;
550         }
551             
552         if (it && it->next)
553             over = (ObMenuEntry *)it->next->data;
554         else if (over == NULL) {
555             if (menu_visible && ((ObMenu *)menu_visible->data)->entries)
556                 over = (ObMenuEntry *)
557                     (((ObMenu *)menu_visible->data)->entries)->data;
558             else
559                 over = NULL;
560         } else {
561             over = (over->parent->entries != NULL ?
562                     over->parent->entries->data : NULL);
563         }
564
565         if (over) {
566             if (over->parent->mouseover)
567                 over->parent->mouseover(over, TRUE);
568             else
569                 menu_control_mouseover(over, TRUE);
570             menu_entry_render(over);
571         }
572         
573         break;
574     }
575     case OB_KEY_UP: {
576         if (over != NULL) {
577             if (over->parent->mouseover)
578                 over->parent->mouseover(over, FALSE);
579             else
580                 menu_control_mouseover(over, FALSE);
581             menu_entry_render(over);
582                 
583             it = g_list_last(over->parent->entries);
584             while (it != NULL && it->data != over)
585                 it = it->prev;
586         } 
587             
588         if (it && it->prev)
589             over = (ObMenuEntry *)it->prev->data;
590         else if (over == NULL) {
591             it = g_list_last(menu_visible);
592             if (it != NULL) {
593                 it = g_list_last(((ObMenu *)it->data)->entries);
594                 over = (ObMenuEntry *)(it != NULL ? it->data : NULL);
595             }
596         } else
597             over = (over->parent->entries != NULL ?
598                     g_list_last(over->parent->entries)->data :
599                     NULL);
600
601         if (over->parent->mouseover)
602             over->parent->mouseover(over, TRUE);
603         else
604             menu_control_mouseover(over, TRUE);
605         menu_entry_render(over);
606         break;
607     }
608     case OB_KEY_RETURN: {
609         if (over == NULL)
610             return over;
611
612         if (over->submenu) {
613             if (over->parent->mouseover)
614                 over->parent->mouseover(over, FALSE);
615             else
616                 menu_control_mouseover(over, FALSE);
617             menu_entry_render(over);
618
619             if (over->submenu->entries)
620                 over = over->submenu->entries->data;
621
622             if (over->parent->mouseover)
623                 over->parent->mouseover(over, TRUE);
624             else
625                 menu_control_mouseover(over, TRUE);
626             menu_entry_render(over);
627         }
628         else {
629             if (over->parent->mouseover)
630                 over->parent->mouseover(over, FALSE);
631             else
632                 menu_control_mouseover(over, FALSE);
633             menu_entry_render(over);
634
635             menu_entry_fire(over);
636         }
637         break;
638     }
639     case OB_KEY_ESCAPE: {
640         if (over != NULL) {
641             if (over->parent->mouseover)
642                 over->parent->mouseover(over, FALSE);
643             else
644                 menu_control_mouseover(over, FALSE);
645             menu_entry_render(over);
646
647             menu_hide(over->parent);
648         } else {
649             it  = g_list_last(menu_visible);
650             if (it) {
651                 menu_hide((ObMenu *)it->data);
652             }
653         }
654         
655         over = NULL;
656         break;
657     }
658     default:
659         g_error("Unknown key");
660     }
661
662     return over;
663 }