[ViewVC] Diff of: cvs/rxvt-unicode/src/menubar.C

Comparing rxvt-unicode/src/menubar.C (file contents):
Revision 1.5 by pcg, Sat Jan 31 03:27:45 2004 UTC vs.
Revision 1.6 by pcg, Sun Feb 1 01:34:41 2004 UTC

…		…
30	#include "menubar.intpro" /* PROTOS for internal routines */	30	#include "menubar.intpro" /* PROTOS for internal routines */
31		31
32	#define Menu_PixelWidth(menu) \	32	#define Menu_PixelWidth(menu) \
33	(2 * SHADOW + Width2Pixel ((menu)->width + 3 * HSPACE))	33	(2 * SHADOW + Width2Pixel ((menu)->width + 3 * HSPACE))
34		34
35	static const struct {	35	static const struct
		36	{
36	const char name; /* (l)eft, (u)p, (d)own, (r)ight */	37	const char name; /* (l)eft, (u)p, (d)own, (r)ight */
37	const unsigned char str[5]; /* str[0] = STRLEN (str+1) */	38	const unsigned char str[5]; /* str[0] = STRLEN (str+1) */
		39	}
38	} Arrows[NARROWS] = {	40	Arrows[NARROWS] = {
39	{ 'l', "\003\033[D" },	41	{ 'l', "\003\033[D" },
40	{ 'u', "\003\033[A" },	42	{ 'u', "\003\033[A" },
41	{ 'd', "\003\033[B" },	43	{ 'd', "\003\033[B" },
42	{ 'r', "\003\033[C" }	44	{ 'r', "\003\033[C" }
43	};	45	};
44		46
45	/}}} /	47	/}}} /
46		48
47	/*	49	/*
48	* find an item called NAME in MENU	50	* find an item called NAME in MENU
49	*/	51	*/
50	menuitem_t *	52	menuitem_t *
51	rxvt_menuitem_find(const menu_t menu, const char name)	53	rxvt_menuitem_find(const menu_t menu, const char name)
52	{	54	{
53	menuitem_t *item;	55	menuitem_t *item;
54		56
55	#ifdef DEBUG_STRICT	57	#ifdef DEBUG_STRICT
56	assert(name != NULL);	58	assert(name != NULL);
57	assert(menu != NULL);	59	assert(menu != NULL);
58	#endif	60	#endif
59		61
60	/* find the last item in the menu, this is good for separators */	62	/* find the last item in the menu, this is good for separators */
61	for (item = menu->tail; item != NULL; item = item->prev) {	63	for (item = menu->tail; item != NULL; item = item->prev)
		64	{
62	if (item->entry.type == MenuSubMenu) {	65	if (item->entry.type == MenuSubMenu)
		66	{
63	if (!STRCMP(name, (item->entry.submenu.menu)->name))	67	if (!STRCMP(name, (item->entry.submenu.menu)->name))
64	break;	68	break;
		69	}
65	} else if ((isSeparator(name) && isSeparator(item->name))	70	else if ((isSeparator(name) && isSeparator(item->name))
66	\|\| !STRCMP(name, item->name))	71	\|\| !STRCMP(name, item->name))
67	break;	72	break;
68	}	73	}
69	return item;	74	return item;
70	}	75	}
71		76
72	/*	77	/*
73	* unlink ITEM from its MENU and free its memory	78	* unlink ITEM from its MENU and free its memory
74	*/	79	*/
75	void	80	void
76	rxvt_term::menuitem_free (menu_t menu, menuitem_t item)	81	rxvt_term::menuitem_free (menu_t menu, menuitem_t item)
77	{	82	{
78	/* disconnect */	83	/* disconnect */
79	menuitem_t prev, next;	84	menuitem_t prev, next;
80		85
81	#ifdef DEBUG_STRICT	86	#ifdef DEBUG_STRICT
82	assert(menu != NULL);	87	assert(menu != NULL);
83	#endif	88	#endif
84		89
85	prev = item->prev;	90	prev = item->prev;
86	next = item->next;	91	next = item->next;
87	if (prev != NULL)	92	if (prev != NULL)
88	prev->next = next;	93	prev->next = next;
89	if (next != NULL)	94	if (next != NULL)
90	next->prev = prev;	95	next->prev = prev;
91		96
92	/* new head, tail */	97	/* new head, tail */
93	if (menu->tail == item)	98	if (menu->tail == item)
94	menu->tail = prev;	99	menu->tail = prev;
95	if (menu->head == item)	100	if (menu->head == item)
96	menu->head = next;	101	menu->head = next;
97		102
98	switch (item->entry.type) {	103	switch (item->entry.type)
		104	{
99	case MenuAction:	105	case MenuAction:
100	case MenuTerminalAction:	106	case MenuTerminalAction:
101	free(item->entry.action.str);	107	free(item->entry.action.str);
102	break;	108	break;
103	case MenuSubMenu:	109	case MenuSubMenu:
104	menu_delete (item->entry.submenu.menu);	110	menu_delete (item->entry.submenu.menu);
105	break;	111	break;
106	}	112	}
107	if (item->name != NULL)	113	if (item->name != NULL)
108	free(item->name);	114	free(item->name);
109	if (item->name2 != NULL)	115	if (item->name2 != NULL)
110	free(item->name2);	116	free(item->name2);
111	free(item);	117	free(item);
112	}	118	}
113		119
114	/*	120	/*
115	* sort command vs. terminal actions and	121	* sort command vs. terminal actions and
116	* remove the first character of STR if it's '\0'	122	* remove the first character of STR if it's '\0'
117	*/	123	*/
118	int	124	int
119	rxvt_action_type(action_t action, unsigned char str)	125	rxvt_action_type(action_t action, unsigned char str)
120	{	126	{
121	unsigned int len;	127	unsigned int len;
122		128
123	#if defined (DEBUG_MENU) \|\| defined (DEBUG_MENUARROWS)	129	#if defined (DEBUG_MENU) \|\| defined (DEBUG_MENUARROWS)
124	len = STRLEN(str);	130	len = STRLEN(str);
125	fprintf(stderr, "(len %d) = %s\n", len, str);	131	fprintf(stderr, "(len %d) = %s\n", len, str);
126	#else	132	#else
127	len = rxvt_Str_escaped((char *)str);	133	len = rxvt_Str_escaped((char *)str);
128	#endif	134	#endif
129		135
130	if (!len)	136	if (!len)
131	return -1;	137	return -1;
132		138
133	/* sort command vs. terminal actions */	139	/* sort command vs. terminal actions */
134	action->type = MenuAction;	140	action->type = MenuAction;
135	if (str[0] == '\0') {	141	if (str[0] == '\0')
		142	{
136	/* the functional equivalent: memmove (str, str+1, len); */	143	/* the functional equivalent: memmove (str, str+1, len); */
137	unsigned char *dst = (str);	144	unsigned char *dst = (str);
138	unsigned char *src = (str + 1);	145	unsigned char *src = (str + 1);
139	unsigned char *end = (str + len);	146	unsigned char *end = (str + len);
140		147
141	while (src <= end)	148	while (src <= end)
142	dst++ = src++;	149	dst++ = src++;
143		150
144	len--; /* decrement length */	151	len--; /* decrement length */
145	if (str[0] != '\0')	152	if (str[0] != '\0')
146	action->type = MenuTerminalAction;	153	action->type = MenuTerminalAction;
147	}	154	}
148	action->str = str;	155	action->str = str;
149	action->len = len;	156	action->len = len;
150		157
151	return 0;	158	return 0;
152	}	159	}
153		160
154	int	161	int
155	rxvt_term::action_dispatch (action_t *action)	162	rxvt_term::action_dispatch (action_t *action)
156	{	163	{
157	switch (action->type) {	164	switch (action->type)
		165	{
158	case MenuTerminalAction:	166	case MenuTerminalAction:
159	cmd_write (action->str, action->len);	167	cmd_write (action->str, action->len);
160	break;	168	break;
161		169
162	case MenuAction:	170	case MenuAction:
163	tt_write (action->str, action->len);	171	tt_write (action->str, action->len);
164	break;	172	break;
165		173
166	default:	174	default:
167	return -1;	175	return -1;
168	break;	176	break;
169	}	177	}
170	return 0;	178	return 0;
171	}	179	}
172		180
173	/* return the arrow index corresponding to NAME */	181	/* return the arrow index corresponding to NAME */
174	int	182	int
175	rxvt_menuarrow_find(char name)	183	rxvt_menuarrow_find(char name)
176	{	184	{
177	int i;	185	int i;
178		186
179	for (i = 0; i < NARROWS; i++)	187	for (i = 0; i < NARROWS; i++)
180	if (name == Arrows[i].name)	188	if (name == Arrows[i].name)
181	return i;	189	return i;
182	return -1;	190	return -1;
183	}	191	}
184		192
185	/* free the memory associated with arrow NAME of the current menubar */	193	/* free the memory associated with arrow NAME of the current menubar */
186	void	194	void
187	rxvt_term::menuarrow_free (char name)	195	rxvt_term::menuarrow_free (char name)
188	{	196	{
189	int i;	197	int i;
190		198
191	if (name) {	199	if (name)
		200	{
192	i = rxvt_menuarrow_find(name);	201	i = rxvt_menuarrow_find(name);
193	if (i >= 0) {	202	if (i >= 0)
		203	{
194	action_t *act = &(CurrentBar->arrows[i]);	204	action_t *act = &(CurrentBar->arrows[i]);
195		205
196	switch (act->type) {	206	switch (act->type)
		207	{
197	case MenuAction:	208	case MenuAction:
198	case MenuTerminalAction:	209	case MenuTerminalAction:
199	free(act->str);	210	free(act->str);
200	act->str = NULL;	211	act->str = NULL;
201	act->len = 0;	212	act->len = 0;
202	break;	213	break;
		214	}
		215	act->type = MenuLabel;
		216	}
203	}	217	}
204	act->type = MenuLabel;	218	else
205	}	219	{
206	} else {
207	for (i = 0; i < NARROWS; i++)	220	for (i = 0; i < NARROWS; i++)
208	menuarrow_free (Arrows[i].name);	221	menuarrow_free (Arrows[i].name);
209	}	222	}
210	}	223	}
211		224
212	void	225	void
213	rxvt_term::menuarrow_add (char *string)	226	rxvt_term::menuarrow_add (char *string)
214	{	227	{
215	int i;	228	int i;
216	unsigned xtra_len;	229	unsigned xtra_len;
217	char *p;	230	char *p;
218	struct {	231	struct
		232	{
219	char *str;	233	char *str;
220	int len;	234	int len;
221	}	235	}
222	beg = { NULL, 0 },	236	beg = { NULL, 0 },
223	end = { NULL, 0 },	237	end = { NULL, 0 },
224	*cur,	238	*cur,
225	parse[NARROWS];	239	parse[NARROWS];
226		240
227	MEMSET(parse, 0, sizeof(parse));	241	MEMSET(parse, 0, sizeof(parse));
228		242
229	/* fprintf(stderr, "add arrows = `%s'\n", string); */	243	/* fprintf(stderr, "add arrows = `%s'\n", string); */
230	for (p = string; p != NULL && *p; string = p) {	244	for (p = string; p != NULL && *p; string = p)
		245	{
231	p = (string + 3);	246	p = (string + 3);
232	/* fprintf(stderr, "parsing at %s\n", string); */	247	/* fprintf(stderr, "parsing at %s\n", string); */
233	switch (string[1]) {	248	switch (string[1])
234	case 'b':	249	{
		250	case 'b':
235	cur = &beg;	251	cur = &beg;
236	break;	252	break;
237	case 'e':	253	case 'e':
238	cur = &end;	254	cur = &end;
239	break;	255	break;
240		256
241	default:	257	default:
242	i = rxvt_menuarrow_find(string[1]);	258	i = rxvt_menuarrow_find(string[1]);
243	if (i >= 0)	259	if (i >= 0)
244	cur = &(parse[i]);	260	cur = &(parse[i]);
245	else	261	else
246	continue; /* not found */	262	continue; /* not found */
247	break;	263	break;
248	}	264	}
249		265
250	string = p;	266	string = p;
251	cur->str = string;	267	cur->str = string;
252	cur->len = 0;	268	cur->len = 0;
253		269
254	if (cur == &end) {	270	if (cur == &end)
		271	{
255	p = STRCHR(string, '\0');	272	p = STRCHR(string, '\0');
256	} else {	273	}
		274	else
		275	{
257	char *next = string;	276	char *next = string;
258		277
259	while (1) {	278	while (1)
260	p = STRCHR(next, '<');	279	{
261	if (p != NULL) {	280	p = STRCHR(next, '<');
		281	if (p != NULL)
		282	{
262	if (p[1] && p[2] == '>')	283	if (p[1] && p[2] == '>')
263	break;	284	break;
264	/* parsed */	285	/* parsed */
265	} else {	286	}
		287	else
		288	{
266	if (beg.str == NULL) /* no end needed */	289	if (beg.str == NULL) /* no end needed */
267	p = STRCHR(next, '\0');	290	p = STRCHR(next, '\0');
268	break;	291	break;
269	}	292	}
270	next = (p + 1);	293	next = (p + 1);
271	}	294	}
272	}	295	}
273		296
274	if (p == NULL)	297	if (p == NULL)
275	return;	298	return;
276	cur->len = (p - string);	299	cur->len = (p - string);
277	}	300	}
278		301
279	#ifdef DEBUG_MENUARROWS	302	#ifdef DEBUG_MENUARROWS
280	cur = &beg;	303	cur = &beg;
281	fprintf(stderr, "<b>(len %d) = %.*s\n",	304	fprintf(stderr, "<b>(len %d) = %.*s\n",
282	cur->len, cur->len, (cur->str ? cur->str : ""));	305	cur->len, cur->len, (cur->str ? cur->str : ""));
283	for (i = 0; i < NARROWS; i++) {	306	for (i = 0; i < NARROWS; i++)
		307	{
284	cur = &(parse[i]);	308	cur = &(parse[i]);
285	fprintf(stderr, "<%c>(len %d) = %.*s\n",	309	fprintf(stderr, "<%c>(len %d) = %.*s\n",
286	Arrows[i].name,	310	Arrows[i].name,
287	cur->len, cur->len, (cur->str ? cur->str : ""));	311	cur->len, cur->len, (cur->str ? cur->str : ""));
288	}	312	}
289	cur = &end;	313	cur = &end;
290	fprintf(stderr, "<e>(len %d) = %.*s\n",	314	fprintf(stderr, "<e>(len %d) = %.*s\n",
291	cur->len, cur->len, (cur->str ? cur->str : ""));	315	cur->len, cur->len, (cur->str ? cur->str : ""));
292	#endif	316	#endif
293		317
294	xtra_len = (beg.len + end.len);	318	xtra_len = (beg.len + end.len);
295	for (i = 0; i < NARROWS; i++) {	319	for (i = 0; i < NARROWS; i++)
		320	{
296	if (xtra_len \|\| parse[i].len)	321	if (xtra_len \|\| parse[i].len)
297	menuarrow_free (Arrows[i].name);	322	menuarrow_free (Arrows[i].name);
298	}	323	}
299		324
300	for (i = 0; i < NARROWS; i++) {	325	for (i = 0; i < NARROWS; i++)
		326	{
301	unsigned char *str;	327	unsigned char *str;
302	unsigned int len;	328	unsigned int len;
303		329
304	if (!parse[i].len)	330	if (!parse[i].len)
305	continue;	331	continue;
306		332
307	str = rxvt_malloc(parse[i].len + xtra_len + 1);	333	str = rxvt_malloc(parse[i].len + xtra_len + 1);
308		334
309	len = 0;	335	len = 0;
310	if (beg.len) {	336	if (beg.len)
		337	{
311	STRNCPY(str + len, beg.str, beg.len);	338	STRNCPY(str + len, beg.str, beg.len);
312	len += beg.len;	339	len += beg.len;
313	}	340	}
314	STRNCPY(str + len, parse[i].str, parse[i].len);	341	STRNCPY(str + len, parse[i].str, parse[i].len);
315	len += parse[i].len;	342	len += parse[i].len;
316		343
317	if (end.len) {	344	if (end.len)
		345	{
318	STRNCPY(str + len, end.str, end.len);	346	STRNCPY(str + len, end.str, end.len);
319	len += end.len;	347	len += end.len;
320	}	348	}
321	str[len] = '\0';	349	str[len] = '\0';
322		350
323	#ifdef DEBUG_MENUARROWS	351	#ifdef DEBUG_MENUARROWS
324	fprintf(stderr, "<%c>(len %d) = %s\n", Arrows[i].name, len, str);	352	fprintf(stderr, "<%c>(len %d) = %s\n", Arrows[i].name, len, str);
325	#endif	353	#endif
326	if (rxvt_action_type(&(CurrentBar->arrows[i]), str) < 0)	354	if (rxvt_action_type(&(CurrentBar->arrows[i]), str) < 0)
327	free(str);	355	free(str);
328	}	356	}
329	}	357	}
330		358
331	menuitem_t *	359	menuitem_t *
332	rxvt_menuitem_add(menu_t menu, const char name, const char name2, const char action)	360	rxvt_menuitem_add(menu_t menu, const char name, const char name2, const char action)
333	{	361	{
334	menuitem_t *item;	362	menuitem_t *item;
335	unsigned int len;	363	unsigned int len;
336		364
337	#ifdef DEBUG_STRICT	365	#ifdef DEBUG_STRICT
338	assert(name != NULL);	366	assert(name != NULL);
339	assert(action != NULL);	367	assert(action != NULL);
340	#endif	368	#endif
341		369
342	if (menu == NULL)	370	if (menu == NULL)
343	return NULL;	371	return NULL;
344		372
345	if (isSeparator(name)) {	373	if (isSeparator(name))
		374	{
346	/* add separator, no action */	375	/* add separator, no action */
347	name = "";	376	name = "";
348	action = "";	377	action = "";
349	} else {	378	}
350	/*	379	else
		380	{
		381	/*
351	* add/replace existing menu item	382	* add/replace existing menu item
352	*/	383	*/
353	item = rxvt_menuitem_find(menu, name);	384	item = rxvt_menuitem_find(menu, name);
354	if (item != NULL) {	385	if (item != NULL)
		386	{
355	if (item->name2 != NULL && name2 != NULL) {	387	if (item->name2 != NULL && name2 != NULL)
356	free(item->name2);	388	{
357	item->len2 = 0;	389	free(item->name2);
358	item->name2 = NULL;	390	item->len2 = 0;
		391	item->name2 = NULL;
		392	}
		393	switch (item->entry.type)
		394	{
		395	case MenuAction:
		396	case MenuTerminalAction:
		397	free(item->entry.action.str);
		398	item->entry.action.str = NULL;
		399	break;
		400	}
		401	goto Item_Found;
		402	}
359	}	403	}
360	switch (item->entry.type) {
361	case MenuAction:
362	case MenuTerminalAction:
363	free(item->entry.action.str);
364	item->entry.action.str = NULL;
365	break;
366	}
367	goto Item_Found;
368	}
369	}
370	/* allocate a new itemect */	404	/* allocate a new itemect */
371	item = (menuitem_t *) rxvt_malloc(sizeof(menuitem_t));	405	item = (menuitem_t *) rxvt_malloc(sizeof(menuitem_t));
372		406
373	item->len2 = 0;	407	item->len2 = 0;
374	item->name2 = NULL;	408	item->name2 = NULL;
375		409
376	len = STRLEN(name);	410	len = STRLEN(name);
377	item->name = rxvt_malloc(len + 1);	411	item->name = rxvt_malloc(len + 1);
378	STRCPY(item->name, name);	412	STRCPY(item->name, name);
379	if (name[0] == '.' && name[1] != '.')	413	if (name[0] == '.' && name[1] != '.')
380	len = 0; /* hidden menu name */	414	len = 0; /* hidden menu name */
381	item->len = len;	415	item->len = len;
382		416
383	/* add to tail of list */	417	/* add to tail of list */
384	item->prev = menu->tail;	418	item->prev = menu->tail;
385	item->next = NULL;	419	item->next = NULL;
386		420
387	if (menu->tail != NULL)	421	if (menu->tail != NULL)
388	(menu->tail)->next = item;	422	(menu->tail)->next = item;
389	menu->tail = item;	423	menu->tail = item;
390	/* fix head */	424	/* fix head */
391	if (menu->head == NULL)	425	if (menu->head == NULL)
392	menu->head = item;	426	menu->head = item;
393		427
394	/*	428	/*
395	* add action	429	* add action
396	*/	430	*/
397	Item_Found:	431	Item_Found:
398	if (name2 != NULL && item->name2 == NULL) {	432	if (name2 != NULL && item->name2 == NULL)
		433	{
399	len = STRLEN(name2);	434	len = STRLEN(name2);
400	if (len == 0)	435	if (len == 0)
401	item->name2 = NULL;	436	item->name2 = NULL;
402	else {	437	else
		438	{
403	item->name2 = rxvt_malloc(len + 1);	439	item->name2 = rxvt_malloc(len + 1);
404	STRCPY(item->name2, name2);	440	STRCPY(item->name2, name2);
405	}	441	}
406	item->len2 = len;	442	item->len2 = len;
407	}	443	}
408	item->entry.type = MenuLabel;	444	item->entry.type = MenuLabel;
409	len = STRLEN(action);	445	len = STRLEN(action);
410		446
411	if (len == 0 && item->name2 != NULL) {	447	if (len == 0 && item->name2 != NULL)
		448	{
412	action = item->name2;	449	action = item->name2;
413	len = item->len2;	450	len = item->len2;
414	}	451	}
415	if (len) {	452	if (len)
		453	{
416	unsigned char *str = rxvt_malloc(len + 1);	454	unsigned char *str = rxvt_malloc(len + 1);
417		455
418	STRCPY(str, action);	456	STRCPY(str, action);
419		457
420	if (rxvt_action_type(&(item->entry.action), str) < 0)	458	if (rxvt_action_type(&(item->entry.action), str) < 0)
421	free(str);	459	free(str);
422	}	460	}
423	/* new item and a possible increase in width */	461	/* new item and a possible increase in width */
424	if (menu->width < (item->len + item->len2))	462	if (menu->width < (item->len + item->len2))
425	menu->width = (item->len + item->len2);	463	menu->width = (item->len + item->len2);
426		464
427	return item;	465	return item;
428	}	466	}
429		467
430	/*	468	/*
431	* search for the base starting menu for NAME.	469	* search for the base starting menu for NAME.
432	* return a pointer to the portion of NAME that remains	470	* return a pointer to the portion of NAME that remains
433	*/	471	*/
434	char *	472	char *
435	rxvt_term::menu_find_base (menu_t *menu, char path)	473	rxvt_term::menu_find_base (menu_t *menu, char path)
436	{	474	{
437	menu_t *m = NULL;	475	menu_t *m = NULL;
438	menuitem_t *item;	476	menuitem_t *item;
439		477
440	#ifdef DEBUG_STRICT	478	#ifdef DEBUG_STRICT
441	assert(menu != NULL);	479	assert(menu != NULL);
442	assert(CurrentBar != NULL);	480	assert(CurrentBar != NULL);
443	#endif	481	#endif
444		482
445	if (path[0] == '\0')	483	if (path[0] == '\0')
446	return path;
447
448	if (STRCHR(path, '/') != NULL) {
449	char *p = path;
450
451	while ((p = STRCHR(p, '/')) != NULL) {
452	p++;
453	if (*p == '/')
454	path = p;
455	}
456	if (path[0] == '/') {
457	path++;
458	*menu = NULL;
459	}
460	while ((p = STRCHR(path, '/')) != NULL) {
461	p[0] = '\0';
462	if (path[0] == '\0')
463	return NULL;
464	if (!STRCMP(path, DOT)) {
465	/* nothing to do */
466	} else if (!STRCMP(path, DOTS)) {
467	if (*menu != NULL)
468	menu = (menu)->parent;
469	} else {
470	path = menu_find_base (menu, path);
471	if (path[0] != '\0') { /* not found */
472	p[0] = '/'; /* fix-up name again */
473	return path;
474	}
475	}
476
477	path = (p + 1);
478	}
479	}
480	if (!STRCMP(path, DOTS)) {
481	path += STRLEN(DOTS);
482	if (*menu != NULL)
483	menu = (menu)->parent;
484	return path;
485	}
486	/* find this menu */
487	if (*menu == NULL) {
488	for (m = CurrentBar->tail; m != NULL; m = m->prev) {
489	if (!STRCMP(path, m->name))
490	break;
491	}
492	} else {
493	/* find this menu */
494	for (item = (*menu)->tail; item != NULL; item = item->prev) {
495	if (item->entry.type == MenuSubMenu
496	&& !STRCMP(path, (item->entry.submenu.menu)->name)) {
497	m = (item->entry.submenu.menu);
498	break;
499	}
500	}
501	}
502	if (m != NULL) {
503	*menu = m;
504	path += STRLEN(path);
505	}
506	return path;	484	return path;
		485
		486	if (STRCHR(path, '/') != NULL)
		487	{
		488	char *p = path;
		489
		490	while ((p = STRCHR(p, '/')) != NULL)
		491	{
		492	p++;
		493	if (*p == '/')
		494	path = p;
		495	}
		496	if (path[0] == '/')
		497	{
		498	path++;
		499	*menu = NULL;
		500	}
		501	while ((p = STRCHR(path, '/')) != NULL)
		502	{
		503	p[0] = '\0';
		504	if (path[0] == '\0')
		505	return NULL;
		506	if (!STRCMP(path, DOT))
		507	{
		508	/* nothing to do */
		509	}
		510	else if (!STRCMP(path, DOTS))
		511	{
		512	if (*menu != NULL)
		513	menu = (menu)->parent;
		514	}
		515	else
		516	{
		517	path = menu_find_base (menu, path);
		518	if (path[0] != '\0')
		519	{ /* not found */
		520	p[0] = '/'; /* fix-up name again */
		521	return path;
		522	}
		523	}
		524
		525	path = (p + 1);
		526	}
		527	}
		528	if (!STRCMP(path, DOTS))
		529	{
		530	path += STRLEN(DOTS);
		531	if (*menu != NULL)
		532	menu = (menu)->parent;
		533	return path;
		534	}
		535	/* find this menu */
		536	if (*menu == NULL)
		537	{
		538	for (m = CurrentBar->tail; m != NULL; m = m->prev)
		539	{
		540	if (!STRCMP(path, m->name))
		541	break;
		542	}
		543	}
		544	else
		545	{
		546	/* find this menu */
		547	for (item = (*menu)->tail; item != NULL; item = item->prev)
		548	{
		549	if (item->entry.type == MenuSubMenu
		550	&& !STRCMP(path, (item->entry.submenu.menu)->name))
		551	{
		552	m = (item->entry.submenu.menu);
		553	break;
		554	}
		555	}
		556	}
		557	if (m != NULL)
		558	{
		559	*menu = m;
		560	path += STRLEN(path);
		561	}
		562	return path;
507	}	563	}
508		564
509	/*	565	/*
510	* delete this entire menu	566	* delete this entire menu
511	*/	567	*/
512	menu_t *	568	menu_t *
513	rxvt_term::menu_delete (menu_t *menu)	569	rxvt_term::menu_delete (menu_t *menu)
514	{	570	{
515	menu_t parent = NULL, prev, *next;	571	menu_t parent = NULL, prev, *next;
516	menuitem_t *item;	572	menuitem_t *item;
517	bar_t *CurrentBar = CurrentBar;	573	bar_t *CurrentBar = CurrentBar;
518		574
519	#ifdef DEBUG_STRICT	575	#ifdef DEBUG_STRICT
520	assert(CurrentBar != NULL);	576	assert(CurrentBar != NULL);
521	#endif	577	#endif
522		578
523	/* delete the entire menu */	579	/* delete the entire menu */
524	if (menu == NULL)	580	if (menu == NULL)
525	return NULL;	581	return NULL;
526		582
527	parent = menu->parent;	583	parent = menu->parent;
528		584
529	/* unlink MENU */	585	/* unlink MENU */
530	prev = menu->prev;	586	prev = menu->prev;
531	next = menu->next;	587	next = menu->next;
532	if (prev != NULL)	588	if (prev != NULL)
533	prev->next = next;	589	prev->next = next;
534	if (next != NULL)	590	if (next != NULL)
535	next->prev = prev;	591	next->prev = prev;
536		592
537	/* fix the index */	593	/* fix the index */
538	if (parent == NULL) {	594	if (parent == NULL)
		595	{
539	const int len = (menu->len + HSPACE);	596	const int len = (menu->len + HSPACE);
540		597
541	if (CurrentBar->tail == menu)	598	if (CurrentBar->tail == menu)
542	CurrentBar->tail = prev;	599	CurrentBar->tail = prev;
543	if (CurrentBar->head == menu)	600	if (CurrentBar->head == menu)
544	CurrentBar->head = next;	601	CurrentBar->head = next;
545		602
546	for (next = menu->next; next != NULL; next = next->next)	603	for (next = menu->next; next != NULL; next = next->next)
547	next->x -= len;	604	next->x -= len;
548	} else {	605	}
		606	else
		607	{
549	for (item = parent->tail; item != NULL; item = item->prev) {	608	for (item = parent->tail; item != NULL; item = item->prev)
		609	{
550	if (item->entry.type == MenuSubMenu	610	if (item->entry.type == MenuSubMenu
551	&& item->entry.submenu.menu == menu) {	611	&& item->entry.submenu.menu == menu)
		612	{
552	item->entry.submenu.menu = NULL;	613	item->entry.submenu.menu = NULL;
553	menuitem_free (menu->parent, item);	614	menuitem_free (menu->parent, item);
554	break;	615	break;
		616	}
		617	}
555	}	618	}
556	}
557	}
558		619
559	item = menu->tail;	620	item = menu->tail;
560	while (item != NULL) {	621	while (item != NULL)
		622	{
561	menuitem_t *p = item->prev;	623	menuitem_t *p = item->prev;
562		624
563	menuitem_free (menu, item);	625	menuitem_free (menu, item);
564	item = p;	626	item = p;
565	}	627	}
566		628
567	if (menu->name != NULL)	629	if (menu->name != NULL)
568	free(menu->name);	630	free(menu->name);
569	free(menu);	631	free(menu);
570		632
571	return parent;	633	return parent;
572	}	634	}
573		635
574	menu_t *	636	menu_t *
575	rxvt_term::menu_add (menu_t parent, char path)	637	rxvt_term::menu_add (menu_t parent, char path)
576	{	638	{
577	menu_t *menu;	639	menu_t *menu;
578	bar_t *CurrentBar = CurrentBar;	640	bar_t *CurrentBar = CurrentBar;
579		641
580	#ifdef DEBUG_STRICT	642	#ifdef DEBUG_STRICT
581	assert(CurrentBar != NULL);	643	assert(CurrentBar != NULL);
582	#endif	644	#endif
583		645
584	if (STRCHR(path, '/') != NULL) {	646	if (STRCHR(path, '/') != NULL)
		647	{
585	char *p;	648	char *p;
586		649
587	if (path[0] == '/') {	650	if (path[0] == '/')
		651	{
588	/* shouldn't happen */	652	/* shouldn't happen */
589	path++;	653	path++;
590	parent = NULL;	654	parent = NULL;
591	}	655	}
592	while ((p = STRCHR(path, '/')) != NULL) {	656	while ((p = STRCHR(path, '/')) != NULL)
		657	{
593	p[0] = '\0';	658	p[0] = '\0';
594	if (path[0] == '\0')	659	if (path[0] == '\0')
595	return NULL;	660	return NULL;
596		661
597	parent = menu_add (parent, path);	662	parent = menu_add (parent, path);
598	path = (p + 1);	663	path = (p + 1);
599	}	664	}
600	}	665	}
601	if (!STRCMP(path, DOTS))	666	if (!STRCMP(path, DOTS))
602	return (parent != NULL ? parent->parent : parent);	667	return (parent != NULL ? parent->parent : parent);
603		668
604	if (!STRCMP(path, DOT) \|\| path[0] == '\0')	669	if (!STRCMP(path, DOT) \|\| path[0] == '\0')
605	return parent;	670	return parent;
606		671
607	/* allocate a new menu */	672	/* allocate a new menu */
608	menu = (menu_t *) rxvt_malloc(sizeof(menu_t));	673	menu = (menu_t *) rxvt_malloc(sizeof(menu_t));
609		674
610	menu->width = 0;	675	menu->width = 0;
611	menu->parent = parent;	676	menu->parent = parent;
612	menu->len = STRLEN(path);	677	menu->len = STRLEN(path);
613	menu->name = rxvt_malloc((menu->len + 1));	678	menu->name = rxvt_malloc((menu->len + 1));
614	STRCPY(menu->name, path);	679	STRCPY(menu->name, path);
615		680
616	/* initialize head/tail */	681	/* initialize head/tail */
617	menu->head = menu->tail = NULL;	682	menu->head = menu->tail = NULL;
618	menu->prev = menu->next = NULL;	683	menu->prev = menu->next = NULL;
619		684
620	menu->win = None;	685	menu->win = None;
621	menu->x = menu->y = menu->w = menu->h = 0;	686	menu->x = menu->y = menu->w = menu->h = 0;
622	menu->item = NULL;	687	menu->item = NULL;
623		688
624	/* add to tail of list */	689	/* add to tail of list */
625	if (parent == NULL) {	690	if (parent == NULL)
		691	{
626	menu->prev = CurrentBar->tail;	692	menu->prev = CurrentBar->tail;
627	if (CurrentBar->tail != NULL)	693	if (CurrentBar->tail != NULL)
628	CurrentBar->tail->next = menu;	694	CurrentBar->tail->next = menu;
629	CurrentBar->tail = menu;	695	CurrentBar->tail = menu;
630	if (CurrentBar->head == NULL)	696	if (CurrentBar->head == NULL)
631	CurrentBar->head = menu; /* fix head */	697	CurrentBar->head = menu; /* fix head */
632	if (menu->prev)	698	if (menu->prev)
633	menu->x = (menu->prev->x + menu->prev->len + HSPACE);	699	menu->x = (menu->prev->x + menu->prev->len + HSPACE);
634	} else {	700	}
		701	else
		702	{
635	menuitem_t *item;	703	menuitem_t *item;
636		704
637	item = rxvt_menuitem_add(parent, path, "", "");	705	item = rxvt_menuitem_add(parent, path, "", "");
638	if (item == NULL) {	706	if (item == NULL)
		707	{
639	free(menu);	708	free(menu);
640	return parent;	709	return parent;
641	}	710	}
642	#ifdef DEBUG_STRICT	711	#ifdef DEBUG_STRICT
643	assert(item->entry.type == MenuLabel);	712	assert(item->entry.type == MenuLabel);
644	#endif	713	#endif
645	item->entry.type = MenuSubMenu;	714	item->entry.type = MenuSubMenu;
646	item->entry.submenu.menu = menu;	715	item->entry.submenu.menu = menu;
647	}	716	}
648		717
649	return menu;	718	return menu;
650	}	719	}
651		720
652	void	721	void
653	rxvt_term::drawbox_menubar (int x, int len, int state)	722	rxvt_term::drawbox_menubar (int x, int len, int state)
654	{	723	{
655	GC top, bot;	724	GC top, bot;
656		725
657	x = Width2Pixel(x);	726	x = Width2Pixel(x);
658	len = Width2Pixel(len + HSPACE);	727	len = Width2Pixel(len + HSPACE);
659	if (x >= TermWin.width)	728	if (x >= TermWin.width)
660	return;	729	return;
661	else if (x + len >= TermWin.width)	730	else if (x + len >= TermWin.width)
662	len = (TermWin_TotalWidth() - x);	731	len = (TermWin_TotalWidth() - x);
663		732
664	#ifdef MENUBAR_SHADOW_IN	733	#ifdef MENUBAR_SHADOW_IN
665	state = -state;	734	state = -state;
666	#endif	735	#endif
667	switch (state) {	736	switch (state)
		737	{
668	case +1:	738	case +1:
669	top = topShadowGC;	739	top = topShadowGC;
670	bot = botShadowGC;	740	bot = botShadowGC;
671	break; /* SHADOW_OUT */	741	break; /* SHADOW_OUT */
672	case -1:	742	case -1:
673	top = botShadowGC;	743	top = botShadowGC;
674	bot = topShadowGC;	744	bot = topShadowGC;
675	break; /* SHADOW_IN */	745	break; /* SHADOW_IN */
676	default:	746	default:
677	top = bot = scrollbarGC;	747	top = bot = scrollbarGC;
678	break; /* neutral */	748	break; /* neutral */
679	}	749	}
680		750
681	rxvt_Draw_Shadow(Xdisplay, menuBar.win, top, bot,	751	rxvt_Draw_Shadow(Xdisplay, menuBar.win, top, bot,
682	x, 0, len, menuBar_TotalHeight());	752	x, 0, len, menuBar_TotalHeight());
683	}	753	}
684		754
685	void	755	void
686	rxvt_term::drawtriangle (int x, int y, int state)	756	rxvt_term::drawtriangle (int x, int y, int state)
687	{	757	{
688	GC top, bot;	758	GC top, bot;
689	int w;	759	int w;
690		760
691	#ifdef MENU_SHADOW_IN	761	#ifdef MENU_SHADOW_IN
692	state = -state;	762	state = -state;
693	#endif	763	#endif
694	switch (state) {	764	switch (state)
		765	{
695	case +1:	766	case +1:
696	top = topShadowGC;	767	top = topShadowGC;
697	bot = botShadowGC;	768	bot = botShadowGC;
698	break; /* SHADOW_OUT */	769	break; /* SHADOW_OUT */
699	case -1:	770	case -1:
700	top = botShadowGC;	771	top = botShadowGC;
701	bot = topShadowGC;	772	bot = topShadowGC;
702	break; /* SHADOW_IN */	773	break; /* SHADOW_IN */
703	default:	774	default:
704	top = bot = scrollbarGC;	775	top = bot = scrollbarGC;
705	break; /* neutral */	776	break; /* neutral */
706	}	777	}
707		778
708	w = Height2Pixel(1) - 2 * SHADOW;	779	w = Height2Pixel(1) - 2 * SHADOW;
709		780
710	x -= SHADOW + (3 * w / 2);	781	x -= SHADOW + (3 * w / 2);
711	y += SHADOW * 3;	782	y += SHADOW * 3;
712		783
713	rxvt_Draw_Triangle(Xdisplay, ActiveMenu->win, top, bot, x, y, w,	784	rxvt_Draw_Triangle(Xdisplay, ActiveMenu->win, top, bot, x, y, w,
714	'r');	785	'r');
715	}	786	}
716		787
717	void	788	void
718	rxvt_term::drawbox_menuitem (int y, int state)	789	rxvt_term::drawbox_menuitem (int y, int state)
719	{	790	{
720	GC top, bot;	791	GC top, bot;
721		792
722	#ifdef MENU_SHADOW_IN	793	#ifdef MENU_SHADOW_IN
723	state = -state;	794	state = -state;
724	#endif	795	#endif
725	switch (state) {	796	switch (state)
		797	{
726	case +1:	798	case +1:
727	top = topShadowGC;	799	top = topShadowGC;
728	bot = botShadowGC;	800	bot = botShadowGC;
729	break; /* SHADOW_OUT */	801	break; /* SHADOW_OUT */
730	case -1:	802	case -1:
731	top = botShadowGC;	803	top = botShadowGC;
732	bot = topShadowGC;	804	bot = topShadowGC;
733	break; /* SHADOW_IN */	805	break; /* SHADOW_IN */
734	default:	806	default:
735	top = bot = scrollbarGC;	807	top = bot = scrollbarGC;
736	break; /* neutral */	808	break; /* neutral */
737	}	809	}
738		810
739	rxvt_Draw_Shadow(Xdisplay, ActiveMenu->win, top, bot,	811	rxvt_Draw_Shadow(Xdisplay, ActiveMenu->win, top, bot,
740	SHADOW + 0, SHADOW + y,	812	SHADOW + 0, SHADOW + y,
741	ActiveMenu->w - 2 * (SHADOW),	813	ActiveMenu->w - 2 * (SHADOW),
742	HEIGHT_TEXT + 2 * SHADOW);	814	HEIGHT_TEXT + 2 * SHADOW);
743	XFlush(Xdisplay);	815	XFlush(Xdisplay);
744	}	816	}
745		817
746	#ifdef DEBUG_MENU_LAYOUT	818	#ifdef DEBUG_MENU_LAYOUT
747	void	819	void
748	rxvt_print_menu_ancestors(menu_t *menu)	820	rxvt_print_menu_ancestors(menu_t *menu)
749	{	821	{
750	if (menu == NULL) {	822	if (menu == NULL)
		823	{
751	fprintf(stderr, "Top Level menu\n");	824	fprintf(stderr, "Top Level menu\n");
752	return;	825	return;
753	}	826	}
754	fprintf(stderr, "menu %s ", menu->name);	827	fprintf(stderr, "menu %s ", menu->name);
755	if (menu->parent != NULL) {	828	if (menu->parent != NULL)
		829	{
756	menuitem_t *item;	830	menuitem_t *item;
757		831
758	for (item = menu->parent->head; item != NULL; item = item->next) {	832	for (item = menu->parent->head; item != NULL; item = item->next)
		833	{
759	if (item->entry.type == MenuSubMenu	834	if (item->entry.type == MenuSubMenu
760	&& item->entry.submenu.menu == menu) {	835	&& item->entry.submenu.menu == menu)
761	break;	836	{
762	}	837	break;
763	}	838	}
		839	}
764	if (item == NULL) {	840	if (item == NULL)
		841	{
765	fprintf(stderr, "is an orphan!\n");	842	fprintf(stderr, "is an orphan!\n");
766	return;	843	return;
767	}	844	}
768	}	845	}
769	fprintf(stderr, "\n");	846	fprintf(stderr, "\n");
770	rxvt_print_menu_ancestors(menu->parent);	847	rxvt_print_menu_ancestors(menu->parent);
771	}	848	}
772		849
773	void	850	void
774	rxvt_print_menu_descendants(menu_t *menu)	851	rxvt_print_menu_descendants(menu_t *menu)
775	{	852	{
776	menuitem_t *item;	853	menuitem_t *item;
777	menu_t *parent;	854	menu_t *parent;
778	int i, level = 0;	855	int i, level = 0;
779		856
780	parent = menu;	857	parent = menu;
		858	do
781	do {	859	{
782	level++;	860	level++;
783	parent = parent->parent;	861	parent = parent->parent;
784	}	862	}
785	while (parent != NULL);	863	while (parent != NULL);
786		864
787	for (i = 0; i < level; i++)	865	for (i = 0; i < level; i++)
788	fprintf(stderr, ">");	866	fprintf(stderr, ">");
789	fprintf(stderr, "%s\n", menu->name);	867	fprintf(stderr, "%s\n", menu->name);
790		868
791	for (item = menu->head; item != NULL; item = item->next) {	869	for (item = menu->head; item != NULL; item = item->next)
		870	{
792	if (item->entry.type == MenuSubMenu) {	871	if (item->entry.type == MenuSubMenu)
		872	{
793	if (item->entry.submenu.menu == NULL)	873	if (item->entry.submenu.menu == NULL)
794	fprintf(stderr, "> %s == NULL\n", item->name);	874	fprintf(stderr, "> %s == NULL\n", item->name);
795	else	875	else
796	rxvt_print_menu_descendants(item->entry.submenu.menu);	876	rxvt_print_menu_descendants(item->entry.submenu.menu);
797	} else {	877	}
		878	else
		879	{
798	for (i = 0; i < level; i++)	880	for (i = 0; i < level; i++)
799	fprintf(stderr, "+");	881	fprintf(stderr, "+");
800	if (item->entry.type == MenuLabel)	882	if (item->entry.type == MenuLabel)
801	fprintf(stderr, "label: ");	883	fprintf(stderr, "label: ");
802	fprintf(stderr, "%s\n", item->name);	884	fprintf(stderr, "%s\n", item->name);
803	}	885	}
804	}	886	}
805		887
806	for (i = 0; i < level; i++)	888	for (i = 0; i < level; i++)
807	fprintf(stderr, "<");	889	fprintf(stderr, "<");
808	fprintf(stderr, "\n");	890	fprintf(stderr, "\n");
809	}	891	}
810	#endif	892	#endif
811		893
812	/* pop up/down the current menu and redraw the menuBar button */	894	/* pop up/down the current menu and redraw the menuBar button */
813	void	895	void
814	rxvt_term::menu_show ()	896	rxvt_term::menu_show ()
815	{	897	{
816	int x, y, xright;	898	int x, y, xright;
817	menu_t *ActiveMenu = ActiveMenu;	899	menu_t *ActiveMenu = ActiveMenu;
818	menuitem_t *item;	900	menuitem_t *item;
819		901
820	if (ActiveMenu == NULL)	902	if (ActiveMenu == NULL)
821	return;	903	return;
822		904
823	x = ActiveMenu->x;	905	x = ActiveMenu->x;
824	if (ActiveMenu->parent == NULL) {	906	if (ActiveMenu->parent == NULL)
		907	{
825	register int h;	908	register int h;
826		909
827	drawbox_menubar (x, ActiveMenu->len, -1);	910	drawbox_menubar (x, ActiveMenu->len, -1);
828	x = Width2Pixel(x);	911	x = Width2Pixel(x);
829		912
830	ActiveMenu->y = 1;	913	ActiveMenu->y = 1;
831	ActiveMenu->w = Menu_PixelWidth(ActiveMenu);	914	ActiveMenu->w = Menu_PixelWidth(ActiveMenu);
832		915
833	if ((x + ActiveMenu->w) >= TermWin.width)	916	if ((x + ActiveMenu->w) >= TermWin.width)
834	x = (TermWin_TotalWidth() - ActiveMenu->w);	917	x = (TermWin_TotalWidth() - ActiveMenu->w);
835		918
836	/* find the height */	919	/* find the height */
837	for (h = 0, item = ActiveMenu->head; item != NULL; item = item->next)	920	for (h = 0, item = ActiveMenu->head; item != NULL; item = item->next)
838	h += isSeparator(item->name) ? HEIGHT_SEPARATOR	921	h += isSeparator(item->name) ? HEIGHT_SEPARATOR
839	: HEIGHT_TEXT + 2 * SHADOW;	922	: HEIGHT_TEXT + 2 * SHADOW;
840	ActiveMenu->h = h + 2 * SHADOW;	923	ActiveMenu->h = h + 2 * SHADOW;
841	}	924	}
842	if (ActiveMenu->win == None) {	925	if (ActiveMenu->win == None)
		926	{
843	ActiveMenu->win = XCreateSimpleWindow(Xdisplay, TermWin.vt,	927	ActiveMenu->win = XCreateSimpleWindow(Xdisplay, TermWin.vt,
844	x, ActiveMenu->y,	928	x, ActiveMenu->y,
845	ActiveMenu->w, ActiveMenu->h,	929	ActiveMenu->w, ActiveMenu->h,
846	0,	930	0,
847	PixColors[Color_fg],	931	PixColors[Color_fg],
848	PixColors[Color_scroll]);	932	PixColors[Color_scroll]);
849	XMapWindow(Xdisplay, ActiveMenu->win);	933	XMapWindow(Xdisplay, ActiveMenu->win);
850	}	934	}
851	rxvt_Draw_Shadow(Xdisplay, ActiveMenu->win,	935	rxvt_Draw_Shadow(Xdisplay, ActiveMenu->win,
852	topShadowGC, botShadowGC,	936	topShadowGC, botShadowGC,
853	0, 0, ActiveMenu->w, ActiveMenu->h);	937	0, 0, ActiveMenu->w, ActiveMenu->h);
854		938
855	/* determine the correct right-alignment */	939	/* determine the correct right-alignment */
856	for (xright = 0, item = ActiveMenu->head; item != NULL; item = item->next)	940	for (xright = 0, item = ActiveMenu->head; item != NULL; item = item->next)
857	if (item->len2 > xright)	941	if (item->len2 > xright)
858	xright = item->len2;	942	xright = item->len2;
859		943
860	for (y = 0, item = ActiveMenu->head; item != NULL; item = item->next) {	944	for (y = 0, item = ActiveMenu->head; item != NULL; item = item->next)
		945	{
861	const int xoff = (SHADOW + Width2Pixel(HSPACE) / 2);	946	const int xoff = (SHADOW + Width2Pixel(HSPACE) / 2);
862	register int h;	947	register int h;
863	GC gc = menubarGC;	948	GC gc = menubarGC;
864		949
865	if (isSeparator(item->name)) {	950	if (isSeparator(item->name))
		951	{
866	rxvt_Draw_Shadow(Xdisplay, ActiveMenu->win,	952	rxvt_Draw_Shadow(Xdisplay, ActiveMenu->win,
867	topShadowGC, botShadowGC,	953	topShadowGC, botShadowGC,
868	SHADOW, y + SHADOW + 1,	954	SHADOW, y + SHADOW + 1,
869	ActiveMenu->w - 2 * SHADOW, 0);	955	ActiveMenu->w - 2 * SHADOW, 0);
870	h = HEIGHT_SEPARATOR;	956	h = HEIGHT_SEPARATOR;
871	} else {	957	}
		958	else
		959	{
872	char *name = item->name;	960	char *name = item->name;
873	int len = item->len;	961	int len = item->len;
874		962
875	if (item->entry.type == MenuLabel) {	963	if (item->entry.type == MenuLabel)
876	gc = botShadowGC;	964	{
		965	gc = botShadowGC;
		966	}
877	} else if (item->entry.type == MenuSubMenu) {	967	else if (item->entry.type == MenuSubMenu)
878	int x1, y1;	968	{
879	menuitem_t *it;	969	int x1, y1;
		970	menuitem_t *it;
880	menu_t *menu = item->entry.submenu.menu;	971	menu_t *menu = item->entry.submenu.menu;
881		972
882	drawtriangle (ActiveMenu->w, y, +1);	973	drawtriangle (ActiveMenu->w, y, +1);
883		974
884	name = menu->name;	975	name = menu->name;
885	len = menu->len;	976	len = menu->len;
886		977
887	y1 = ActiveMenu->y + y;	978	y1 = ActiveMenu->y + y;
888		979
889	menu->w = Menu_PixelWidth(menu);	980	menu->w = Menu_PixelWidth(menu);
890		981
891	/* place sub-menu at midpoint of parent menu */	982	/* place sub-menu at midpoint of parent menu */
892	x1 = ActiveMenu->w / 2;	983	x1 = ActiveMenu->w / 2;
893	if (x1 > menu->w) /* right-flush menu if too small */	984	if (x1 > menu->w) /* right-flush menu if too small */
894	x1 += (x1 - menu->w);	985	x1 += (x1 - menu->w);
895	x1 += x;	986	x1 += x;
896		987
897	/* find the height of this submenu */	988	/* find the height of this submenu */
898	for (h = 0, it = menu->head; it != NULL; it = it->next)	989	for (h = 0, it = menu->head; it != NULL; it = it->next)
899	h += isSeparator(it->name) ? HEIGHT_SEPARATOR	990	h += isSeparator(it->name) ? HEIGHT_SEPARATOR
900	: HEIGHT_TEXT + 2 * SHADOW;	991	: HEIGHT_TEXT + 2 * SHADOW;
901	menu->h = h + 2 * SHADOW;	992	menu->h = h + 2 * SHADOW;
902		993
903	/* ensure menu is in window limits */	994	/* ensure menu is in window limits */
904	if ((x1 + menu->w) >= TermWin.width)	995	if ((x1 + menu->w) >= TermWin.width)
905	x1 = (TermWin_TotalWidth() - menu->w);	996	x1 = (TermWin_TotalWidth() - menu->w);
906		997
907	if ((y1 + menu->h) >= TermWin.height)	998	if ((y1 + menu->h) >= TermWin.height)
908	y1 = (TermWin_TotalHeight() - menu->h);	999	y1 = (TermWin_TotalHeight() - menu->h);
909		1000
910	menu->x = (x1 < 0 ? 0 : x1);	1001	menu->x = (x1 < 0 ? 0 : x1);
911	menu->y = (y1 < 0 ? 0 : y1);	1002	menu->y = (y1 < 0 ? 0 : y1);
		1003	}
912	} else if (item->name2 && !STRCMP(name, item->name2))	1004	else if (item->name2 && !STRCMP(name, item->name2))
913	name = NULL;	1005	name = NULL;
914		1006
915	if (len && name) {	1007	if (len && name)
		1008	{
916	#ifdef USE_XIM	1009	#ifdef USE_XIM
917	if (TermWin.fontset)	1010	if (TermWin.fontset)
918	XmbDrawString(Xdisplay,	1011	XmbDrawString(Xdisplay,
919	ActiveMenu->win, TermWin.fontset,	1012	ActiveMenu->win, TermWin.fontset,
920	gc, xoff,	1013	gc, xoff,
921	2 * SHADOW + y + TermWin.font->ascent + 1,	1014	2 * SHADOW + y + TermWin.font->ascent + 1,
922	name, len);	1015	name, len);
923	else	1016	else
924	#endif	1017	#endif
925	XDrawString(Xdisplay, ActiveMenu->win, gc, xoff,	1018	XDrawString(Xdisplay, ActiveMenu->win, gc, xoff,
926	2 * SHADOW + y + TermWin.font->ascent + 1,	1019	2 * SHADOW + y + TermWin.font->ascent + 1,
927	name, len);	1020	name, len);
928	}	1021	}
929		1022
930	len = item->len2;	1023	len = item->len2;
931	name = item->name2;	1024	name = item->name2;
932	if (len && name) {	1025	if (len && name)
		1026	{
933	#ifdef USE_XIM	1027	#ifdef USE_XIM
934	if (TermWin.fontset)	1028	if (TermWin.fontset)
935	XmbDrawString(Xdisplay,	1029	XmbDrawString(Xdisplay,
936	ActiveMenu->win, TermWin.fontset,	1030	ActiveMenu->win, TermWin.fontset,
937	gc,	1031	gc,
938	ActiveMenu->w - (xoff + Width2Pixel(xright)),	1032	ActiveMenu->w - (xoff + Width2Pixel(xright)),
939	2 * SHADOW + y + TermWin.font->ascent + 1,	1033	2 * SHADOW + y + TermWin.font->ascent + 1,
940	name, len);	1034	name, len);
941	else	1035	else
942	#endif	1036	#endif
943	XDrawString(Xdisplay, ActiveMenu->win, gc,	1037	XDrawString(Xdisplay, ActiveMenu->win, gc,
944	ActiveMenu->w - (xoff + Width2Pixel(xright)),	1038	ActiveMenu->w - (xoff + Width2Pixel(xright)),
945	2 * SHADOW + y + TermWin.font->ascent + 1,	1039	2 * SHADOW + y + TermWin.font->ascent + 1,
946	name, len);	1040	name, len);
947	}	1041	}
948	h = HEIGHT_TEXT + 2 * SHADOW;	1042	h = HEIGHT_TEXT + 2 * SHADOW;
949	}	1043	}
950	y += h;	1044	y += h;
951	}	1045	}
952	}	1046	}
953		1047
954	void	1048	void
955	rxvt_term::menu_display (void (update)(rxvt_t ))	1049	rxvt_term::menu_display (void (update)(rxvt_t ))
956	{	1050	{
957	menu_t *ActiveMenu = ActiveMenu;	1051	menu_t *ActiveMenu = ActiveMenu;
958		1052
959	if (ActiveMenu == NULL)	1053	if (ActiveMenu == NULL)
960	return;	1054	return;
961	if (ActiveMenu->win != None)	1055	if (ActiveMenu->win != None)
962	XDestroyWindow(Xdisplay, ActiveMenu->win);	1056	XDestroyWindow(Xdisplay, ActiveMenu->win);
963	ActiveMenu->win = None;	1057	ActiveMenu->win = None;
964	ActiveMenu->item = NULL;	1058	ActiveMenu->item = NULL;
965		1059
966	if (ActiveMenu->parent == NULL)	1060	if (ActiveMenu->parent == NULL)
967	drawbox_menubar (ActiveMenu->x, ActiveMenu->len, +1);	1061	drawbox_menubar (ActiveMenu->x, ActiveMenu->len, +1);
968	ActiveMenu = ActiveMenu->parent;	1062	ActiveMenu = ActiveMenu->parent;
969	update(r);	1063	update(r);
970	}	1064	}
971		1065
972	void	1066	void
973	rxvt_term::menu_hide_all ()	1067	rxvt_term::menu_hide_all ()
974	{	1068	{
975	menu_display (rxvt_menu_hide_all);	1069	menu_display (rxvt_menu_hide_all);
976	}	1070	}
977		1071
978	void	1072	void
979	rxvt_term::menu_hide ()	1073	rxvt_term::menu_hide ()
980	{	1074	{
981	menu_display (rxvt_menu_show);	1075	menu_display (rxvt_menu_show);
982	}	1076	}
983		1077
984	void	1078	void
985	rxvt_term::menu_clear (menu_t *menu)	1079	rxvt_term::menu_clear (menu_t *menu)
986	{	1080	{
987	if (menu != NULL) {	1081	if (menu != NULL)
		1082	{
988	menuitem_t *item = menu->tail;	1083	menuitem_t *item = menu->tail;
989		1084
990	while (item != NULL) {	1085	while (item != NULL)
		1086	{
991	menuitem_free (menu, item);	1087	menuitem_free (menu, item);
992	/* it didn't get freed ... why? */	1088	/* it didn't get freed ... why? */
993	if (item == menu->tail)	1089	if (item == menu->tail)
994	return;	1090	return;
995	item = menu->tail;	1091	item = menu->tail;
996	}	1092	}
997	menu->width = 0;	1093	menu->width = 0;
998	}	1094	}
999	}	1095	}
1000		1096
1001	void	1097	void
1002	rxvt_term::menubar_clear ()	1098	rxvt_term::menubar_clear ()
1003	{	1099	{
1004	bar_t *CurrentBar = CurrentBar;	1100	bar_t *CurrentBar = CurrentBar;
1005		1101
1006	if (CurrentBar != NULL) {	1102	if (CurrentBar != NULL)
		1103	{
1007	menu_t *menu = CurrentBar->tail;	1104	menu_t *menu = CurrentBar->tail;
1008		1105
1009	while (menu != NULL) {	1106	while (menu != NULL)
		1107	{
1010	menu_t *prev = menu->prev;	1108	menu_t *prev = menu->prev;
1011		1109
1012	menu_delete (menu);	1110	menu_delete (menu);
1013	menu = prev;	1111	menu = prev;
1014	}	1112	}
1015	CurrentBar->head = CurrentBar->tail = NULL;	1113	CurrentBar->head = CurrentBar->tail = NULL;
1016		1114
1017	if (CurrentBar->title) {	1115	if (CurrentBar->title)
		1116	{
1018	free(CurrentBar->title);	1117	free(CurrentBar->title);
1019	CurrentBar->title = NULL;	1118	CurrentBar->title = NULL;
1020	}	1119	}
1021	menuarrow_free (0); /* remove all arrow functions */	1120	menuarrow_free (0); /* remove all arrow functions */
1022	}	1121	}
1023	ActiveMenu = NULL;	1122	ActiveMenu = NULL;
1024	}	1123	}
1025		1124
1026	#if (MENUBAR_MAX > 1)	1125	#if (MENUBAR_MAX > 1)
1027	/* find if menu already exists */	1126	/* find if menu already exists */
1028	bar_t *	1127	bar_t *
1029	rxvt_term::menubar_find (const char *name)	1128	rxvt_term::menubar_find (const char *name)
1030	{	1129	{
1031	bar_t *bar = CurrentBar;	1130	bar_t *bar = CurrentBar;
1032		1131
1033	#ifdef DEBUG_MENUBAR_STACKING	1132	#ifdef DEBUG_MENUBAR_STACKING
1034	fprintf(stderr, "looking for [menu:%s] ...", name ? name : "(nil)");	1133	fprintf(stderr, "looking for [menu:%s] ...", name ? name : "(nil)");
1035	#endif	1134	#endif
1036	if (bar == NULL \|\| name == NULL)	1135	if (bar == NULL \|\| name == NULL)
1037	return NULL;	1136	return NULL;
1038		1137
1039	if (STRLEN(name) && STRCMP(name, "*")) {	1138	if (STRLEN(name) && STRCMP(name, "*"))
1040	do {	1139	{
		1140	do
		1141	{
1041	if (!STRCMP(bar->name, name)) {	1142	if (!STRCMP(bar->name, name))
		1143	{
1042	#ifdef DEBUG_MENUBAR_STACKING	1144	#ifdef DEBUG_MENUBAR_STACKING
1043	fprintf(stderr, " found!\n");	1145	fprintf(stderr, " found!\n");
1044	#endif	1146	#endif
1045	return bar;	1147	return bar;
1046	}	1148	}
1047	bar = bar->next;	1149	bar = bar->next;
1048	}	1150	}
1049	while (bar != CurrentBar);	1151	while (bar != CurrentBar);
1050	bar = NULL;	1152	bar = NULL;
1051	}	1153	}
1052	#ifdef DEBUG_MENUBAR_STACKING	1154	#ifdef DEBUG_MENUBAR_STACKING
1053	fprintf(stderr, "%s found!\n", (bar ? "" : " NOT"));	1155	fprintf(stderr, "%s found!\n", (bar ? "" : " NOT"));
1054	#endif	1156	#endif
1055		1157
1056	return bar;	1158	return bar;
1057	}	1159	}
1058		1160
1059	int	1161	int
1060	rxvt_term::menubar_push (const char *name)	1162	rxvt_term::menubar_push (const char *name)
1061	{	1163	{
1062	int ret = 1;	1164	int ret = 1;
1063	bar_t *bar;	1165	bar_t *bar;
1064		1166
1065	if (CurrentBar == NULL) {	1167	if (CurrentBar == NULL)
		1168	{
1066	/* allocate first one */	1169	/* allocate first one */
1067	bar = (bar_t *) rxvt_malloc(sizeof(bar_t));
1068
1069	MEMSET(bar, 0, sizeof(bar_t));
1070	/* circular linked-list */
1071	bar->next = bar->prev = bar;
1072	bar->head = bar->tail = NULL;
1073	bar->title = NULL;
1074	CurrentBar = bar;
1075	Nbars++;
1076
1077	menubar_clear ();
1078	} else {
1079	/* find if menu already exists */
1080	bar = menubar_find (name);
1081	if (bar != NULL) {
1082	/* found it, use it */
1083	CurrentBar = bar;
1084	} else {
1085	/* create if needed, or reuse the existing empty menubar */
1086	if (CurrentBar->head != NULL) {
1087	/* need to malloc another one */
1088	if (Nbars < MENUBAR_MAX)
1089	bar = (bar_t *) rxvt_malloc(sizeof(bar_t));	1170	bar = (bar_t *) rxvt_malloc(sizeof(bar_t));
1090	else
1091	bar = NULL;
1092		1171
1093	/* malloc failed or too many menubars, reuse another */	1172	MEMSET(bar, 0, sizeof(bar_t));
1094	if (bar == NULL) {	1173	/* circular linked-list */
1095	bar = CurrentBar->next;	1174	bar->next = bar->prev = bar;
1096	ret = -1;
1097	} else {
1098	bar->head = bar->tail = NULL;	1175	bar->head = bar->tail = NULL;
1099	bar->title = NULL;	1176	bar->title = NULL;
1100
1101	bar->next = CurrentBar->next;
1102	CurrentBar->next = bar;	1177	CurrentBar = bar;
1103	bar->prev = CurrentBar;
1104	bar->next->prev = bar;
1105
1106	Nbars++;	1178	Nbars++;
1107	}
1108	CurrentBar = bar;
1109		1179
1110	}
1111	menubar_clear ();	1180	menubar_clear ();
1112	}	1181	}
		1182	else
1113	}	1183	{
		1184	/* find if menu already exists */
		1185	bar = menubar_find (name);
		1186	if (bar != NULL)
		1187	{
		1188	/* found it, use it */
		1189	CurrentBar = bar;
		1190	}
		1191	else
		1192	{
		1193	/* create if needed, or reuse the existing empty menubar */
		1194	if (CurrentBar->head != NULL)
		1195	{
		1196	/* need to malloc another one */
		1197	if (Nbars < MENUBAR_MAX)
		1198	bar = (bar_t *) rxvt_malloc(sizeof(bar_t));
		1199	else
		1200	bar = NULL;
1114		1201
		1202	/* malloc failed or too many menubars, reuse another */
		1203	if (bar == NULL)
		1204	{
		1205	bar = CurrentBar->next;
		1206	ret = -1;
		1207	}
		1208	else
		1209	{
		1210	bar->head = bar->tail = NULL;
		1211	bar->title = NULL;
		1212
		1213	bar->next = CurrentBar->next;
		1214	CurrentBar->next = bar;
		1215	bar->prev = CurrentBar;
		1216	bar->next->prev = bar;
		1217
		1218	Nbars++;
		1219	}
		1220	CurrentBar = bar;
		1221
		1222	}
		1223	menubar_clear ();
		1224	}
		1225	}
		1226
1115	/* give menubar this name */	1227	/* give menubar this name */
1116	STRNCPY(CurrentBar->name, name, MAXNAME);	1228	STRNCPY(CurrentBar->name, name, MAXNAME);
1117	CurrentBar->name[MAXNAME - 1] = '\0';	1229	CurrentBar->name[MAXNAME - 1] = '\0';
1118		1230
1119	return ret;	1231	return ret;
1120	}	1232	}
1121		1233
1122	/* switch to a menu called NAME and remove it */	1234	/* switch to a menu called NAME and remove it */
1123	void	1235	void
1124	rxvt_term::menubar_remove (const char *name)	1236	rxvt_term::menubar_remove (const char *name)
1125	{	1237	{
1126	bar_t *bar;	1238	bar_t *bar;
1127		1239
1128	if ((bar = menubar_find (name)) == NULL)	1240	if ((bar = menubar_find (name)) == NULL)
1129	return;	1241	return;
1130	CurrentBar = bar;	1242	CurrentBar = bar;
1131		1243
		1244	do
1132	do {	1245	{
1133	menubar_clear ();	1246	menubar_clear ();
1134	/*	1247	/*
1135	* pop a menubar, clean it up first	1248	* pop a menubar, clean it up first
1136	*/	1249	*/
1137	if (CurrentBar != NULL) {	1250	if (CurrentBar != NULL)
		1251	{
1138	bar_t *prev = CurrentBar->prev;	1252	bar_t *prev = CurrentBar->prev;
1139	bar_t *next = CurrentBar->next;	1253	bar_t *next = CurrentBar->next;
1140		1254
1141	if (prev == next && prev == CurrentBar) { /* only 1 left */	1255	if (prev == next && prev == CurrentBar)
1142	prev = NULL;	1256	{ /* only 1 left */
1143	Nbars = 0; /* safety */	1257	prev = NULL;
1144	} else {	1258	Nbars = 0; /* safety */
1145	next->prev = prev;	1259	}
1146	prev->next = next;	1260	else
1147	Nbars--;	1261	{
		1262	next->prev = prev;
		1263	prev->next = next;
		1264	Nbars--;
		1265	}
		1266
		1267	free(CurrentBar);
		1268	CurrentBar = prev;
		1269	}
1148	}	1270	}
1149
1150	free(CurrentBar);
1151	CurrentBar = prev;
1152	}
1153	}
1154	while (CurrentBar && !STRCMP(name, "*"));	1271	while (CurrentBar && !STRCMP(name, "*"));
1155	}	1272	}
1156		1273
1157	void	1274	void
1158	rxvt_action_decode(FILE fp, action_t act)	1275	rxvt_action_decode(FILE fp, action_t act)
1159	{	1276	{
1160	unsigned char *str;	1277	unsigned char *str;
1161	short len;	1278	short len;
1162		1279
1163	if (act == NULL \|\| (len = act->len) == 0 \|\| (str = act->str) == NULL)	1280	if (act == NULL \|\| (len = act->len) == 0 \|\| (str = act->str) == NULL)
1164	return;	1281	return;
1165		1282
1166	if (act->type == MenuTerminalAction) {	1283	if (act->type == MenuTerminalAction)
		1284	{
1167	fprintf(fp, "^@");	1285	fprintf(fp, "^@");
1168	/* can strip trailing ^G from XTerm sequence */	1286	/* can strip trailing ^G from XTerm sequence */
1169	if (str[0] == C0_ESC && str[1] == ']' && str[len - 1] == C0_BEL)	1287	if (str[0] == C0_ESC && str[1] == ']' && str[len - 1] == C0_BEL)
1170	len--;	1288	len--;
		1289	}
1171	} else if (str[0] == C0_ESC) {	1290	else if (str[0] == C0_ESC)
		1291	{
1172	switch (str[1]) {	1292	switch (str[1])
1173	case '[':	1293	{
1174	case ']':	1294	case '[':
1175	break;	1295	case ']':
		1296	break;
1176		1297
1177	case 'x':	1298	case 'x':
1178	/* can strip trailing '\r' from M-x sequence */	1299	/* can strip trailing '\r' from M-x sequence */
1179	if (str[len - 1] == '\r')	1300	if (str[len - 1] == '\r')
1180	len--;	1301	len--;
1181	/* FALLTHROUGH */	1302	/* FALLTHROUGH */
1182		1303
1183	default:	1304	default:
1184	fprintf(fp, "M-"); /* meta prefix */	1305	fprintf(fp, "M-"); /* meta prefix */
1185	str++;	1306	str++;
1186	len--;	1307	len--;
1187	break;	1308	break;
1188	}	1309	}
1189	}	1310	}
1190	/*	1311	/*
1191	* control character form is preferred, since backslash-escaping	1312	* control character form is preferred, since backslash-escaping
1192	* can be really ugly looking when the backslashes themselves also	1313	* can be really ugly looking when the backslashes themselves also
1193	* have to be escaped to avoid Shell (or whatever scripting	1314	* have to be escaped to avoid Shell (or whatever scripting
1194	* language) interpretation	1315	* language) interpretation
1195	*/	1316	*/
1196	while (len > 0) {	1317	while (len > 0)
		1318	{
1197	unsigned char ch = *str++;	1319	unsigned char ch = *str++;
1198		1320
1199	switch (ch) {	1321	switch (ch)
1200	case C0_ESC:	1322	{
		1323	case C0_ESC:
1201	fprintf(fp, "\\E");	1324	fprintf(fp, "\\E");
1202	break; /* escape */	1325	break; /* escape */
1203	case '\r':	1326	case '\r':
1204	fprintf(fp, "\\r");	1327	fprintf(fp, "\\r");
1205	break; /* carriage-return */	1328	break; /* carriage-return */
1206	case '\\':	1329	case '\\':
1207	fprintf(fp, "\\\\");	1330	fprintf(fp, "\\\\");
1208	break; /* backslash */	1331	break; /* backslash */
1209	case '^':	1332	case '^':
1210	fprintf(fp, "\\^");	1333	fprintf(fp, "\\^");
1211	break; /* caret */	1334	break; /* caret */
1212	case 127:	1335	case 127:
1213	fprintf(fp, "^?");	1336	fprintf(fp, "^?");
1214	default:	1337	default:
1215	if (ch <= 31)	1338	if (ch <= 31)
1216	fprintf(fp, "^%c", ('@' + ch));	1339	fprintf(fp, "^%c", ('@' + ch));
1217	else if (ch > 127)	1340	else if (ch > 127)
1218	fprintf(fp, "\\%o", ch);	1341	fprintf(fp, "\\%o", ch);
1219	else	1342	else
1220	fprintf(fp, "%c", ch);	1343	fprintf(fp, "%c", ch);
1221	break;	1344	break;
1222	}	1345	}
1223	len--;	1346	len--;
1224	}	1347	}
1225	fprintf(fp, "\n");	1348	fprintf(fp, "\n");
1226	}	1349	}
1227		1350
1228	void	1351	void
1229	rxvt_menu_dump(FILE fp, menu_t menu)	1352	rxvt_menu_dump(FILE fp, menu_t menu)
1230	{	1353	{
1231	menuitem_t *item;	1354	menuitem_t *item;
1232		1355
1233	/* create a new menu and clear it */	1356	/* create a new menu and clear it */
1234	fprintf(fp, (menu->parent ? "./%s/\n" : "/%s/\n"), menu->name);	1357	fprintf(fp, (menu->parent ? "./%s/\n" : "/%s/\n"), menu->name);
1235		1358
1236	for (item = menu->head; item != NULL; item = item->next) {	1359	for (item = menu->head; item != NULL; item = item->next)
		1360	{
1237	switch (item->entry.type) {	1361	switch (item->entry.type)
		1362	{
1238	case MenuSubMenu:	1363	case MenuSubMenu:
1239	if (item->entry.submenu.menu == NULL)	1364	if (item->entry.submenu.menu == NULL)
1240	fprintf(fp, "> %s == NULL\n", item->name);	1365	fprintf(fp, "> %s == NULL\n", item->name);
1241	else	1366	else
1242	rxvt_menu_dump(fp, item->entry.submenu.menu);	1367	rxvt_menu_dump(fp, item->entry.submenu.menu);
1243	break;	1368	break;
1244		1369
1245	case MenuLabel:	1370	case MenuLabel:
1246	fprintf(fp, "{%s}\n", (STRLEN(item->name) ? item->name : "-"));	1371	fprintf(fp, "{%s}\n", (STRLEN(item->name) ? item->name : "-"));
1247	break;	1372	break;
1248		1373
1249	case MenuTerminalAction:	1374	case MenuTerminalAction:
1250	case MenuAction:	1375	case MenuAction:
1251	fprintf(fp, "{%s}", item->name);	1376	fprintf(fp, "{%s}", item->name);
1252	if (item->name2 != NULL && STRLEN(item->name2))	1377	if (item->name2 != NULL && STRLEN(item->name2))
1253	fprintf(fp, "{%s}", item->name2);	1378	fprintf(fp, "{%s}", item->name2);
1254	fprintf(fp, "\t");	1379	fprintf(fp, "\t");
1255	rxvt_action_decode(fp, &(item->entry.action));	1380	rxvt_action_decode(fp, &(item->entry.action));
1256	break;	1381	break;
1257	}	1382	}
1258	}	1383	}
1259		1384
1260	fprintf(fp, (menu->parent ? "../\n" : "/\n\n"));	1385	fprintf(fp, (menu->parent ? "../\n" : "/\n\n"));
1261	}	1386	}
1262		1387
1263	void	1388	void
1264	rxvt_term::menubar_dump (FILE *fp)	1389	rxvt_term::menubar_dump (FILE *fp)
1265	{	1390	{
1266	bar_t *bar = CurrentBar;	1391	bar_t *bar = CurrentBar;
1267	time_t t;	1392	time_t t;
1268		1393
1269	if (bar == NULL \|\| fp == NULL)	1394	if (bar == NULL \|\| fp == NULL)
1270	return;	1395	return;
1271	time(&t);	1396	time(&t);
1272		1397
1273	fprintf(fp,	1398	fprintf(fp,
1274	"# " APL_SUBCLASS " (%s) Pid: %u\n# Date: %s\n\n",	1399	"# " APL_SUBCLASS " (%s) Pid: %u\n# Date: %s\n\n",
1275	rs[Rs_name], (unsigned int)getpid(), ctime(&t));	1400	rs[Rs_name], (unsigned int)getpid(), ctime(&t));
1276		1401
1277	/* dump in reverse order */	1402	/* dump in reverse order */
1278	bar = CurrentBar->prev;	1403	bar = CurrentBar->prev;
		1404	do
1279	do {	1405	{
1280	menu_t *menu;	1406	menu_t *menu;
1281	int i;	1407	int i;
1282		1408
1283	fprintf(fp, "[menu:%s]\n", bar->name);	1409	fprintf(fp, "[menu:%s]\n", bar->name);
1284		1410
1285	if (bar->title != NULL)	1411	if (bar->title != NULL)
1286	fprintf(fp, "[title:%s]\n", bar->title);	1412	fprintf(fp, "[title:%s]\n", bar->title);
1287		1413
1288	for (i = 0; i < NARROWS; i++) {	1414	for (i = 0; i < NARROWS; i++)
		1415	{
1289	switch (bar->arrows[i].type) {	1416	switch (bar->arrows[i].type)
		1417	{
1290	case MenuTerminalAction:	1418	case MenuTerminalAction:
1291	case MenuAction:	1419	case MenuAction:
1292	fprintf(fp, "<%c>", Arrows[i].name);	1420	fprintf(fp, "<%c>", Arrows[i].name);
1293	rxvt_action_decode(fp, &(bar->arrows[i]));	1421	rxvt_action_decode(fp, &(bar->arrows[i]));
1294	break;	1422	break;
1295	}	1423	}
1296	}	1424	}
1297	fprintf(fp, "\n");	1425	fprintf(fp, "\n");
1298		1426
1299	for (menu = bar->head; menu != NULL; menu = menu->next)	1427	for (menu = bar->head; menu != NULL; menu = menu->next)
1300	rxvt_menu_dump(fp, menu);	1428	rxvt_menu_dump(fp, menu);
1301		1429
1302	fprintf(fp, "\n[done:%s]\n\n", bar->name);	1430	fprintf(fp, "\n[done:%s]\n\n", bar->name);
1303	bar = bar->prev;	1431	bar = bar->prev;
1304	}	1432	}
1305	while (bar != CurrentBar->prev);	1433	while (bar != CurrentBar->prev);
1306	}	1434	}
1307	#endif /* (MENUBAR_MAX > 1) */	1435	#endif /* (MENUBAR_MAX > 1) */
1308		1436
1309	/*	1437	/*
1310	* read in menubar commands from FILENAME	1438	* read in menubar commands from FILENAME
…		…
1322	* read `file' starting with [menu:tag]	1450	* read `file' starting with [menu:tag]
1323	*/	1451	*/
1324	void	1452	void
1325	rxvt_term::menubar_read (const char *filename)	1453	rxvt_term::menubar_read (const char *filename)
1326	{	1454	{
1327	/* read in a menu from a file */	1455	/* read in a menu from a file */
1328	FILE *fp;	1456	FILE *fp;
1329	char buffer[256];	1457	char buffer[256];
1330	char p, file, *tag = NULL;	1458	char p, file, *tag = NULL;
1331		1459
1332	file = (char *)rxvt_File_find(filename, ".menu", rs[Rs_path]);	1460	file = (char *)rxvt_File_find(filename, ".menu", rs[Rs_path]);
1333	if (file == NULL)	1461	if (file == NULL)
1334	return;	1462	return;
1335	fp = fopen(file, "rb");	1463	fp = fopen(file, "rb");
1336	free(file);	1464	free(file);
1337	if (fp == NULL)	1465	if (fp == NULL)
1338	return;	1466	return;
1339		1467
1340	#if (MENUBAR_MAX > 1)	1468	#if (MENUBAR_MAX > 1)
1341	/* semi-colon delimited */	1469	/* semi-colon delimited */
1342	if ((tag = STRCHR(filename, ';')) != NULL) {	1470	if ((tag = STRCHR(filename, ';')) != NULL)
1343	tag++;	1471	{
		1472	tag++;
1344	if (*tag == '\0')	1473	if (*tag == '\0')
1345	tag = NULL;	1474	tag = NULL;
1346	}	1475	}
1347	#endif /* (MENUBAR_MAX > 1) */	1476	#endif /* (MENUBAR_MAX > 1) */
1348	#ifdef DEBUG_MENU	1477	#ifdef DEBUG_MENU
1349	fprintf(stderr, "[read:%s]\n", p);	1478	fprintf(stderr, "[read:%s]\n", p);
1350	if (tag)	1479	if (tag)
1351	fprintf(stderr, "looking for [menu:%s]\n", tag);	1480	fprintf(stderr, "looking for [menu:%s]\n", tag);
1352	#endif	1481	#endif
1353		1482
1354	while ((p = fgets(buffer, sizeof(buffer), fp)) != NULL) {	1483	while ((p = fgets(buffer, sizeof(buffer), fp)) != NULL)
		1484	{
1355	int n;	1485	int n;
1356		1486
1357	if ((n = rxvt_Str_match(p, "[menu")) != 0) {	1487	if ((n = rxvt_Str_match(p, "[menu")) != 0)
1358	if (tag) {	1488	{
		1489	if (tag)
		1490	{
1359	/* looking for [menu:tag] */	1491	/* looking for [menu:tag] */
1360	if (p[n] == ':' && p[n + 1] != ']') {	1492	if (p[n] == ':' && p[n + 1] != ']')
1361	n++;	1493	{
		1494	n++;
1362	n += rxvt_Str_match(p + n, tag);	1495	n += rxvt_Str_match(p + n, tag);
1363	if (p[n] == ']') {	1496	if (p[n] == ']')
		1497	{
1364	#ifdef DEBUG_MENU	1498	#ifdef DEBUG_MENU
1365	fprintf(stderr, "[menu:%s]\n", tag);	1499	fprintf(stderr, "[menu:%s]\n", tag);
1366	#endif	1500	#endif
1367	break;	1501	break;
		1502	}
		1503	}
		1504	}
		1505	else if (p[n] == ':' \|\| p[n] == ']')
		1506	break;
		1507	}
1368	}	1508	}
1369	}
1370	} else if (p[n] == ':' \|\| p[n] == ']')
1371	break;
1372	}
1373	}
1374		1509
1375	/* found [menu], [menu:???] tag */	1510	/* found [menu], [menu:???] tag */
1376	while (p != NULL) {	1511	while (p != NULL)
		1512	{
1377	int n;	1513	int n;
1378		1514
1379	#ifdef DEBUG_MENU	1515	#ifdef DEBUG_MENU
1380	fprintf(stderr, "read line = %s\n", p);	1516	fprintf(stderr, "read line = %s\n", p);
1381	#endif	1517	#endif
1382		1518
1383	/* looking for [done:tag] or [done:] */	1519	/* looking for [done:tag] or [done:] */
1384	if ((n = rxvt_Str_match(p, "[done")) != 0) {	1520	if ((n = rxvt_Str_match(p, "[done")) != 0)
		1521	{
1385	if (p[n] == ']') {	1522	if (p[n] == ']')
1386	menu_readonly = 1;	1523	{
1387	break;
1388	} else if (p[n] == ':') {
1389	n++;
1390	if (p[n] == ']') {
1391	menu_readonly = 1;	1524	menu_readonly = 1;
1392	break;	1525	break;
1393	} else if (tag) {	1526	}
		1527	else if (p[n] == ':')
		1528	{
		1529	n++;
		1530	if (p[n] == ']')
		1531	{
		1532	menu_readonly = 1;
		1533	break;
		1534	}
		1535	else if (tag)
		1536	{
1394	n += rxvt_Str_match(p + n, tag);	1537	n += rxvt_Str_match(p + n, tag);
1395	if (p[n] == ']') {	1538	if (p[n] == ']')
		1539	{
1396	#ifdef DEBUG_MENU	1540	#ifdef DEBUG_MENU
1397	fprintf(stderr, "[done:%s]\n", tag);	1541	fprintf(stderr, "[done:%s]\n", tag);
1398	#endif	1542	#endif
1399	menu_readonly = 1;	1543	menu_readonly = 1;
1400	break;	1544	break;
1401	}	1545	}
1402	} else {	1546	}
		1547	else
		1548	{
1403	/* what? ... skip this line */	1549	/* what? ... skip this line */
1404	p[0] = COMMENT_CHAR;	1550	p[0] = COMMENT_CHAR;
1405	}	1551	}
1406	}	1552	}
1407	}	1553	}
1408	/*	1554	/*
1409	* remove leading/trailing space	1555	* remove leading/trailing space
1410	* and strip-off leading/trailing quotes	1556	* and strip-off leading/trailing quotes
1411	* skip blank or comment lines	1557	* skip blank or comment lines
1412	*/	1558	*/
1413	rxvt_Str_trim(p);	1559	rxvt_Str_trim(p);
1414	if (p && p != '#') {	1560	if (p && p != '#')
		1561	{
1415	menu_readonly = 0; /* if case we read another file */	1562	menu_readonly = 0; /* if case we read another file */
1416	menubar_dispatch (p);	1563	menubar_dispatch (p);
1417	}	1564	}
1418	/* get another line */	1565	/* get another line */
1419	p = fgets(buffer, sizeof(buffer), fp);	1566	p = fgets(buffer, sizeof(buffer), fp);
1420	}	1567	}
1421		1568
1422	fclose(fp);	1569	fclose(fp);
1423	}	1570	}
1424		1571
1425	/*	1572	/*
1426	* user interface for building/deleting and otherwise managing menus	1573	* user interface for building/deleting and otherwise managing menus
1427	*/	1574	*/
1428	void	1575	void
1429	rxvt_term::menubar_dispatch (char *str)	1576	rxvt_term::menubar_dispatch (char *str)
1430	{	1577	{
1431	int n, cmd;	1578	int n, cmd;
1432	char path, name, *name2;	1579	char path, name, *name2;
1433		1580
1434	if (menubar_visible(r) && ActiveMenu != NULL)	1581	if (menubar_visible(r) && ActiveMenu != NULL)
1435	menubar_expose ();	1582	menubar_expose ();
1436	else	1583	else
1437	ActiveMenu = NULL;	1584	ActiveMenu = NULL;
1438		1585
1439	cmd = *str;	1586	cmd = *str;
1440	switch (cmd) {	1587	switch (cmd)
		1588	{
1441	case '.':	1589	case '.':
1442	case '/': /* absolute & relative path */	1590	case '/': /* absolute & relative path */
1443	case MENUITEM_BEG: /* menuitem */	1591	case MENUITEM_BEG: /* menuitem */
1444	/* add `+' prefix for these cases */	1592	/* add `+' prefix for these cases */
1445	cmd = '+';	1593	cmd = '+';
1446	break;	1594	break;
1447		1595
1448	case '+':	1596	case '+':
1449	case '-':	1597	case '-':
1450	str++; /* skip cmd character */	1598	str++; /* skip cmd character */
1451	break;	1599	break;
1452		1600
1453	case '<':	1601	case '<':
1454	#if (MENUBAR_MAX > 1)	1602	#if (MENUBAR_MAX > 1)
1455	if (CurrentBar == NULL)	1603	if (CurrentBar == NULL)
1456	break;	1604	break;
1457	#endif /* (MENUBAR_MAX > 1) */	1605	#endif /* (MENUBAR_MAX > 1) */
1458	if (str[1] && str[2] == '>') /* arrow commands */	1606	if (str[1] && str[2] == '>') /* arrow commands */
1459	menuarrow_add (str);	1607	menuarrow_add (str);
1460	break;	1608	break;
1461		1609
1462	case '[': /* extended command */	1610	case '[': /* extended command */
1463	while (str[0] == '[') {	1611	while (str[0] == '[')
		1612	{
1464	char next = (++str); / skip leading '[' */	1613	char next = (++str); / skip leading '[' */
1465		1614
1466	if (str[0] == ':') { /* [:command:] */	1615	if (str[0] == ':')
1467	do {	1616	{ /* [:command:] */
1468	next++;	1617	do
		1618	{
		1619	next++;
		1620	if ((next = STRCHR(next, ':')) == NULL)
		1621	return; /* parse error */
		1622	}
		1623	while (next[1] != ']');
		1624	/* remove and skip ':]' */
		1625	*next = '\0';
		1626	next += 2;
		1627	}
		1628	else
		1629	{
1469	if ((next = STRCHR(next, ':')) == NULL)	1630	if ((next = STRCHR(next, ']')) == NULL)
1470	return; /* parse error */
1471	}
1472	while (next[1] != ']');
1473	/* remove and skip ':]' */
1474	*next = '\0';
1475	next += 2;
1476	} else {
1477	if ((next = STRCHR(next, ']')) == NULL)
1478	return; /* parse error */	1631	return; /* parse error */
1479	/* remove and skip ']' */	1632	/* remove and skip ']' */
1480	*next = '\0';	1633	*next = '\0';
1481	next++;	1634	next++;
1482	}	1635	}
1483		1636
1484	if (str[0] == ':') {	1637	if (str[0] == ':')
1485	int saved;	1638	{
		1639	int saved;
1486		1640
1487	/* try and dispatch it, regardless of read/write status */	1641	/* try and dispatch it, regardless of read/write status */
1488	saved = menu_readonly;	1642	saved = menu_readonly;
1489	menu_readonly = 0;	1643	menu_readonly = 0;
1490	menubar_dispatch (str + 1);	1644	menubar_dispatch (str + 1);
1491	menu_readonly = saved;	1645	menu_readonly = saved;
1492	}	1646	}
1493	/* these ones don't require menu stacking */	1647	/* these ones don't require menu stacking */
1494	else if (!STRCMP(str, "clear")) {	1648	else if (!STRCMP(str, "clear"))
1495	menubar_clear ();	1649	{
		1650	menubar_clear ();
		1651	}
1496	} else if (!STRCMP(str, "done") \|\| rxvt_Str_match(str, "done:")) {	1652	else if (!STRCMP(str, "done") \|\| rxvt_Str_match(str, "done:"))
1497	menu_readonly = 1;	1653	{
		1654	menu_readonly = 1;
		1655	}
1498	} else if (!STRCMP(str, "show")) {	1656	else if (!STRCMP(str, "show"))
1499	map_menuBar (1);	1657	{
1500	menu_readonly = 1;	1658	map_menuBar (1);
		1659	menu_readonly = 1;
		1660	}
1501	} else if (!STRCMP(str, "hide")) {	1661	else if (!STRCMP(str, "hide"))
1502	map_menuBar (0);	1662	{
1503	menu_readonly = 1;	1663	map_menuBar (0);
		1664	menu_readonly = 1;
		1665	}
1504	} else if ((n = rxvt_Str_match(str, "read:")) != 0) {	1666	else if ((n = rxvt_Str_match(str, "read:")) != 0)
		1667	{
1505	/* read in a menu from a file */	1668	/* read in a menu from a file */
1506	str += n;	1669	str += n;
1507	menubar_read (str);	1670	menubar_read (str);
		1671	}
1508	} else if ((n = rxvt_Str_match(str, "title:")) != 0) {	1672	else if ((n = rxvt_Str_match(str, "title:")) != 0)
1509	str += n;	1673	{
		1674	str += n;
1510	if (CurrentBar != NULL && !menu_readonly) {	1675	if (CurrentBar != NULL && !menu_readonly)
1511	if (*str) {	1676	{
1512	name = rxvt_realloc(CurrentBar->title,	1677	if (*str)
1513	STRLEN(str) + 1);	1678	{
1514	if (name != NULL) {	1679	name = rxvt_realloc(CurrentBar->title,
1515	STRCPY(name, str);	1680	STRLEN(str) + 1);
1516	CurrentBar->title = name;	1681	if (name != NULL)
1517	}	1682	{
1518	menubar_expose ();	1683	STRCPY(name, str);
1519	} else {	1684	CurrentBar->title = name;
1520	free(CurrentBar->title);	1685	}
1521	CurrentBar->title = NULL;	1686	menubar_expose ();
1522	}	1687	}
1523	}	1688	else
		1689	{
		1690	free(CurrentBar->title);
		1691	CurrentBar->title = NULL;
		1692	}
		1693	}
		1694	}
1524	} else if ((n = rxvt_Str_match(str, "pixmap:")) != 0) {	1695	else if ((n = rxvt_Str_match(str, "pixmap:")) != 0)
1525	str += n;	1696	{
		1697	str += n;
1526	xterm_seq (XTerm_Pixmap, str, CHAR_ST);	1698	xterm_seq (XTerm_Pixmap, str, CHAR_ST);
1527	}	1699	}
1528	#if (MENUBAR_MAX > 1)	1700	#if (MENUBAR_MAX > 1)
1529	else if ((n = rxvt_Str_match(str, "rm")) != 0) {	1701	else if ((n = rxvt_Str_match(str, "rm")) != 0)
1530	str += n;	1702	{
1531	switch (str[0]) {	1703	str += n;
1532	case ':':	1704	switch (str[0])
1533	str++;	1705	{
1534	/* FALLTHROUGH */	1706	case ':':
1535	case '\0':	1707	str++;
1536	/* FALLTHROUGH */	1708	/* FALLTHROUGH */
1537	case '*':	1709	case '\0':
1538	menubar_remove (str);	1710	/* FALLTHROUGH */
1539	break;	1711	case '*':
1540	}	1712	menubar_remove (str);
1541	menu_readonly = 1;	1713	break;
		1714	}
		1715	menu_readonly = 1;
		1716	}
1542	} else if ((n = rxvt_Str_match(str, "menu")) != 0) {	1717	else if ((n = rxvt_Str_match(str, "menu")) != 0)
1543	str += n;	1718	{
1544	switch (str[0]) {	1719	str += n;
1545	case ':':	1720	switch (str[0])
1546	str++;	1721	{
1547	/* add/access menuBar */	1722	case ':':
		1723	str++;
		1724	/* add/access menuBar */
1548	if (str != '\0' && str != '*')	1725	if (str != '\0' && str != '*')
1549	menubar_push (str);	1726	menubar_push (str);
1550	break;	1727	break;
1551	default:	1728	default:
1552	if (CurrentBar == NULL) {	1729	if (CurrentBar == NULL)
1553	menubar_push ("default");	1730	{
1554	}	1731	menubar_push ("default");
1555	}	1732	}
		1733	}
1556		1734
1557	if (CurrentBar != NULL)	1735	if (CurrentBar != NULL)
1558	menu_readonly = 0; /* allow menu build commands */	1736	menu_readonly = 0; /* allow menu build commands */
		1737	}
1559	} else if (!STRCMP(str, "dump")) {	1738	else if (!STRCMP(str, "dump"))
		1739	{
1560	/* dump current menubars to a file */	1740	/* dump current menubars to a file */
1561	FILE *fp;	1741	FILE *fp;
1562		1742
1563	/* enough space to hold the results */	1743	/* enough space to hold the results */
1564	char buffer[32];	1744	char buffer[32];
1565		1745
1566	sprintf(buffer, "/tmp/" APL_SUBCLASS "-%u",	1746	sprintf(buffer, "/tmp/" APL_SUBCLASS "-%u",
1567	(unsigned int)getpid());	1747	(unsigned int)getpid());
1568		1748
1569	if ((fp = fopen(buffer, "wb")) != NULL) {	1749	if ((fp = fopen(buffer, "wb")) != NULL)
		1750	{
1570	xterm_seq (XTerm_title, buffer, CHAR_ST);	1751	xterm_seq (XTerm_title, buffer, CHAR_ST);
1571	menubar_dump (fp);	1752	menubar_dump (fp);
1572	fclose(fp);	1753	fclose(fp);
1573	}	1754	}
		1755	}
1574	} else if (!STRCMP(str, "next")) {	1756	else if (!STRCMP(str, "next"))
1575	if (CurrentBar) {	1757	{
		1758	if (CurrentBar)
		1759	{
1576	CurrentBar = CurrentBar->next;	1760	CurrentBar = CurrentBar->next;
1577	menu_readonly = 1;	1761	menu_readonly = 1;
1578	}	1762	}
		1763	}
1579	} else if (!STRCMP(str, "prev")) {	1764	else if (!STRCMP(str, "prev"))
1580	if (CurrentBar) {	1765	{
		1766	if (CurrentBar)
		1767	{
1581	CurrentBar = CurrentBar->prev;	1768	CurrentBar = CurrentBar->prev;
1582	menu_readonly = 1;	1769	menu_readonly = 1;
1583	}	1770	}
		1771	}
1584	} else if (!STRCMP(str, "swap")) {	1772	else if (!STRCMP(str, "swap"))
1585	/* swap the top 2 menus */	1773	{
1586	if (CurrentBar) {	1774	/* swap the top 2 menus */
		1775	if (CurrentBar)
		1776	{
1587	bar_t *cbprev = CurrentBar->prev;	1777	bar_t *cbprev = CurrentBar->prev;
1588	bar_t *cbnext = CurrentBar->next;	1778	bar_t *cbnext = CurrentBar->next;
1589		1779
1590	cbprev->next = cbnext;	1780	cbprev->next = cbnext;
1591	cbnext->prev = cbprev;	1781	cbnext->prev = cbprev;
1592		1782
1593	CurrentBar->next = cbprev;	1783	CurrentBar->next = cbprev;
1594	CurrentBar->prev = cbprev->prev;	1784	CurrentBar->prev = cbprev->prev;
1595		1785
1596	cbprev->prev->next = CurrentBar;	1786	cbprev->prev->next = CurrentBar;
1597	cbprev->prev = CurrentBar;	1787	cbprev->prev = CurrentBar;
1598		1788
1599	CurrentBar = cbprev;	1789	CurrentBar = cbprev;
1600	menu_readonly = 1;	1790	menu_readonly = 1;
1601	}	1791	}
1602	}	1792	}
1603	#endif /* (MENUBAR_MAX > 1) */	1793	#endif /* (MENUBAR_MAX > 1) */
1604	str = next;	1794	str = next;
1605		1795
1606	BuildMenu = ActiveMenu = NULL;	1796	BuildMenu = ActiveMenu = NULL;
1607	menubar_expose ();	1797	menubar_expose ();
1608	#ifdef DEBUG_MENUBAR_STACKING	1798	#ifdef DEBUG_MENUBAR_STACKING
1609	fprintf(stderr, "menus are read%s\n",	1799	fprintf(stderr, "menus are read%s\n",
1610	menu_readonly ? "only" : "/write");	1800	menu_readonly ? "only" : "/write");
1611	#endif	1801	#endif
1612	}	1802
1613	return;	1803	}
1614	break;	1804	return;
		1805	break;
1615	}	1806	}
1616		1807
1617	#if (MENUBAR_MAX > 1)	1808	#if (MENUBAR_MAX > 1)
1618	if (CurrentBar == NULL)	1809	if (CurrentBar == NULL)
1619	return;	1810	return;
1620	if (menu_readonly) {	1811	if (menu_readonly)
		1812	{
1621	#ifdef DEBUG_MENUBAR_STACKING	1813	#ifdef DEBUG_MENUBAR_STACKING
1622	fprintf(stderr, "menus are read%s\n",	1814	fprintf(stderr, "menus are read%s\n",
1623	menu_readonly ? "only" : "/write");	1815	menu_readonly ? "only" : "/write");
1624	#endif	1816	#endif
1625	return;	1817	return;
1626	}	1818	}
1627	#endif /* (MENUBAR_MAX > 1) */	1819	#endif /* (MENUBAR_MAX > 1) */
1628		1820
1629	switch (cmd) {	1821	switch (cmd)
		1822	{
1630	case '+':	1823	case '+':
1631	case '-':	1824	case '-':
1632	path = name = str;	1825	path = name = str;
1633		1826
1634	name2 = NULL;	1827	name2 = NULL;
1635	/* parse STR, allow spaces inside (name) */	1828	/* parse STR, allow spaces inside (name) */
1636	if (path[0] != '\0') {	1829	if (path[0] != '\0')
		1830	{
1637	name = STRCHR(path, MENUITEM_BEG);	1831	name = STRCHR(path, MENUITEM_BEG);
1638	str = STRCHR(path, MENUITEM_END);	1832	str = STRCHR(path, MENUITEM_END);
1639	if (name != NULL \|\| str != NULL) {	1833	if (name != NULL \|\| str != NULL)
		1834	{
1640	if (name == NULL \|\| str == NULL \|\| str <= (name + 1)	1835	if (name == NULL \|\| str == NULL \|\| str <= (name + 1)
1641	\|\| (name > path && name[-1] != '/')) {	1836	\|\| (name > path && name[-1] != '/'))
		1837	{
1642	rxvt_print_error("menu error <%s>\n", path);	1838	rxvt_print_error("menu error <%s>\n", path);
1643	break;	1839	break;
1644	}	1840	}
1645	if (str[1] == MENUITEM_BEG) {	1841	if (str[1] == MENUITEM_BEG)
1646	name2 = (str + 2);	1842	{
		1843	name2 = (str + 2);
1647	str = STRCHR(name2, MENUITEM_END);	1844	str = STRCHR(name2, MENUITEM_END);
1648		1845
1649	if (str == NULL) {	1846	if (str == NULL)
		1847	{
1650	rxvt_print_error("menu error <%s>\n", path);	1848	rxvt_print_error("menu error <%s>\n", path);
1651	break;	1849	break;
1652	}	1850	}
1653	name2[-2] = '\0'; /* remove prev MENUITEM_END */	1851	name2[-2] = '\0'; /* remove prev MENUITEM_END */
1654	}	1852	}
1655	if (name > path && name[-1] == '/')	1853	if (name > path && name[-1] == '/')
1656	name[-1] = '\0';	1854	name[-1] = '\0';
1657		1855
1658	name++ = '\0'; / delimit */	1856	name++ = '\0'; / delimit */
1659	str++ = '\0'; / delimit */	1857	str++ = '\0'; / delimit */
1660		1858
1661	while (isspace(*str))	1859	while (isspace(*str))
1662	str++; /* skip space */	1860	str++; /* skip space */
1663	}	1861	}
1664	#ifdef DEBUG_MENU	1862	#ifdef DEBUG_MENU
1665	fprintf(stderr,	1863	fprintf(stderr,
1666	"`%c' path = <%s>, name = <%s>, name2 = <%s>, action = <%s>\n",	1864	"`%c' path = <%s>, name = <%s>, name2 = <%s>, action = <%s>\n",
1667	cmd, (path ? path : "(nil)"), (name ? name : "(nil)"),	1865	cmd, (path ? path : "(nil)"), (name ? name : "(nil)"),
1668	(name2 ? name2 : "(nil)"), (str ? str : "(nil)")	1866	(name2 ? name2 : "(nil)"), (str ? str : "(nil)")
1669	);	1867	);
1670	#endif	1868	#endif
1671	}	1869
		1870	}
1672	/* process the different commands */	1871	/* process the different commands */
1673	switch (cmd) {	1872	switch (cmd)
		1873	{
1674	case '+': /* add/replace existing menu or menuitem */	1874	case '+': /* add/replace existing menu or menuitem */
1675	if (path[0] != '\0') {	1875	if (path[0] != '\0')
1676	int len;	1876	{
		1877	int len;
1677		1878
1678	path = menu_find_base (&(BuildMenu), path);	1879	path = menu_find_base (&(BuildMenu), path);
1679	len = STRLEN(path);	1880	len = STRLEN(path);
1680		1881
1681	/* don't allow menus called `' /	1882	/* don't allow menus called `' /
1682	if (path[0] == '*') {	1883	if (path[0] == '*')
1683	menu_clear (BuildMenu);	1884	{
1684	break;	1885	menu_clear (BuildMenu);
		1886	break;
		1887	}
1685	} else if (len >= 2 && !STRCMP((path + len - 2), "/*")) {	1888	else if (len >= 2 && !STRCMP((path + len - 2), "/*"))
1686	path[len - 2] = '\0';	1889	{
1687	}	1890	path[len - 2] = '\0';
1688	if (path[0] != '\0')	1891	}
		1892	if (path[0] != '\0')
1689	BuildMenu = menu_add (BuildMenu, path);	1893	BuildMenu = menu_add (BuildMenu, path);
1690	}	1894	}
1691	if (name != NULL && name[0] != '\0')	1895	if (name != NULL && name[0] != '\0')
1692	rxvt_menuitem_add(BuildMenu,	1896	rxvt_menuitem_add(BuildMenu,
1693	(STRCMP(name, SEPARATOR_NAME) ? name : ""),	1897	(STRCMP(name, SEPARATOR_NAME) ? name : ""),
1694	name2, str);	1898	name2, str);
1695	break;	1899	break;
1696		1900
1697	case '-': /* delete menu entry */	1901	case '-': /* delete menu entry */
1698	if (!STRCMP(path, "/*") && (name == NULL \|\| name[0] == '\0')) {	1902	if (!STRCMP(path, "/*") && (name == NULL \|\| name[0] == '\0'))
1699	menubar_clear ();	1903	{
1700	BuildMenu = NULL;	1904	menubar_clear ();
1701	menubar_expose ();	1905	BuildMenu = NULL;
1702	break;	1906	menubar_expose ();
1703	} else if (path[0] != '\0') {	1907	break;
1704	int len;	1908	}
		1909	else if (path[0] != '\0')
		1910	{
		1911	int len;
1705	menu_t *menu = BuildMenu;	1912	menu_t *menu = BuildMenu;
1706		1913
1707	path = menu_find_base (&menu, path);	1914	path = menu_find_base (&menu, path);
1708	len = STRLEN(path);	1915	len = STRLEN(path);
1709		1916
1710	/* submenu called `' clears all menu items /	1917	/* submenu called `' clears all menu items /
1711	if (path[0] == '*') {	1918	if (path[0] == '*')
1712	menu_clear (menu);	1919	{
1713	break; /* done */	1920	menu_clear (menu);
		1921	break; /* done */
		1922	}
1714	} else if (len >= 2 && !STRCMP(&path[len - 2], "/*")) {	1923	else if (len >= 2 && !STRCMP(&path[len - 2], "/*"))
1715	/* done */	1924	{
1716	break;	1925	/* done */
1717	} else if (path[0] != '\0') {	1926	break;
1718	BuildMenu = NULL;	1927	}
1719	break;	1928	else if (path[0] != '\0')
1720	} else	1929	{
1721	BuildMenu = menu;	1930	BuildMenu = NULL;
1722	}	1931	break;
		1932	}
		1933	else
		1934	BuildMenu = menu;
		1935	}
1723	if (BuildMenu != NULL) {	1936	if (BuildMenu != NULL)
		1937	{
1724	if (name == NULL \|\| name[0] == '\0')	1938	if (name == NULL \|\| name[0] == '\0')
1725	BuildMenu = menu_delete (BuildMenu);	1939	BuildMenu = menu_delete (BuildMenu);
1726	else {	1940	else
1727	const char *n1;	1941	{
1728	menuitem_t *item;	1942	const char *n1;
		1943	menuitem_t *item;
1729	menu_t *BuildMenu = BuildMenu;	1944	menu_t *BuildMenu = BuildMenu;
1730		1945
1731	n1 = STRCMP(name, SEPARATOR_NAME) ? name : "";	1946	n1 = STRCMP(name, SEPARATOR_NAME) ? name : "";
1732	item = rxvt_menuitem_find(BuildMenu, n1);	1947	item = rxvt_menuitem_find(BuildMenu, n1);
1733	if (item != NULL && item->entry.type != MenuSubMenu) {	1948	if (item != NULL && item->entry.type != MenuSubMenu)
1734	menuitem_free (BuildMenu, item);	1949	{
		1950	menuitem_free (BuildMenu, item);
1735		1951
1736	/* fix up the width */	1952	/* fix up the width */
1737	BuildMenu->width = 0;	1953	BuildMenu->width = 0;
1738	for (item = BuildMenu->head; item != NULL;	1954	for (item = BuildMenu->head; item != NULL;
1739	item = item->next) {	1955	item = item->next)
		1956	{
1740	short l = item->len + item->len2;	1957	short l = item->len + item->len2;
1741		1958
1742	MAX_IT(BuildMenu->width, l);	1959	MAX_IT(BuildMenu->width, l);
1743	}	1960	}
1744	}	1961	}
1745	}	1962	}
1746	menubar_expose ();	1963	menubar_expose ();
1747	}	1964	}
		1965	break;
		1966	}
1748	break;	1967	break;
1749	}
1750	break;
1751	}	1968	}
1752	}	1969	}
1753		1970
1754	void	1971	void
1755	rxvt_term::draw_Arrows (int name, int state)	1972	rxvt_term::draw_Arrows (int name, int state)
1756	{	1973	{
1757	GC top, bot;	1974	GC top, bot;
1758		1975
1759	int i;	1976	int i;
1760		1977
1761	#ifdef MENU_SHADOW_IN	1978	#ifdef MENU_SHADOW_IN
1762	state = -state;	1979	state = -state;
1763	#endif	1980	#endif
1764	switch (state) {	1981	switch (state)
		1982	{
1765	case +1:	1983	case +1:
1766	top = topShadowGC;	1984	top = topShadowGC;
1767	bot = botShadowGC;	1985	bot = botShadowGC;
1768	break; /* SHADOW_OUT */	1986	break; /* SHADOW_OUT */
1769	case -1:	1987	case -1:
1770	top = botShadowGC;	1988	top = botShadowGC;
1771	bot = topShadowGC;	1989	bot = topShadowGC;
1772	break; /* SHADOW_IN */	1990	break; /* SHADOW_IN */
1773	default:	1991	default:
1774	top = bot = scrollbarGC;	1992	top = bot = scrollbarGC;
1775	break; /* neutral */	1993	break; /* neutral */
1776	}	1994	}
1777		1995
1778	if (!Arrows_x)	1996	if (!Arrows_x)
1779	return;	1997	return;
1780		1998
1781	for (i = 0; i < NARROWS; i++) {	1999	for (i = 0; i < NARROWS; i++)
		2000	{
1782	const int w = Width2Pixel(1);	2001	const int w = Width2Pixel(1);
1783	const int y = (menuBar_TotalHeight() - w) / 2;	2002	const int y = (menuBar_TotalHeight() - w) / 2;
1784	int x = Arrows_x + (5 * Width2Pixel(i)) / 4;	2003	int x = Arrows_x + (5 * Width2Pixel(i)) / 4;
1785		2004
1786	if (!name \|\| name == Arrows[i].name)	2005	if (!name \|\| name == Arrows[i].name)
1787	rxvt_Draw_Triangle(Xdisplay, menuBar.win, top, bot, x, y, w,	2006	rxvt_Draw_Triangle(Xdisplay, menuBar.win, top, bot, x, y, w,
1788	Arrows[i].name);	2007	Arrows[i].name);
1789	}	2008	}
1790	XFlush(Xdisplay);	2009	XFlush(Xdisplay);
1791	}	2010	}
1792		2011
1793	void	2012	void
1794	rxvt_term::menubar_expose ()	2013	rxvt_term::menubar_expose ()
1795	{	2014	{
1796	menu_t *menu;	2015	menu_t *menu;
1797	int x;	2016	int x;
1798		2017
1799	if (!menubar_visible(r) \|\| menuBar.win == 0)	2018	if (!menubar_visible(r) \|\| menuBar.win == 0)
1800	return;	2019	return;
1801		2020
1802	if (menubarGC == None) {	2021	if (menubarGC == None)
		2022	{
1803	/* Create the graphics context */	2023	/* Create the graphics context */
1804	XGCValues gcvalue;	2024	XGCValues gcvalue;
1805		2025
1806	gcvalue.font = TermWin.font->fid;	2026	gcvalue.font = TermWin.font->fid;
1807		2027
1808	gcvalue.foreground = (XDEPTH <= 2 ? PixColors[Color_fg]	2028	gcvalue.foreground = (XDEPTH <= 2 ? PixColors[Color_fg]
1809	: PixColors[Color_Black]);	2029	: PixColors[Color_Black]);
1810	menubarGC = XCreateGC(Xdisplay, menuBar.win,	2030	menubarGC = XCreateGC(Xdisplay, menuBar.win,
1811	GCForeground \| GCFont, &gcvalue);	2031	GCForeground \| GCFont, &gcvalue);
1812		2032
1813	}	2033	}
1814	/* make sure the font is correct */	2034	/* make sure the font is correct */
1815	XSetFont(Xdisplay, menubarGC, TermWin.font->fid);	2035	XSetFont(Xdisplay, menubarGC, TermWin.font->fid);
1816	XSetFont(Xdisplay, botShadowGC, TermWin.font->fid);	2036	XSetFont(Xdisplay, botShadowGC, TermWin.font->fid);
1817	XClearWindow(Xdisplay, menuBar.win);	2037	XClearWindow(Xdisplay, menuBar.win);
1818		2038
1819	menu_hide_all ();	2039	menu_hide_all ();
1820		2040
1821	x = 0;	2041	x = 0;
1822	if (CurrentBar != NULL) {	2042	if (CurrentBar != NULL)
		2043	{
1823	for (menu = CurrentBar->head; menu != NULL; menu = menu->next) {	2044	for (menu = CurrentBar->head; menu != NULL; menu = menu->next)
		2045	{
1824	int len = menu->len;	2046	int len = menu->len;
1825		2047
1826	x = (menu->x + menu->len + HSPACE);	2048	x = (menu->x + menu->len + HSPACE);
1827		2049
1828	#ifdef DEBUG_MENU_LAYOUT	2050	#ifdef DEBUG_MENU_LAYOUT
1829	rxvt_print_menu_descendants(menu);	2051	rxvt_print_menu_descendants(menu);
1830	#endif	2052	#endif
1831		2053
1832	if (x >= TermWin.ncol)	2054	if (x >= TermWin.ncol)
1833	len = (TermWin.ncol - (menu->x + HSPACE));	2055	len = (TermWin.ncol - (menu->x + HSPACE));
1834		2056
1835	drawbox_menubar (menu->x, len, +1);	2057	drawbox_menubar (menu->x, len, +1);
1836	#ifdef USE_XIM	2058	#ifdef USE_XIM
1837	if (TermWin.fontset)	2059	if (TermWin.fontset)
1838	XmbDrawString(Xdisplay,	2060	XmbDrawString(Xdisplay,
1839	menuBar.win, TermWin.fontset,	2061	menuBar.win, TermWin.fontset,
1840	menubarGC,	2062	menubarGC,
1841	(Width2Pixel(menu->x) + Width2Pixel(HSPACE) / 2),	2063	(Width2Pixel(menu->x) + Width2Pixel(HSPACE) / 2),
1842	menuBar_height() - SHADOW, menu->name, len);	2064	menuBar_height() - SHADOW, menu->name, len);
1843	else	2065	else
1844	#endif	2066	#endif
1845	XDrawString(Xdisplay, menuBar.win, menubarGC,	2067	XDrawString(Xdisplay, menuBar.win, menubarGC,
1846	(Width2Pixel(menu->x) + Width2Pixel(HSPACE) / 2),	2068	(Width2Pixel(menu->x) + Width2Pixel(HSPACE) / 2),
1847	menuBar_height() - SHADOW, menu->name, len);	2069	menuBar_height() - SHADOW, menu->name, len);
1848		2070
1849	if (x >= TermWin.ncol)	2071	if (x >= TermWin.ncol)
1850	break;	2072	break;
1851	}	2073	}
1852	}	2074	}
1853	drawbox_menubar (x, TermWin.ncol, (CurrentBar ? +1 : -1));	2075	drawbox_menubar (x, TermWin.ncol, (CurrentBar ? +1 : -1));
1854		2076
1855	/* add the menuBar title, if it exists and there's plenty of room */	2077	/* add the menuBar title, if it exists and there's plenty of room */
1856	Arrows_x = 0;	2078	Arrows_x = 0;
1857	if (x < TermWin.ncol) {	2079	if (x < TermWin.ncol)
		2080	{
1858	const char *str;	2081	const char *str;
1859	int ncol;	2082	int ncol;
1860	unsigned int len;	2083	unsigned int len;
1861	char title[256];	2084	char title[256];
1862		2085
1863	ncol = (int)TermWin.ncol;	2086	ncol = (int)TermWin.ncol;
1864	if (x < (ncol - (NARROWS + 1))) {	2087	if (x < (ncol - (NARROWS + 1)))
		2088	{
1865	ncol -= (NARROWS + 1);	2089	ncol -= (NARROWS + 1);
1866	Arrows_x = Width2Pixel(ncol);	2090	Arrows_x = Width2Pixel(ncol);
1867	}	2091	}
1868	draw_Arrows (0, +1);	2092	draw_Arrows (0, +1);
1869		2093
1870	str = (CurrentBar	2094	str = (CurrentBar
1871	&& CurrentBar->title) ? CurrentBar->title : "%n-%v";	2095	&& CurrentBar->title) ? CurrentBar->title : "%n-%v";
1872	for (len = 0; str[0] && len < sizeof(title) - 1; str++) {	2096	for (len = 0; str[0] && len < sizeof(title) - 1; str++)
		2097	{
1873	const char *s = NULL;	2098	const char *s = NULL;
1874		2099
1875	switch (str[0]) {	2100	switch (str[0])
1876	case '%':	2101	{
1877	str++;	2102	case '%':
1878	switch (str[0]) {	2103	str++;
1879	case 'n':	2104	switch (str[0])
1880	s = rs[Rs_name];	2105	{
		2106	case 'n':
		2107	s = rs[Rs_name];
1881	break; /* resource name */	2108	break; /* resource name */
1882	case 'v':	2109	case 'v':
1883	s = VERSION;	2110	s = VERSION;
1884	break; /* version number */	2111	break; /* version number */
1885	case '%':	2112	case '%':
1886	s = "%";	2113	s = "%";
1887	break; /* literal '%' */	2114	break; /* literal '%' */
1888	}	2115	}
1889	if (s != NULL)	2116	if (s != NULL)
1890	while (*s && len < sizeof(title) - 1)	2117	while (*s && len < sizeof(title) - 1)
1891	title[len++] = *s++;	2118	title[len++] = *s++;
1892	break;	2119	break;
1893		2120
1894	default:	2121	default:
1895	title[len++] = str[0];	2122	title[len++] = str[0];
1896	break;	2123	break;
1897	}	2124	}
1898	}	2125	}
1899	title[len] = '\0';	2126	title[len] = '\0';
1900		2127
1901	ncol -= (x + len + HSPACE);	2128	ncol -= (x + len + HSPACE);
1902	if (len > 0 && ncol >= 0) {	2129	if (len > 0 && ncol >= 0)
		2130	{
1903	#ifdef USE_XIM	2131	#ifdef USE_XIM
1904	if (TermWin.fontset)	2132	if (TermWin.fontset)
1905	XmbDrawString(Xdisplay,	2133	XmbDrawString(Xdisplay,
1906	menuBar.win, TermWin.fontset,	2134	menuBar.win, TermWin.fontset,
1907	menubarGC,	2135	menubarGC,
1908	Width2Pixel(x) + Width2Pixel(ncol + HSPACE) / 2,	2136	Width2Pixel(x) + Width2Pixel(ncol + HSPACE) / 2,
1909	menuBar_height() - SHADOW, title, len);	2137	menuBar_height() - SHADOW, title, len);
1910	else	2138	else
1911	#endif	2139	#endif
1912	XDrawString(Xdisplay, menuBar.win, menubarGC,	2140	XDrawString(Xdisplay, menuBar.win, menubarGC,
1913	Width2Pixel(x) + Width2Pixel(ncol + HSPACE) / 2,	2141	Width2Pixel(x) + Width2Pixel(ncol + HSPACE) / 2,
1914	menuBar_height() - SHADOW, title, len);	2142	menuBar_height() - SHADOW, title, len);
1915	}	2143	}
1916	}	2144	}
1917	}	2145	}
1918		2146
1919	int	2147	int
1920	rxvt_term::menubar_mapping (int map)	2148	rxvt_term::menubar_mapping (int map)
1921	{	2149	{
1922	int change = 0;	2150	int change = 0;
1923		2151
1924	if (map && !menubar_visible(r)) {	2152	if (map && !menubar_visible(r))
		2153	{
1925	menuBar.state = 1;	2154	menuBar.state = 1;
1926	if (menuBar.win == 0)	2155	if (menuBar.win == 0)
1927	return 0;	2156	return 0;
1928	XMapWindow(Xdisplay, menuBar.win);	2157	XMapWindow(Xdisplay, menuBar.win);
1929	change = 1;	2158	change = 1;
		2159	}
1930	} else if (!map && menubar_visible(r)) {	2160	else if (!map && menubar_visible(r))
		2161	{
1931	menubar_expose ();	2162	menubar_expose ();
1932	menuBar.state = 0;	2163	menuBar.state = 0;
1933	XUnmapWindow(Xdisplay, menuBar.win);	2164	XUnmapWindow(Xdisplay, menuBar.win);
1934	change = 1;	2165	change = 1;
		2166	}
1935	} else	2167	else
1936	menubar_expose ();	2168	menubar_expose ();
1937		2169
1938	return change;	2170	return change;
1939	}	2171	}
1940		2172
1941	int	2173	int
1942	rxvt_term::menu_select (XButtonEvent *ev)	2174	rxvt_term::menu_select (XButtonEvent *ev)
1943	{	2175	{
1944	menuitem_t thisitem, item = NULL;	2176	menuitem_t thisitem, item = NULL;
1945	int this_y, y;	2177	int this_y, y;
1946	menu_t *ActiveMenu = ActiveMenu;	2178	menu_t *ActiveMenu = ActiveMenu;
1947		2179
1948	Window unused_root, unused_child;	2180	Window unused_root, unused_child;
1949	int unused_root_x, unused_root_y;	2181	int unused_root_x, unused_root_y;
1950	unsigned int unused_mask;	2182	unsigned int unused_mask;
1951		2183
1952	if (ActiveMenu == NULL)	2184	if (ActiveMenu == NULL)
1953	return 0;	2185	return 0;
1954		2186
1955	XQueryPointer(Xdisplay, ActiveMenu->win,	2187	XQueryPointer(Xdisplay, ActiveMenu->win,
1956	&unused_root, &unused_child,	2188	&unused_root, &unused_child,
1957	&unused_root_x, &unused_root_y,	2189	&unused_root_x, &unused_root_y,
1958	&(ev->x), &(ev->y), &unused_mask);	2190	&(ev->x), &(ev->y), &unused_mask);
1959		2191
1960	if (ActiveMenu->parent != NULL && (ev->x < 0 \|\| ev->y < 0)) {	2192	if (ActiveMenu->parent != NULL && (ev->x < 0 \|\| ev->y < 0))
1961	menu_hide ();
1962	return 1;
1963	}	2193	{
		2194	menu_hide ();
		2195	return 1;
		2196	}
1964	/* determine the menu item corresponding to the Y index */	2197	/* determine the menu item corresponding to the Y index */
1965	y = SHADOW;	2198	y = SHADOW;
1966	if (ev->x >= 0 && ev->x <= (ActiveMenu->w - SHADOW)) {	2199	if (ev->x >= 0 && ev->x <= (ActiveMenu->w - SHADOW))
		2200	{
1967	for (item = ActiveMenu->head; item != NULL; item = item->next) {	2201	for (item = ActiveMenu->head; item != NULL; item = item->next)
		2202	{
1968	int h = HEIGHT_TEXT + 2 * SHADOW;	2203	int h = HEIGHT_TEXT + 2 * SHADOW;
1969		2204
1970	if (isSeparator(item->name))	2205	if (isSeparator(item->name))
1971	h = HEIGHT_SEPARATOR;	2206	h = HEIGHT_SEPARATOR;
1972	else if (ev->y >= y && ev->y < (y + h))	2207	else if (ev->y >= y && ev->y < (y + h))
1973	break;	2208	break;
1974	y += h;	2209	y += h;
1975	}	2210	}
1976	}	2211	}
1977	if (item == NULL && ev->type == ButtonRelease) {	2212	if (item == NULL && ev->type == ButtonRelease)
		2213	{
1978	menu_hide_all ();	2214	menu_hide_all ();
1979	return 0;	2215	return 0;
1980	}	2216	}
1981	thisitem = item;	2217	thisitem = item;
1982	this_y = y - SHADOW;	2218	this_y = y - SHADOW;
1983		2219
1984	/* erase the last item */	2220	/* erase the last item */
1985	if (ActiveMenu->item != NULL) {	2221	if (ActiveMenu->item != NULL)
		2222	{
1986	if (ActiveMenu->item != thisitem) {	2223	if (ActiveMenu->item != thisitem)
		2224	{
1987	for (y = 0, item = ActiveMenu->head; item != NULL;	2225	for (y = 0, item = ActiveMenu->head; item != NULL;
1988	item = item->next) {	2226	item = item->next)
1989	int h;	2227	{
		2228	int h;
1990		2229
1991	if (isSeparator(item->name))	2230	if (isSeparator(item->name))
1992	h = HEIGHT_SEPARATOR;	2231	h = HEIGHT_SEPARATOR;
1993	else if (item == ActiveMenu->item) {	2232	else if (item == ActiveMenu->item)
		2233	{
1994	/* erase old menuitem */	2234	/* erase old menuitem */
1995	drawbox_menuitem (y, 0); /* No Shadow */	2235	drawbox_menuitem (y, 0); /* No Shadow */
1996	if (item->entry.type == MenuSubMenu)	2236	if (item->entry.type == MenuSubMenu)
1997	drawtriangle (ActiveMenu->w, y, +1);	2237	drawtriangle (ActiveMenu->w, y, +1);
1998	break;	2238	break;
1999	} else	2239	}
		2240	else
2000	h = HEIGHT_TEXT + 2 * SHADOW;	2241	h = HEIGHT_TEXT + 2 * SHADOW;
2001	y += h;	2242	y += h;
2002	}	2243	}
2003	} else {	2244	}
		2245	else
		2246	{
2004	switch (ev->type) {	2247	switch (ev->type)
		2248	{
2005	case ButtonRelease:	2249	case ButtonRelease:
2006	switch (item->entry.type) {	2250	switch (item->entry.type)
2007	case MenuLabel:	2251	{
2008	case MenuSubMenu:	2252	case MenuLabel:
2009	menu_hide_all ();	2253	case MenuSubMenu:
2010	break;	2254	menu_hide_all ();
		2255	break;
2011		2256
2012	case MenuAction:	2257	case MenuAction:
2013	case MenuTerminalAction:	2258	case MenuTerminalAction:
2014	drawbox_menuitem (_y, -1);	2259	drawbox_menuitem (_y, -1);
2015	{	2260	{
2016	#ifdef HAVE_NANOSLEEP	2261	#ifdef HAVE_NANOSLEEP
2017	struct timespec rqt;	2262	struct timespec rqt;
2018		2263
2019	rqt.tv_sec = 0;	2264	rqt.tv_sec = 0;
2020	rqt.tv_nsec = MENU_DELAY_USEC * 1000;	2265	rqt.tv_nsec = MENU_DELAY_USEC * 1000;
2021	nanosleep(&rqt, NULL);	2266	nanosleep(&rqt, NULL);
2022	#else	2267	#else
2023	/* use select for timing */	2268	/* use select for timing */
2024	struct timeval tv;	2269	struct timeval tv;
2025		2270
2026	tv.tv_sec = 0;	2271	tv.tv_sec = 0;
2027	tv.tv_usec = MENU_DELAY_USEC;	2272	tv.tv_usec = MENU_DELAY_USEC;
2028	select(0, NULL, NULL, NULL, &tv);	2273	select(0, NULL, NULL, NULL, &tv);
2029	#endif	2274	#endif
2030	}	2275
		2276	}
2031	/* remove menu before sending keys to the application */	2277	/* remove menu before sending keys to the application */
2032	menu_hide_all ();	2278	menu_hide_all ();
2033	#ifndef DEBUG_MENU	2279	#ifndef DEBUG_MENU
2034	action_dispatch (&(item->entry.action));	2280	action_dispatch (&(item->entry.action));
2035	#else /* DEBUG_MENU */	2281	#else /* DEBUG_MENU */
2036	fprintf(stderr, "%s: %s\n", item->name,	2282	fprintf(stderr, "%s: %s\n", item->name,
2037	item->entry.action.str);	2283	item->entry.action.str);
2038	#endif /* DEBUG_MENU */	2284	#endif /* DEBUG_MENU */
2039	break;	2285	break;
2040	}	2286	}
2041	break;	2287	break;
2042		2288
2043	default:	2289	default:
2044	if (item->entry.type == MenuSubMenu)	2290	if (item->entry.type == MenuSubMenu)
2045	goto DoMenu;	2291	goto DoMenu;
2046	break;	2292	break;
		2293	}
		2294	return 0;
		2295	}
2047	}	2296	}
2048	return 0;
2049	}
2050	}
2051	DoMenu:	2297	DoMenu:
2052	ActiveMenu->item = thisitem;	2298	ActiveMenu->item = thisitem;
2053	y = this_y;	2299	y = this_y;
2054	if (item != NULL) {	2300	if (item != NULL)
		2301	{
2055	item = ActiveMenu->item;	2302	item = ActiveMenu->item;
2056	if (item->entry.type != MenuLabel)	2303	if (item->entry.type != MenuLabel)
2057	drawbox_menuitem (y, +1);	2304	drawbox_menuitem (y, +1);
2058	if (item->entry.type == MenuSubMenu) {	2305	if (item->entry.type == MenuSubMenu)
		2306	{
2059	int x;	2307	int x;
2060		2308
2061	drawtriangle (ActiveMenu->w, y, -1);	2309	drawtriangle (ActiveMenu->w, y, -1);
2062		2310
2063	x = ev->x + (ActiveMenu->parent	2311	x = ev->x + (ActiveMenu->parent
2064	? ActiveMenu->x	2312	? ActiveMenu->x
2065	: Width2Pixel(ActiveMenu->x));	2313	: Width2Pixel(ActiveMenu->x));
2066		2314
2067	if (x >= item->entry.submenu.menu->x) {	2315	if (x >= item->entry.submenu.menu->x)
		2316	{
2068	ActiveMenu = item->entry.submenu.menu;	2317	ActiveMenu = item->entry.submenu.menu;
2069	menu_show ();	2318	menu_show ();
2070	return 1;	2319	return 1;
		2320	}
		2321	}
2071	}	2322	}
2072	}
2073	}
2074	return 0;	2323	return 0;
2075	}	2324	}
2076		2325
2077	void	2326	void
2078	rxvt_term::menubar_select (XButtonEvent *ev)	2327	rxvt_term::menubar_select (XButtonEvent *ev)
2079	{	2328	{
2080	menu_t *menu = NULL;	2329	menu_t *menu = NULL;
2081		2330
2082	/* determine the pulldown menu corresponding to the X index */	2331	/* determine the pulldown menu corresponding to the X index */
2083	if (ev->y >= 0 && ev->y <= menuBar_height() && CurrentBar != NULL) {	2332	if (ev->y >= 0 && ev->y <= menuBar_height() && CurrentBar != NULL)
		2333	{
2084	for (menu = CurrentBar->head; menu != NULL; menu = menu->next) {	2334	for (menu = CurrentBar->head; menu != NULL; menu = menu->next)
		2335	{
2085	int x = Width2Pixel(menu->x);	2336	int x = Width2Pixel(menu->x);
2086	int w = Width2Pixel(menu->len + HSPACE);	2337	int w = Width2Pixel(menu->len + HSPACE);
2087		2338
2088	if ((ev->x >= x && ev->x < x + w))	2339	if ((ev->x >= x && ev->x < x + w))
2089	break;	2340	break;
2090	}	2341	}
2091	}	2342	}
2092	switch (ev->type) {	2343	switch (ev->type)
		2344	{
2093	case ButtonRelease:	2345	case ButtonRelease:
2094	menu_hide_all ();	2346	menu_hide_all ();
2095	break;	2347	break;
2096		2348
2097	case ButtonPress:	2349	case ButtonPress:
2098	if (menu == NULL && Arrows_x && ev->x >= Arrows_x) {	2350	if (menu == NULL && Arrows_x && ev->x >= Arrows_x)
		2351	{
2099	int i;	2352	int i;
2100		2353
2101	for (i = 0; i < NARROWS; i++) {	2354	for (i = 0; i < NARROWS; i++)
		2355	{
2102	if (ev->x >= (Arrows_x + (Width2Pixel(4 * i + i)) / 4)	2356	if (ev->x >= (Arrows_x + (Width2Pixel(4 * i + i)) / 4)
2103	&& ev->x < (Arrows_x	2357	&& ev->x < (Arrows_x
2104	+ (Width2Pixel(4 * i + i + 4)) / 4)) {	2358	+ (Width2Pixel(4 * i + i + 4)) / 4))
		2359	{
2105	draw_Arrows (Arrows[i].name, -1);	2360	draw_Arrows (Arrows[i].name, -1);
2106	{	2361	{
2107	#ifdef HAVE_NANOSLEEP	2362	#ifdef HAVE_NANOSLEEP
2108	struct timespec rqt;	2363	struct timespec rqt;
2109		2364
2110	rqt.tv_sec = 0;	2365	rqt.tv_sec = 0;
2111	rqt.tv_nsec = MENU_DELAY_USEC * 1000;	2366	rqt.tv_nsec = MENU_DELAY_USEC * 1000;
2112	nanosleep(&rqt, NULL);	2367	nanosleep(&rqt, NULL);
2113	#else	2368	#else
2114	/* use select for timing */	2369	/* use select for timing */
2115	struct timeval tv;	2370	struct timeval tv;
2116		2371
2117	tv.tv_sec = 0;	2372	tv.tv_sec = 0;
2118	tv.tv_usec = MENU_DELAY_USEC;	2373	tv.tv_usec = MENU_DELAY_USEC;
2119	select(0, NULL, NULL, NULL, &tv);	2374	select(0, NULL, NULL, NULL, &tv);
2120	#endif	2375	#endif
2121	}	2376
		2377	}
2122	draw_Arrows (Arrows[i].name, +1);	2378	draw_Arrows (Arrows[i].name, +1);
2123	#ifdef DEBUG_MENUARROWS	2379	#ifdef DEBUG_MENUARROWS
2124	fprintf(stderr, "'%c': ", Arrows[i].name);	2380	fprintf(stderr, "'%c': ", Arrows[i].name);
2125		2381
2126	if (CurrentBar == NULL	2382	if (CurrentBar == NULL
2127	\|\| (CurrentBar->arrows[i].type != MenuAction	2383	\|\| (CurrentBar->arrows[i].type != MenuAction
2128	&& CurrentBar->arrows[i].type !=	2384	&& CurrentBar->arrows[i].type !=
2129	MenuTerminalAction)) {	2385	MenuTerminalAction))
		2386	{
2130	if (Arrows[i].str != NULL && Arrows[i].str[0])	2387	if (Arrows[i].str != NULL && Arrows[i].str[0])
2131	fprintf(stderr, "(default) \\033%s\n",	2388	fprintf(stderr, "(default) \\033%s\n",
2132	&(Arrows[i].str[2]));	2389	&(Arrows[i].str[2]));
2133	} else {	2390	}
2134	fprintf(stderr, "%s\n",	2391	else
2135	CurrentBar->arrows[i].str);	2392	{
2136	}	2393	fprintf(stderr, "%s\n",
		2394	CurrentBar->arrows[i].str);
		2395	}
2137	#else /* DEBUG_MENUARROWS */	2396	#else /* DEBUG_MENUARROWS */
2138	if (CurrentBar == NULL	2397	if (CurrentBar == NULL
2139	\|\| rxvt_action_dispatch(r,	2398	\|\| rxvt_action_dispatch(r,
2140	&(CurrentBar->arrows[i]))	2399	&(CurrentBar->arrows[i]))
2141	) {	2400	)
		2401	{
2142	if (Arrows[i].str != NULL && Arrows[i].str[0] != 0)	2402	if (Arrows[i].str != NULL && Arrows[i].str[0] != 0)
2143	tt_write ((Arrows[i].str + 1),	2403	tt_write ((Arrows[i].str + 1),
2144	Arrows[i].str[0]);	2404	Arrows[i].str[0]);
2145	}	2405	}
2146	#endif /* DEBUG_MENUARROWS */	2406	#endif /* DEBUG_MENUARROWS */
2147	return;	2407	return;
2148	}	2408	}
2149	}	2409	}
2150	}	2410	}
2151	/* FALLTHROUGH */	2411	/* FALLTHROUGH */
2152		2412
2153	default:	2413	default:
2154	/*	2414	/*
2155	* press menubar or move to a new entry	2415	* press menubar or move to a new entry
2156	*/	2416	*/
2157	if (menu != NULL && menu != ActiveMenu) {	2417	if (menu != NULL && menu != ActiveMenu)
		2418	{
2158	menu_hide_all (); /* pop down old menu */	2419	menu_hide_all (); /* pop down old menu */
2159	ActiveMenu = menu;	2420	ActiveMenu = menu;
2160	menu_show (); /* pop up new menu */	2421	menu_show (); /* pop up new menu */
2161	}	2422	}
2162	break;	2423	break;
2163	}	2424	}
2164	}	2425	}
2165		2426
2166	/*	2427	/*
2167	* general dispatch routine,	2428	* general dispatch routine,
2168	* it would be nice to have `sticky' menus	2429	* it would be nice to have `sticky' menus
2169	*/	2430	*/
2170	void	2431	void
2171	rxvt_term::menubar_control (XButtonEvent *ev)	2432	rxvt_term::menubar_control (XButtonEvent *ev)
2172	{	2433	{
2173	switch (ev->type) {	2434	switch (ev->type)
		2435	{
2174	case ButtonPress:	2436	case ButtonPress:
2175	if (ev->button == Button1)	2437	if (ev->button == Button1)
2176	menubar_select (ev);	2438	menubar_select (ev);
2177	break;	2439	break;
2178		2440
2179	case ButtonRelease:	2441	case ButtonRelease:
2180	if (ev->button == Button1)	2442	if (ev->button == Button1)
2181	menu_select (ev);	2443	menu_select (ev);
2182	break;	2444	break;
2183		2445
2184	case MotionNotify:	2446	case MotionNotify:
2185	while (XCheckTypedWindowEvent(Xdisplay, TermWin.parent[0],	2447	while (XCheckTypedWindowEvent(Xdisplay, TermWin.parent[0],
2186	MotionNotify, (XEvent *) ev)) ;	2448	MotionNotify, (XEvent *) ev)) ;
2187		2449
2188	if (ActiveMenu)	2450	if (ActiveMenu)
2189	while (menu_select (ev)) ;	2451	while (menu_select (ev)) ;
2190	else	2452	else
2191	ev->y = -1;	2453	ev->y = -1;
2192	if (ev->y < 0) {	2454	if (ev->y < 0)
		2455	{
2193	Window unused_root, unused_child;	2456	Window unused_root, unused_child;
2194	int unused_root_x, unused_root_y;	2457	int unused_root_x, unused_root_y;
2195	unsigned int unused_mask;	2458	unsigned int unused_mask;
2196		2459
2197	XQueryPointer(Xdisplay, menuBar.win,	2460	XQueryPointer(Xdisplay, menuBar.win,
2198	&unused_root, &unused_child,	2461	&unused_root, &unused_child,
2199	&unused_root_x, &unused_root_y,	2462	&unused_root_x, &unused_root_y,
2200	&(ev->x), &(ev->y), &unused_mask);	2463	&(ev->x), &(ev->y), &unused_mask);
2201	menubar_select (ev);	2464	menubar_select (ev);
2202	}	2465	}
2203	break;	2466	break;
2204	}	2467	}
2205	}	2468	}
2206		2469
2207	void	2470	void
2208	rxvt_term::map_menuBar (int map)	2471	rxvt_term::map_menuBar (int map)
2209	{	2472	{
2210	if (menubar_mapping (map))	2473	if (menubar_mapping (map))
2211	resize_all_windows (0, 0, 0);	2474	resize_all_windows (0, 0, 0);
2212	}	2475	}
2213	#endif	2476	#endif
2214	/----------------------- end-of-file (C source) -----------------------/	2477	/----------------------- end-of-file (C source) -----------------------/

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing rxvt-unicode/src/menubar.C (file contents): Revision 1.5 by pcg, Sat Jan 31 03:27:45 2004 UTC vs. Revision 1.6 by pcg, Sun Feb 1 01:34:41 2004 UTC

Diff Legend

Comparing rxvt-unicode/src/menubar.C (file contents):
Revision 1.5 by pcg, Sat Jan 31 03:27:45 2004 UTC vs.
Revision 1.6 by pcg, Sun Feb 1 01:34:41 2004 UTC