lbbs/src/menu.c

/***************************************************************************
                          menu.c  -  description
                             -------------------
    begin                : Wed Mar 16 2004
    copyright            : (C) 2005 by Leaflet
    email                : leaflet@leafok.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "bbs.h"
#include "menu.h"
#include "io.h"
#include "common.h"
#include <stdio.h>
#include <ctype.h>
#include <regex.h>

MENU_SET bbs_menu;

int
load_menu (MENU_SET * p_menu_set, const char *conf_file)
{
  FILE *fin, *fout;
  int i = 0, j;
  char buffer[256], screen_filename[256], temp[256];
  regmatch_t pmatch[10];

  if ((fin = fopen (conf_file, "r")) == NULL)
    {
      log_error ("Open %s failed", conf_file);
      return -1;
    }

  while (fgets (buffer, 255, fin))
    {
      switch (buffer[0])
        {
        case '#':
          break;
        case '%':
          if (ireg ("^%S_([A-Za-z0-9_]+)", buffer, 1, pmatch) == 0)
            {
              strncpy (temp, buffer + pmatch[0].rm_so,
                       pmatch[0].rm_eo - pmatch[0].rm_so + 1);
              sprintf (screen_filename, "%sMENU_SCR_%s", app_temp_dir, temp);

              if ((fout = fopen (screen_filename, "w")) == NULL)
                {
                  log_error ("Open %s failed", screen_filename);
                  return -2;
                }

              while (fgets (buffer, 255, fin))
                {
                  if (buffer[0] != '%')
                    fputs (buffer, fout);
                  else
                    break;
                }

              fclose (fout);
              break;
            }

          if (ireg ("^%menu ([A-Za-z0-9_]+)", buffer, 2, pmatch) == 0)
            {
              p_menu_set->p_menu[i] = malloc (sizeof (MENU));

              strncpy (p_menu_set->p_menu[i]->name,
                buffer + pmatch[1].rm_so,
                pmatch[1].rm_eo - pmatch[1].rm_so + 1);

              j = 0;
              
              while (fgets (buffer, 255, fin))
                {
                  if (buffer[0] == '#')
                  {
                    break;
                  }
                  if (buffer[0] == '%')
                  {
                    p_menu_set->p_menu[i]->item_count = j;
                    p_menu_set->p_menu[i]->item_cur_pos = 0;
                    i++;
                    break;
                  }
                  if (ireg (
                    "^!([A-Za-z0-9_.]+)[[:space:]]*([0-9]+),"
                    "[[:space:]]*([0-9]+),[[:space:]]*([0-9]+),"
                    "[[:space:]]*\"([A-Za-z0-9_]+)\",[[:space:]]*\"([^\"]+)\"",
                    buffer, 7, pmatch) == 0)
                    {
                      p_menu_set->p_menu[i]->items[j] = malloc (sizeof (MENU_ITEM));
                      p_menu_set->p_menu[i]->items[j]->submenu = 1;
                      strncpy (p_menu_set->p_menu[i]->items[j]->action,
                        buffer + pmatch[1].rm_so,
                        pmatch[1].rm_eo - pmatch[1].rm_so + 1);
                      strncpy (temp,
                        buffer + pmatch[2].rm_so,
                        pmatch[2].rm_eo - pmatch[2].rm_so + 1);
                      p_menu_set->p_menu[i]->items[j]->row = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[3].rm_so,
                        pmatch[3].rm_eo - pmatch[3].rm_so + 1);
                      p_menu_set->p_menu[i]->items[j]->col = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[4].rm_so,
                        pmatch[4].rm_eo - pmatch[4].rm_so + 1);
                      p_menu_set->p_menu[i]->items[j]->priv = atoi (temp);
                      strncpy (p_menu_set->p_menu[i]->items[j]->name,
                        buffer + pmatch[5].rm_so,
                        pmatch[5].rm_eo - pmatch[5].rm_so + 1);
                      strncpy (p_menu_set->p_menu[i]->items[j]->text,
                        buffer + pmatch[6].rm_so,
                        pmatch[6].rm_eo - pmatch[6].rm_so + 1);
                      j++;
                      continue;
                    }
                  if (ireg (
                    "^@([A-Za-z0-9_]+)[[:space:]]*([0-9]+),"
                    "[[:space:]]*([0-9]+),[[:space:]]*([0-9]+),"
                    "[[:space:]]*\"([A-Za-z0-9_]+)\",[[:space:]]*\"([^\"]+)\"",
                    buffer, 7, pmatch) == 0)
                    {
                      p_menu_set->p_menu[i]->items[j] = malloc (sizeof (MENU_ITEM));
                      p_menu_set->p_menu[i]->items[j]->submenu = 0;
                      strncpy (p_menu_set->p_menu[i]->items[j]->action,
                        buffer + pmatch[1].rm_so,
                        pmatch[1].rm_eo - pmatch[1].rm_so + 1);
                      strncpy (temp,
                        buffer + pmatch[2].rm_so,
                        pmatch[2].rm_eo - pmatch[2].rm_so + 1);
                      p_menu_set->p_menu[i]->items[j]->row = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[3].rm_so,
                        pmatch[3].rm_eo - pmatch[3].rm_so + 1);
                      p_menu_set->p_menu[i]->items[j]->col = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[4].rm_so,
                        pmatch[4].rm_eo - pmatch[4].rm_so + 1);
                      p_menu_set->p_menu[i]->items[j]->priv = atoi (temp);
                      strncpy (p_menu_set->p_menu[i]->items[j]->name,
                        buffer + pmatch[5].rm_so,
                        pmatch[5].rm_eo - pmatch[5].rm_so + 1);
                      strncpy (p_menu_set->p_menu[i]->items[j]->text,
                        buffer + pmatch[6].rm_so,
                        pmatch[6].rm_eo - pmatch[6].rm_so + 1);
                      j++;
                      continue;
                    }
                  if (ireg (
                    "^title[[:space:]]*([0-9]+),"
                    "[[:space:]]*([0-9]+),[[:space:]]*\"([^\"]+)\"",
                    buffer, 4, pmatch) == 0)
                    {
                      strncpy (temp,
                        buffer + pmatch[1].rm_so,
                        pmatch[1].rm_eo - pmatch[1].rm_so + 1);
                      p_menu_set->p_menu[i]->title.row = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[2].rm_so,
                        pmatch[2].rm_eo - pmatch[2].rm_so + 1);
                      p_menu_set->p_menu[i]->title.col = atoi (temp);
                      strncpy (p_menu_set->p_menu[i]->title.text,
                        buffer + pmatch[3].rm_so,
                        pmatch[3].rm_eo - pmatch[3].rm_so + 1);
                      continue;
                    }
                  if (ireg (
                    "^title[[:space:]]*([0-9]+),"
                    "[[:space:]]*([0-9]+),[[:space:]]*S_([A-Za-z0-9_]+)",
                    buffer, 4, pmatch) == 0)
                    {
                      strncpy (temp,
                        buffer + pmatch[1].rm_so,
                        pmatch[1].rm_eo - pmatch[1].rm_so + 1);
                      p_menu_set->p_menu[i]->screen.row = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[2].rm_so,
                        pmatch[2].rm_eo - pmatch[2].rm_so + 1);
                      p_menu_set->p_menu[i]->screen.col = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[3].rm_so,
                        pmatch[3].rm_eo - pmatch[3].rm_so + 1);
                      sprintf (p_menu_set->p_menu[i]->screen.filename, 
                        "%sMENU_SCR_%s", app_temp_dir, temp);
                      continue;
                    }
                }
            }
          break;
        }
    }
  fclose (fin);

  p_menu_set->menu_count = i;
  p_menu_set->menu_select_depth = 0;
  p_menu_set->p_menu_select[p_menu_set->menu_select_depth]
    = (i == 0 ? NULL : p_menu_set->p_menu[0]);

  return 0;
}

MENU * 
get_menu (MENU_SET * p_menu_set, const char * menu_name)
{
  int i;

  for (i = 0; i < p_menu_set->menu_count; i++)
  {
    if (strcmp(p_menu_set->p_menu[i]->name, menu_name) == 0)
    {
log_std ("%s %s\n", p_menu_set->p_menu[i]->name, menu_name);
      return p_menu_set->p_menu[i];
    }
  }

log_std ("%d:)\n", i);
  return NULL;
}

void
display_menu_cursor (MENU * p_menu, int show)
{
  moveto ((p_menu->items[p_menu->item_cur_pos])->r_row,
          (p_menu->items[p_menu->item_cur_pos])->r_col - 2);
  prints (show ? ">" : " ");
  iflush ();
}

int
display_menu (MENU * p_menu)
{
  int i, row, col, menu_selectable = 0;

  if (p_menu == NULL)
    return -1;

  show_top (p_menu->title.text);

  moveto (p_menu->screen.row, p_menu->screen.col); 
  display_file (p_menu->screen.filename);

  row = p_menu->items[0]->row;
  col = p_menu->items[0]->col;

  for (i = 0; i < p_menu->item_count; i++)
    {
      if (checkpriv (&BBS_priv, 0, p_menu->items[i]->priv) == 0)
      {
        p_menu->items[i]->display = 0;
      }
      else
      {
        p_menu->items[i]->display = 1;

        menu_selectable = 1;
        
        if (p_menu->items[i]->row != 0)
          row = p_menu->items[i]->row;
        else
          row ++;
        p_menu->items[i]->r_row = row;
        if (p_menu->items[i]->col != 0)
          col = p_menu->items[i]->col;
        p_menu->items[i]->r_col = col;
        moveto (row, col);
        prints (p_menu->items[i]->text);
        iflush ();
      }
    }
  
  if (!menu_selectable)
    return -1;

  display_menu_cursor (p_menu, 1);

  return 0;
}

const char *
menu_control (MENU_SET * p_menu_set, int key)
{
  int i;
  MENU *p_menu;

  if (p_menu_set->menu_count == 0)
    return "";

  p_menu = p_menu_set->p_menu_select[p_menu_set->menu_select_depth];

  switch (key)
    {
    case CR:
    case KEY_RIGHT:
      if (p_menu->items[p_menu->item_cur_pos]->submenu)
        {
          p_menu_set->menu_select_depth ++;
          p_menu =
            p_menu_set->p_menu_select[p_menu_set->menu_select_depth] =
            get_menu (p_menu_set, p_menu->items[p_menu->item_cur_pos]->action);
          if (display_menu (p_menu) != 0)
            return menu_control (p_menu_set, KEY_LEFT);
          break;
        }
      else
        {
          if (strcmp (p_menu->items[p_menu->item_cur_pos]->action, "..") == 0)
            return menu_control (p_menu_set, KEY_LEFT);
          else
            return (p_menu->items[p_menu->item_cur_pos]->action);
        }
    case KEY_LEFT:
      if (p_menu_set->menu_select_depth > 0)
        {
          p_menu_set->menu_select_depth --;
          p_menu =
            p_menu_set->p_menu_select[p_menu_set->menu_select_depth];
          if (display_menu (p_menu) != 0)
            return menu_control (p_menu_set, KEY_LEFT);
          break;
        }
      else
        {
          display_menu_cursor (p_menu, 0);
          p_menu->item_cur_pos = p_menu->item_count - 1;
          while (!p_menu->items[p_menu->item_cur_pos]->display)
            p_menu->item_cur_pos --;
          display_menu_cursor (p_menu, 1);
          break;
        }
    case KEY_UP:
      display_menu_cursor (p_menu, 0);
      p_menu->item_cur_pos --;
      while (!p_menu->items[p_menu->item_cur_pos]->display)
        p_menu->item_cur_pos --;
      if (p_menu->item_cur_pos < 0)
        p_menu->item_cur_pos = p_menu->item_count - 1;
      while (!p_menu->items[p_menu->item_cur_pos]->display)
        p_menu->item_cur_pos --;
      display_menu_cursor (p_menu, 1);
      break;
    case KEY_DOWN:
      display_menu_cursor (p_menu, 0);
      p_menu->item_cur_pos++;
      while (!p_menu->items[p_menu->item_cur_pos]->display)
        p_menu->item_cur_pos ++;
      if (p_menu->item_cur_pos >= p_menu->item_count)
        p_menu->item_cur_pos = 0;
      while (!p_menu->items[p_menu->item_cur_pos]->display)
        p_menu->item_cur_pos ++;
      display_menu_cursor (p_menu, 1);
      break;
    default:
      for (i = 0; i < p_menu->item_count; i++)
        {
          if (toupper (key) == toupper (p_menu->items[i]->name[0]))
            {
              display_menu_cursor (p_menu, 0);
              p_menu->item_cur_pos = i;
              display_menu_cursor (p_menu, 1);
              break;
            }
        }
    }

  return "";
}
1	/***************************************************************************
2	menu.c - description
3	-------------------
4	begin : Wed Mar 16 2004
5	copyright : (C) 2005 by Leaflet
6	email : leaflet@leafok.com
7	***************************************************************************/
8
9	/***************************************************************************
10	* *
11	* This program is free software; you can redistribute it and/or modify *
12	* it under the terms of the GNU General Public License as published by *
13	* the Free Software Foundation; either version 2 of the License, or *
14	* (at your option) any later version. *
15	* *
16	***************************************************************************/
17
18	#include "bbs.h"
19	#include "menu.h"
20	#include "io.h"
21	#include "common.h"
22	#include <stdio.h>
23	#include <ctype.h>
24	#include <regex.h>
25
26	MENU_SET bbs_menu;
27
28	int
29	load_menu (MENU_SET * p_menu_set, const char *conf_file)
30	{
31	FILE fin, fout;
32	int i = 0, j;
33	char buffer[256], screen_filename[256], temp[256];
34	regmatch_t pmatch[10];
35
36	if ((fin = fopen (conf_file, "r")) == NULL)
37	{
38	log_error ("Open %s failed", conf_file);
39	return -1;
40	}
41
42	while (fgets (buffer, 255, fin))
43	{
44	switch (buffer[0])
45	{
46	case '#':
47	break;
48	case '%':
49	if (ireg ("^%S_([A-Za-z0-9_]+)", buffer, 1, pmatch) == 0)
50	{
51	strncpy (temp, buffer + pmatch[0].rm_so,
52	pmatch[0].rm_eo - pmatch[0].rm_so + 1);
53	sprintf (screen_filename, "%sMENU_SCR_%s", app_temp_dir, temp);
54
55	if ((fout = fopen (screen_filename, "w")) == NULL)
56	{
57	log_error ("Open %s failed", screen_filename);
58	return -2;
59	}
60
61	while (fgets (buffer, 255, fin))
62	{
63	if (buffer[0] != '%')
64	fputs (buffer, fout);
65	else
66	break;
67	}
68
69	fclose (fout);
70	break;
71	}
72
73	if (ireg ("^%menu ([A-Za-z0-9_]+)", buffer, 2, pmatch) == 0)
74	{
75	p_menu_set->p_menu[i] = malloc (sizeof (MENU));
76
77	strncpy (p_menu_set->p_menu[i]->name,
78	buffer + pmatch[1].rm_so,
79	pmatch[1].rm_eo - pmatch[1].rm_so + 1);
80
81	j = 0;
82
83	while (fgets (buffer, 255, fin))
84	{
85	if (buffer[0] == '#')
86	{
87	break;
88	}
89	if (buffer[0] == '%')
90	{
91	p_menu_set->p_menu[i]->item_count = j;
92	p_menu_set->p_menu[i]->item_cur_pos = 0;
93	i++;
94	break;
95	}
96	if (ireg (
97	"^!([A-Za-z0-9_.]+)[[:space:]]*([0-9]+),"
98	"[[:space:]]([0-9]+),[[:space:]]([0-9]+),"
99	"[[:space:]]\"([A-Za-z0-9_]+)\",[[:space:]]\"([^\"]+)\"",
100	buffer, 7, pmatch) == 0)
101	{
102	p_menu_set->p_menu[i]->items[j] = malloc (sizeof (MENU_ITEM));
103	p_menu_set->p_menu[i]->items[j]->submenu = 1;
104	strncpy (p_menu_set->p_menu[i]->items[j]->action,
105	buffer + pmatch[1].rm_so,
106	pmatch[1].rm_eo - pmatch[1].rm_so + 1);
107	strncpy (temp,
108	buffer + pmatch[2].rm_so,
109	pmatch[2].rm_eo - pmatch[2].rm_so + 1);
110	p_menu_set->p_menu[i]->items[j]->row = atoi (temp);
111	strncpy (temp,
112	buffer + pmatch[3].rm_so,
113	pmatch[3].rm_eo - pmatch[3].rm_so + 1);
114	p_menu_set->p_menu[i]->items[j]->col = atoi (temp);
115	strncpy (temp,
116	buffer + pmatch[4].rm_so,
117	pmatch[4].rm_eo - pmatch[4].rm_so + 1);
118	p_menu_set->p_menu[i]->items[j]->priv = atoi (temp);
119	strncpy (p_menu_set->p_menu[i]->items[j]->name,
120	buffer + pmatch[5].rm_so,
121	pmatch[5].rm_eo - pmatch[5].rm_so + 1);
122	strncpy (p_menu_set->p_menu[i]->items[j]->text,
123	buffer + pmatch[6].rm_so,
124	pmatch[6].rm_eo - pmatch[6].rm_so + 1);
125	j++;
126	continue;
127	}
128	if (ireg (
129	"^@([A-Za-z0-9_]+)[[:space:]]*([0-9]+),"
130	"[[:space:]]([0-9]+),[[:space:]]([0-9]+),"
131	"[[:space:]]\"([A-Za-z0-9_]+)\",[[:space:]]\"([^\"]+)\"",
132	buffer, 7, pmatch) == 0)
133	{
134	p_menu_set->p_menu[i]->items[j] = malloc (sizeof (MENU_ITEM));
135	p_menu_set->p_menu[i]->items[j]->submenu = 0;
136	strncpy (p_menu_set->p_menu[i]->items[j]->action,
137	buffer + pmatch[1].rm_so,
138	pmatch[1].rm_eo - pmatch[1].rm_so + 1);
139	strncpy (temp,
140	buffer + pmatch[2].rm_so,
141	pmatch[2].rm_eo - pmatch[2].rm_so + 1);
142	p_menu_set->p_menu[i]->items[j]->row = atoi (temp);
143	strncpy (temp,
144	buffer + pmatch[3].rm_so,
145	pmatch[3].rm_eo - pmatch[3].rm_so + 1);
146	p_menu_set->p_menu[i]->items[j]->col = atoi (temp);
147	strncpy (temp,
148	buffer + pmatch[4].rm_so,
149	pmatch[4].rm_eo - pmatch[4].rm_so + 1);
150	p_menu_set->p_menu[i]->items[j]->priv = atoi (temp);
151	strncpy (p_menu_set->p_menu[i]->items[j]->name,
152	buffer + pmatch[5].rm_so,
153	pmatch[5].rm_eo - pmatch[5].rm_so + 1);
154	strncpy (p_menu_set->p_menu[i]->items[j]->text,
155	buffer + pmatch[6].rm_so,
156	pmatch[6].rm_eo - pmatch[6].rm_so + 1);
157	j++;
158	continue;
159	}
160	if (ireg (
161	"^title[[:space:]]*([0-9]+),"
162	"[[:space:]]([0-9]+),[[:space:]]\"([^\"]+)\"",
163	buffer, 4, pmatch) == 0)
164	{
165	strncpy (temp,
166	buffer + pmatch[1].rm_so,
167	pmatch[1].rm_eo - pmatch[1].rm_so + 1);
168	p_menu_set->p_menu[i]->title.row = atoi (temp);
169	strncpy (temp,
170	buffer + pmatch[2].rm_so,
171	pmatch[2].rm_eo - pmatch[2].rm_so + 1);
172	p_menu_set->p_menu[i]->title.col = atoi (temp);
173	strncpy (p_menu_set->p_menu[i]->title.text,
174	buffer + pmatch[3].rm_so,
175	pmatch[3].rm_eo - pmatch[3].rm_so + 1);
176	continue;
177	}
178	if (ireg (
179	"^title[[:space:]]*([0-9]+),"
180	"[[:space:]]([0-9]+),[[:space:]]S_([A-Za-z0-9_]+)",
181	buffer, 4, pmatch) == 0)
182	{
183	strncpy (temp,
184	buffer + pmatch[1].rm_so,
185	pmatch[1].rm_eo - pmatch[1].rm_so + 1);
186	p_menu_set->p_menu[i]->screen.row = atoi (temp);
187	strncpy (temp,
188	buffer + pmatch[2].rm_so,
189	pmatch[2].rm_eo - pmatch[2].rm_so + 1);
190	p_menu_set->p_menu[i]->screen.col = atoi (temp);
191	strncpy (temp,
192	buffer + pmatch[3].rm_so,
193	pmatch[3].rm_eo - pmatch[3].rm_so + 1);
194	sprintf (p_menu_set->p_menu[i]->screen.filename,
195	"%sMENU_SCR_%s", app_temp_dir, temp);
196	continue;
197	}
198	}
199	}
200	break;
201	}
202	}
203	fclose (fin);
204
205	p_menu_set->menu_count = i;
206	p_menu_set->menu_select_depth = 0;
207	p_menu_set->p_menu_select[p_menu_set->menu_select_depth]
208	= (i == 0 ? NULL : p_menu_set->p_menu[0]);
209
210	return 0;
211	}
212
213	MENU *
214	get_menu (MENU_SET * p_menu_set, const char * menu_name)
215	{
216	int i;
217
218	for (i = 0; i < p_menu_set->menu_count; i++)
219	{
220	if (strcmp(p_menu_set->p_menu[i]->name, menu_name) == 0)
221	{
222	log_std ("%s %s\n", p_menu_set->p_menu[i]->name, menu_name);
223	return p_menu_set->p_menu[i];
224	}
225	}
226
227	log_std ("%d:)\n", i);
228	return NULL;
229	}
230
231	void
232	display_menu_cursor (MENU * p_menu, int show)
233	{
234	moveto ((p_menu->items[p_menu->item_cur_pos])->r_row,
235	(p_menu->items[p_menu->item_cur_pos])->r_col - 2);
236	prints (show ? ">" : " ");
237	iflush ();
238	}
239
240	int
241	display_menu (MENU * p_menu)
242	{
243	int i, row, col, menu_selectable = 0;
244
245	if (p_menu == NULL)
246	return -1;
247
248	show_top (p_menu->title.text);
249
250	moveto (p_menu->screen.row, p_menu->screen.col);
251	display_file (p_menu->screen.filename);
252
253	row = p_menu->items[0]->row;
254	col = p_menu->items[0]->col;
255
256	for (i = 0; i < p_menu->item_count; i++)
257	{
258	if (checkpriv (&BBS_priv, 0, p_menu->items[i]->priv) == 0)
259	{
260	p_menu->items[i]->display = 0;
261	}
262	else
263	{
264	p_menu->items[i]->display = 1;
265
266	menu_selectable = 1;
267
268	if (p_menu->items[i]->row != 0)
269	row = p_menu->items[i]->row;
270	else
271	row ++;
272	p_menu->items[i]->r_row = row;
273	if (p_menu->items[i]->col != 0)
274	col = p_menu->items[i]->col;
275	p_menu->items[i]->r_col = col;
276	moveto (row, col);
277	prints (p_menu->items[i]->text);
278	iflush ();
279	}
280	}
281
282	if (!menu_selectable)
283	return -1;
284
285	display_menu_cursor (p_menu, 1);
286
287	return 0;
288	}
289
290	const char *
291	menu_control (MENU_SET * p_menu_set, int key)
292	{
293	int i;
294	MENU *p_menu;
295
296	if (p_menu_set->menu_count == 0)
297	return "";
298
299	p_menu = p_menu_set->p_menu_select[p_menu_set->menu_select_depth];
300
301	switch (key)
302	{
303	case CR:
304	case KEY_RIGHT:
305	if (p_menu->items[p_menu->item_cur_pos]->submenu)
306	{
307	p_menu_set->menu_select_depth ++;
308	p_menu =
309	p_menu_set->p_menu_select[p_menu_set->menu_select_depth] =
310	get_menu (p_menu_set, p_menu->items[p_menu->item_cur_pos]->action);
311	if (display_menu (p_menu) != 0)
312	return menu_control (p_menu_set, KEY_LEFT);
313	break;
314	}
315	else
316	{
317	if (strcmp (p_menu->items[p_menu->item_cur_pos]->action, "..") == 0)
318	return menu_control (p_menu_set, KEY_LEFT);
319	else
320	return (p_menu->items[p_menu->item_cur_pos]->action);
321	}
322	case KEY_LEFT:
323	if (p_menu_set->menu_select_depth > 0)
324	{
325	p_menu_set->menu_select_depth --;
326	p_menu =
327	p_menu_set->p_menu_select[p_menu_set->menu_select_depth];
328	if (display_menu (p_menu) != 0)
329	return menu_control (p_menu_set, KEY_LEFT);
330	break;
331	}
332	else
333	{
334	display_menu_cursor (p_menu, 0);
335	p_menu->item_cur_pos = p_menu->item_count - 1;
336	while (!p_menu->items[p_menu->item_cur_pos]->display)
337	p_menu->item_cur_pos --;
338	display_menu_cursor (p_menu, 1);
339	break;
340	}
341	case KEY_UP:
342	display_menu_cursor (p_menu, 0);
343	p_menu->item_cur_pos --;
344	while (!p_menu->items[p_menu->item_cur_pos]->display)
345	p_menu->item_cur_pos --;
346	if (p_menu->item_cur_pos < 0)
347	p_menu->item_cur_pos = p_menu->item_count - 1;
348	while (!p_menu->items[p_menu->item_cur_pos]->display)
349	p_menu->item_cur_pos --;
350	display_menu_cursor (p_menu, 1);
351	break;
352	case KEY_DOWN:
353	display_menu_cursor (p_menu, 0);
354	p_menu->item_cur_pos++;
355	while (!p_menu->items[p_menu->item_cur_pos]->display)
356	p_menu->item_cur_pos ++;
357	if (p_menu->item_cur_pos >= p_menu->item_count)
358	p_menu->item_cur_pos = 0;
359	while (!p_menu->items[p_menu->item_cur_pos]->display)
360	p_menu->item_cur_pos ++;
361	display_menu_cursor (p_menu, 1);
362	break;
363	default:
364	for (i = 0; i < p_menu->item_count; i++)
365	{
366	if (toupper (key) == toupper (p_menu->items[i]->name[0]))
367	{
368	display_menu_cursor (p_menu, 0);
369	p_menu->item_cur_pos = i;
370	display_menu_cursor (p_menu, 1);
371	break;
372	}
373	}
374	}
375
376	return "";
377	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1