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, 1, pmatch) == 0)
            {
              p_menu_set->p_menu[i] = malloc (sizeof (MENU));

              strncpy (p_menu_set->p_menu[i]->name,
                buffer + pmatch[0].rm_so,
                pmatch[0].rm_eo - pmatch[0].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, 6, 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[0].rm_so,
                        pmatch[0].rm_eo - pmatch[0].rm_so + 1);
                      strncpy (temp,
                        buffer + pmatch[1].rm_so,
                        pmatch[1].rm_eo - pmatch[1].rm_so + 1);
                      p_menu_set->p_menu[i]->items[j]->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]->items[j]->col = 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]->priv = atoi (temp);
                      strncpy (p_menu_set->p_menu[i]->items[j]->name,
                        buffer + pmatch[4].rm_so,
                        pmatch[4].rm_eo - pmatch[4].rm_so + 1);
                      strncpy (p_menu_set->p_menu[i]->items[j]->text,
                        buffer + pmatch[5].rm_so,
                        pmatch[5].rm_eo - pmatch[5].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, 6, 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[0].rm_so,
                        pmatch[0].rm_eo - pmatch[0].rm_so + 1);
                      strncpy (temp,
                        buffer + pmatch[1].rm_so,
                        pmatch[1].rm_eo - pmatch[1].rm_so + 1);
                      p_menu_set->p_menu[i]->items[j]->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]->items[j]->col = 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]->priv = atoi (temp);
                      strncpy (p_menu_set->p_menu[i]->items[j]->name,
                        buffer + pmatch[4].rm_so,
                        pmatch[4].rm_eo - pmatch[4].rm_so + 1);
                      strncpy (p_menu_set->p_menu[i]->items[j]->text,
                        buffer + pmatch[5].rm_so,
                        pmatch[5].rm_eo - pmatch[5].rm_so + 1);
                      j++;
                      continue;
                    }
                  if (ireg (
                    "^title[[:space:]]*([0-9]+),"
                    "[[:space:]]*([0-9]+),[[:space:]]*\"([^\"]+)\"",
                    buffer, 3, pmatch) == 0)
                    {
                      strncpy (temp,
                        buffer + pmatch[0].rm_so,
                        pmatch[0].rm_eo - pmatch[0].rm_so + 1);
                      p_menu_set->p_menu[i]->title.row = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[1].rm_so,
                        pmatch[1].rm_eo - pmatch[1].rm_so + 1);
                      p_menu_set->p_menu[i]->title.col = atoi (temp);
                      strncpy (p_menu_set->p_menu[i]->title.text,
                        buffer + pmatch[2].rm_so,
                        pmatch[2].rm_eo - pmatch[2].rm_so + 1);
                      continue;
                    }
                  if (ireg (
                    "^title[[:space:]]*([0-9]+),"
                    "[[:space:]]*([0-9]+),[[:space:]]*S_([A-Za-z0-9_]+)",
                    buffer, 3, pmatch) == 0)
                    {
                      strncpy (temp,
                        buffer + pmatch[0].rm_so,
                        pmatch[0].rm_eo - pmatch[0].rm_so + 1);
                      p_menu_set->p_menu[i]->screen.row = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[1].rm_so,
                        pmatch[1].rm_eo - pmatch[1].rm_so + 1);
                      p_menu_set->p_menu[i]->screen.col = atoi (temp);
                      strncpy (temp,
                        buffer + pmatch[2].rm_so,
                        pmatch[2].rm_eo - pmatch[2].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)
    {
      return p_menu_set->p_menu[i];
    }
  }
}

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;

  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 ++;
        else
          row = p_menu->items[i]->row;
        p_menu->items[i]->r_row = row;
        if (p_menu->items[i]->col == 0)
          col ++;
        else
          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, 1, 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[0].rm_so,
79	pmatch[0].rm_eo - pmatch[0].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, 6, 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[0].rm_so,
106	pmatch[0].rm_eo - pmatch[0].rm_so + 1);
107	strncpy (temp,
108	buffer + pmatch[1].rm_so,
109	pmatch[1].rm_eo - pmatch[1].rm_so + 1);
110	p_menu_set->p_menu[i]->items[j]->row = atoi (temp);
111	strncpy (temp,
112	buffer + pmatch[2].rm_so,
113	pmatch[2].rm_eo - pmatch[2].rm_so + 1);
114	p_menu_set->p_menu[i]->items[j]->col = atoi (temp);
115	strncpy (temp,
116	buffer + pmatch[3].rm_so,
117	pmatch[3].rm_eo - pmatch[3].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[4].rm_so,
121	pmatch[4].rm_eo - pmatch[4].rm_so + 1);
122	strncpy (p_menu_set->p_menu[i]->items[j]->text,
123	buffer + pmatch[5].rm_so,
124	pmatch[5].rm_eo - pmatch[5].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, 6, 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[0].rm_so,
138	pmatch[0].rm_eo - pmatch[0].rm_so + 1);
139	strncpy (temp,
140	buffer + pmatch[1].rm_so,
141	pmatch[1].rm_eo - pmatch[1].rm_so + 1);
142	p_menu_set->p_menu[i]->items[j]->row = atoi (temp);
143	strncpy (temp,
144	buffer + pmatch[2].rm_so,
145	pmatch[2].rm_eo - pmatch[2].rm_so + 1);
146	p_menu_set->p_menu[i]->items[j]->col = atoi (temp);
147	strncpy (temp,
148	buffer + pmatch[3].rm_so,
149	pmatch[3].rm_eo - pmatch[3].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[4].rm_so,
153	pmatch[4].rm_eo - pmatch[4].rm_so + 1);
154	strncpy (p_menu_set->p_menu[i]->items[j]->text,
155	buffer + pmatch[5].rm_so,
156	pmatch[5].rm_eo - pmatch[5].rm_so + 1);
157	j++;
158	continue;
159	}
160	if (ireg (
161	"^title[[:space:]]*([0-9]+),"
162	"[[:space:]]([0-9]+),[[:space:]]\"([^\"]+)\"",
163	buffer, 3, pmatch) == 0)
164	{
165	strncpy (temp,
166	buffer + pmatch[0].rm_so,
167	pmatch[0].rm_eo - pmatch[0].rm_so + 1);
168	p_menu_set->p_menu[i]->title.row = atoi (temp);
169	strncpy (temp,
170	buffer + pmatch[1].rm_so,
171	pmatch[1].rm_eo - pmatch[1].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[2].rm_so,
175	pmatch[2].rm_eo - pmatch[2].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, 3, pmatch) == 0)
182	{
183	strncpy (temp,
184	buffer + pmatch[0].rm_so,
185	pmatch[0].rm_eo - pmatch[0].rm_so + 1);
186	p_menu_set->p_menu[i]->screen.row = atoi (temp);
187	strncpy (temp,
188	buffer + pmatch[1].rm_so,
189	pmatch[1].rm_eo - pmatch[1].rm_so + 1);
190	p_menu_set->p_menu[i]->screen.col = atoi (temp);
191	strncpy (temp,
192	buffer + pmatch[2].rm_so,
193	pmatch[2].rm_eo - pmatch[2].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	for (i = 0; i < p_menu_set->menu_count; i++)
218	{
219	if (strcmp(p_menu_set->p_menu[i]->name, menu_name) == 0)
220	{
221	return p_menu_set->p_menu[i];
222	}
223	}
224	}
225
226	void
227	display_menu_cursor (MENU * p_menu, int show)
228	{
229	moveto ((p_menu->items[p_menu->item_cur_pos])->r_row,
230	(p_menu->items[p_menu->item_cur_pos])->r_col - 2);
231	prints (show ? ">" : " ");
232	iflush ();
233	}
234
235	int
236	display_menu (MENU * p_menu)
237	{
238	int i, row, col, menu_selectable = 0;
239
240	show_top (p_menu->title.text);
241
242	moveto (p_menu->screen.row, p_menu->screen.col);
243	display_file (p_menu->screen.filename);
244
245	row = p_menu->items[0]->row;
246	col = p_menu->items[0]->col;
247
248	for (i = 0; i < p_menu->item_count; i++)
249	{
250	if (checkpriv (&BBS_priv, 0, p_menu->items[i]->priv) == 0)
251	{
252	p_menu->items[i]->display = 0;
253	}
254	else
255	{
256	p_menu->items[i]->display = 1;
257
258	menu_selectable = 1;
259
260	if (p_menu->items[i]->row == 0)
261	row ++;
262	else
263	row = p_menu->items[i]->row;
264	p_menu->items[i]->r_row = row;
265	if (p_menu->items[i]->col == 0)
266	col ++;
267	else
268	col = p_menu->items[i]->col;
269	p_menu->items[i]->r_col = col;
270	moveto (row, col);
271	prints (p_menu->items[i]->text);
272	iflush ();
273	}
274	}
275
276	if (!menu_selectable)
277	return -1;
278
279	display_menu_cursor (p_menu, 1);
280
281	return 0;
282	}
283
284	const char *
285	menu_control (MENU_SET * p_menu_set, int key)
286	{
287	int i;
288	MENU *p_menu;
289
290	if (p_menu_set->menu_count == 0)
291	return "";
292
293	p_menu = p_menu_set->p_menu_select[p_menu_set->menu_select_depth];
294
295	switch (key)
296	{
297	case CR:
298	case KEY_RIGHT:
299	if (p_menu->items[p_menu->item_cur_pos]->submenu)
300	{
301	p_menu_set->menu_select_depth ++;
302	p_menu =
303	p_menu_set->p_menu_select[p_menu_set->menu_select_depth] =
304	get_menu (p_menu_set, p_menu->items[p_menu->item_cur_pos]->action);
305	if (display_menu (p_menu) != 0)
306	return menu_control (p_menu_set, KEY_LEFT);
307	break;
308	}
309	else
310	{
311	if (strcmp (p_menu->items[p_menu->item_cur_pos]->action, "..") == 0)
312	return menu_control (p_menu_set, KEY_LEFT);
313	else
314	return (p_menu->items[p_menu->item_cur_pos]->action);
315	}
316	case KEY_LEFT:
317	if (p_menu_set->menu_select_depth > 0)
318	{
319	p_menu_set->menu_select_depth --;
320	p_menu =
321	p_menu_set->p_menu_select[p_menu_set->menu_select_depth];
322	if (display_menu (p_menu) != 0)
323	return menu_control (p_menu_set, KEY_LEFT);
324	break;
325	}
326	else
327	{
328	display_menu_cursor (p_menu, 0);
329	p_menu->item_cur_pos = p_menu->item_count - 1;
330	while (!p_menu->items[p_menu->item_cur_pos]->display)
331	p_menu->item_cur_pos --;
332	display_menu_cursor (p_menu, 1);
333	break;
334	}
335	case KEY_UP:
336	display_menu_cursor (p_menu, 0);
337	p_menu->item_cur_pos --;
338	while (!p_menu->items[p_menu->item_cur_pos]->display)
339	p_menu->item_cur_pos --;
340	if (p_menu->item_cur_pos < 0)
341	p_menu->item_cur_pos = p_menu->item_count - 1;
342	while (!p_menu->items[p_menu->item_cur_pos]->display)
343	p_menu->item_cur_pos --;
344	display_menu_cursor (p_menu, 1);
345	break;
346	case KEY_DOWN:
347	display_menu_cursor (p_menu, 0);
348	p_menu->item_cur_pos++;
349	while (!p_menu->items[p_menu->item_cur_pos]->display)
350	p_menu->item_cur_pos ++;
351	if (p_menu->item_cur_pos >= p_menu->item_count)
352	p_menu->item_cur_pos = 0;
353	while (!p_menu->items[p_menu->item_cur_pos]->display)
354	p_menu->item_cur_pos ++;
355	display_menu_cursor (p_menu, 1);
356	break;
357	default:
358	for (i = 0; i < p_menu->item_count; i++)
359	{
360	if (toupper (key) == toupper (p_menu->items[i]->name[0]))
361	{
362	display_menu_cursor (p_menu, 0);
363	p_menu->item_cur_pos = i;
364	display_menu_cursor (p_menu, 1);
365	break;
366	}
367	}
368	}
369
370	return "";
371	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1