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 (
                    "^!M_([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
        {
          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	sysadm	1.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	sysadm	1.3	#include "bbs.h"
19	sysadm	1.1	#include "menu.h"
20			#include "io.h"
21	sysadm	1.2	#include "common.h"
22	sysadm	1.1	#include <stdio.h>
23			#include <ctype.h>
24	sysadm	1.2	#include <regex.h>
25	sysadm	1.1
26	sysadm	1.2	MENU_SET bbs_menu;
27	sysadm	1.1
28			int
29	sysadm	1.3	load_menu (MENU_SET * p_menu_set, const char *conf_file)
30	sysadm	1.1	{
31	sysadm	1.2	FILE fin, fout;
32	sysadm	1.3	int i = 0, j;
33	sysadm	1.2	char buffer[256], screen_filename[256], temp[256];
34			regmatch_t pmatch[10];
35	sysadm	1.1
36			if ((fin = fopen (conf_file, "r")) == NULL)
37			{
38			log_error ("Open %s failed", conf_file);
39			return -1;
40			}
41
42	sysadm	1.2	while (fgets (buffer, 255, fin))
43	sysadm	1.3	{
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			"^!M_([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	sysadm	1.1	}
203	sysadm	1.3	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	sysadm	1.2
210	sysadm	1.1	return 0;
211			}
212
213	sysadm	1.3	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	sysadm	1.1	void
227	sysadm	1.3	display_menu_cursor (MENU * p_menu, int show)
228	sysadm	1.1	{
229	sysadm	1.3	moveto ((p_menu->items[p_menu->item_cur_pos])->r_row,
230			(p_menu->items[p_menu->item_cur_pos])->r_col - 2);
231	sysadm	1.1	prints (show ? ">" : " ");
232			iflush ();
233			}
234
235			int
236	sysadm	1.3	display_menu (MENU * p_menu)
237	sysadm	1.1	{
238	sysadm	1.3	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	sysadm	1.1
276	sysadm	1.3	if (!menu_selectable)
277			return -1;
278
279	sysadm	1.1	display_menu_cursor (p_menu, 1);
280
281			return 0;
282			}
283
284	sysadm	1.3	const char *
285			menu_control (MENU_SET * p_menu_set, int key)
286	sysadm	1.1	{
287			int i;
288	sysadm	1.3	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	sysadm	1.1	switch (key)
296			{
297			case CR:
298			case KEY_RIGHT:
299	sysadm	1.3	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			return (p_menu->items[p_menu->item_cur_pos]->action);
312			}
313			case KEY_LEFT:
314			if (p_menu_set->menu_select_depth > 0)
315			{
316			p_menu_set->menu_select_depth --;
317			p_menu =
318			p_menu_set->p_menu_select[p_menu_set->menu_select_depth];
319			if (display_menu (p_menu) != 0)
320			return menu_control (p_menu_set, KEY_LEFT);
321			break;
322			}
323			else
324			{
325			display_menu_cursor (p_menu, 0);
326			p_menu->item_cur_pos = p_menu->item_count - 1;
327			while (!p_menu->items[p_menu->item_cur_pos]->display)
328			p_menu->item_cur_pos --;
329			display_menu_cursor (p_menu, 1);
330			break;
331			}
332	sysadm	1.1	case KEY_UP:
333			display_menu_cursor (p_menu, 0);
334			p_menu->item_cur_pos --;
335	sysadm	1.3	while (!p_menu->items[p_menu->item_cur_pos]->display)
336			p_menu->item_cur_pos --;
337	sysadm	1.1	if (p_menu->item_cur_pos < 0)
338	sysadm	1.3	p_menu->item_cur_pos = p_menu->item_count - 1;
339			while (!p_menu->items[p_menu->item_cur_pos]->display)
340			p_menu->item_cur_pos --;
341	sysadm	1.1	display_menu_cursor (p_menu, 1);
342			break;
343			case KEY_DOWN:
344			display_menu_cursor (p_menu, 0);
345	sysadm	1.3	p_menu->item_cur_pos++;
346			while (!p_menu->items[p_menu->item_cur_pos]->display)
347			p_menu->item_cur_pos ++;
348	sysadm	1.1	if (p_menu->item_cur_pos >= p_menu->item_count)
349	sysadm	1.3	p_menu->item_cur_pos = 0;
350			while (!p_menu->items[p_menu->item_cur_pos]->display)
351			p_menu->item_cur_pos ++;
352	sysadm	1.1	display_menu_cursor (p_menu, 1);
353			break;
354			default:
355			for (i = 0; i < p_menu->item_count; i++)
356	sysadm	1.3	{
357			if (toupper (key) == toupper (p_menu->items[i]->name[0]))
358			{
359			display_menu_cursor (p_menu, 0);
360			p_menu->item_cur_pos = i;
361			display_menu_cursor (p_menu, 1);
362			break;
363			}
364			}
365	sysadm	1.1	}
366
367	sysadm	1.3	return "";
368	sysadm	1.1	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1