the menu must be redrawn after displaying the help info
[asterisk/asterisk.git] / build_tools / menuselect_curses.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2005 - 2006, Russell Bryant
5  *
6  * Russell Bryant <russell@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*
20  * \file
21  *
22  * \author Russell Bryant <russell@digium.com>
23  * 
24  * \brief curses frontend for Asterisk module selection
25  */
26
27 #include "asterisk/autoconfig.h"
28
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <signal.h>
33 #include <curses.h>
34
35 #include "menuselect.h"
36
37 #define MENU_TITLE1     "*************************************"
38 #define MENU_TITLE2     "*     Asterisk Module Selection     *"
39 #define MENU_TITLE3     "*************************************"
40 #define MENU_HELP       "Press 'h' for help."
41
42 #define TITLE_HEIGHT    7
43
44 #define MIN_X           80
45 #define MIN_Y           20
46
47 #define PAGE_OFFSET     10
48
49
50 /*! Maximum number of characters horizontally */
51 int max_x = 0;
52 /*! Maximum number of characters vertically */
53 int max_y = 0;
54
55 const char * const help_info[] = {
56         "scroll        => up/down arrows",
57         "(de)select    => Enter",
58         "select all    => F8",
59         "deselect all  => F7",
60         "back          => left arrow",
61         "quit          => q",
62         "save and quit => x",
63         "",
64         "XXX means dependencies have not been met"
65 };
66
67 void winch_handler(int sig);
68 void show_help(WINDOW *win);
69 void draw_main_menu(WINDOW *menu, int curopt);
70 void draw_category_menu(WINDOW *menu, struct category *cat, int start, int end, int curopt, int changed);
71 int run_category_menu(WINDOW *menu, int cat_num);
72 int run_category_menu(WINDOW *menu, int cat_num);
73 void draw_title_window(WINDOW *title);
74
75 /*! \brief Handle a window resize in xterm */
76 void winch_handler(int sig)
77 {
78         getmaxyx(stdscr, max_y, max_x);
79
80         if (max_x < MIN_X - 1 || max_y < MIN_Y - 1) {
81                 fprintf(stderr, "Terminal must be at least 80 x 25.\n");
82                 max_x = MIN_X - 1;
83                 max_y = MIN_Y - 1;
84         }
85 }
86
87 /*! \brief Display help information */
88 void show_help(WINDOW *win)
89 {
90         int i;
91
92         wclear(win);
93         for (i = 0; i < (sizeof(help_info) / sizeof(help_info[0])); i++) {
94                 wmove(win, i, max_x / 2 - 15);
95                 waddstr(win, help_info[i]);
96         }
97         wrefresh(win);
98         getch(); /* display the help until the user hits a key */
99 }
100
101 void draw_main_menu(WINDOW *menu, int curopt)
102 {
103         struct category *cat;
104         char buf[64];
105         int i = 0;
106
107         wclear(menu);
108
109         AST_LIST_TRAVERSE(&categories, cat, list) {
110                 wmove(menu, i++, max_x / 2 - 10);
111                 if (!strlen_zero(cat->displayname))
112                         snprintf(buf, sizeof(buf), "%d.%s %s", i, i < 10 ? " " : "", cat->displayname);
113                 else
114                         snprintf(buf, sizeof(buf), "%d.%s %s", i, i < 10 ? " " : "", cat->name);
115                 waddstr(menu, buf);
116         }
117
118         wmove(menu, curopt, (max_x / 2) - 15);
119         waddstr(menu, "--->");
120         wmove(menu, 0, 0);
121
122         wrefresh(menu);
123 }
124
125 void display_mem_info(WINDOW *menu, struct member *mem, int start, int end)
126 {
127         char buf[64];
128         struct depend *dep;
129         struct conflict *con;
130
131         wmove(menu, end - start + 2, max_x / 2 - 16);
132         wclrtoeol(menu);
133         wmove(menu, end - start + 3, max_x / 2 - 16);
134         wclrtoeol(menu);
135         wmove(menu, end - start + 4, max_x / 2 - 16);
136         wclrtoeol(menu);
137
138         if (mem->displayname) {
139                 wmove(menu, end - start + 2, max_x / 2 - 16);
140                 waddstr(menu, mem->displayname);
141         }
142         if (!AST_LIST_EMPTY(&mem->deps)) {
143                 wmove(menu, end - start + 3, max_x / 2 - 16);
144                 strcpy(buf, "Depends on: ");
145                 AST_LIST_TRAVERSE(&mem->deps, dep, list) {
146                         strncat(buf, dep->name, sizeof(buf) - strlen(buf) - 1);
147                         if (AST_LIST_NEXT(dep, list))
148                                 strncat(buf, ", ", sizeof(buf) - strlen(buf) - 1);
149                 }
150                 waddstr(menu, buf);
151         }
152         if (!AST_LIST_EMPTY(&mem->conflicts)) {
153                 wmove(menu, end - start + 4, max_x / 2 - 16);
154                 strcpy(buf, "Conflicts with: ");
155                 AST_LIST_TRAVERSE(&mem->conflicts, con, list) {
156                         strncat(buf, con->name, sizeof(buf) - strlen(buf) - 1);
157                         if (AST_LIST_NEXT(con, list))
158                                 strncat(buf, ", ", sizeof(buf) - strlen(buf) - 1);
159                 }
160                 waddstr(menu, buf);
161         }
162
163 }
164
165 void draw_category_menu(WINDOW *menu, struct category *cat, int start, int end, int curopt, int changed)
166 {
167         int i = 0;
168         int j = 0;
169         struct member *mem;
170         char buf[64];
171         const char *desc = NULL;
172
173         if (!changed) {
174                 /* If all we have to do is move the cursor, 
175                  * then don't clear the screen and start over */
176                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
177                         i++;
178                         if (curopt + 1 == i) {
179                                 display_mem_info(menu, mem, start, end);
180                                 break;
181                         }
182                 }
183                 wmove(menu, curopt - start, max_x / 2 - 9);
184                 wrefresh(menu);
185                 return;
186         }
187
188         wclear(menu);
189
190         i = 0;
191         AST_LIST_TRAVERSE(&cat->members, mem, list) {
192                 if (i < start) {
193                         i++;
194                         continue;
195                 }
196                 wmove(menu, j++, max_x / 2 - 10);
197                 i++;
198                 if (mem->depsfailed)
199                         snprintf(buf, sizeof(buf), "XXX %d.%s %s", i, i < 10 ? " " : "", mem->name);
200                 else
201                         snprintf(buf, sizeof(buf), "[%s] %d.%s %s", mem->enabled ? "*" : " ", i, i < 10 ? " " : "", mem->name);
202                 waddstr(menu, buf);
203                 
204                 if (curopt + 1 == i)
205                         display_mem_info(menu, mem, start, end);
206
207                 if (i == end)
208                         break;
209         }
210
211         wmove(menu, curopt - start, max_x / 2 - 9);
212         wrefresh(menu);
213 }
214
215 int run_category_menu(WINDOW *menu, int cat_num)
216 {
217         struct category *cat;
218         int i = 0;
219         int start = 0;
220         int end = max_y - TITLE_HEIGHT - 6;
221         int c;
222         int curopt = 0;
223         int maxopt;
224         int changed = 1;
225
226         AST_LIST_TRAVERSE(&categories, cat, list) {
227                 if (i++ == cat_num)
228                         break;
229         }
230         if (!cat)
231                 return -1;
232
233         maxopt = count_members(cat) - 1;
234
235         draw_category_menu(menu, cat, start, end, curopt, changed);
236
237         while ((c = getch())) {
238                 changed = 0;
239                 switch (c) {
240                 case KEY_UP:
241                         if (curopt > 0) {
242                                 curopt--;
243                                 if (curopt < start) {
244                                         start--;
245                                         end--;
246                                         changed = 1;
247                                 }
248                         }
249                         break;
250                 case KEY_DOWN:
251                         if (curopt < maxopt) {
252                                 curopt++;
253                                 if (curopt > end - 1) {
254                                         start++;
255                                         end++;
256                                         changed = 1;
257                                 }
258                         }
259                         break;
260                 case KEY_NPAGE:
261                         /* XXX Move down the list by PAGE_OFFSET */
262                         break;
263                 case KEY_PPAGE:
264                         /* XXX Move up the list by PAGE_OFFSET */
265                         break;
266                 case KEY_LEFT:
267                 case 27:        /* Esc key */
268                         return 0;
269                 case KEY_RIGHT:
270                 case KEY_ENTER:
271                 case '\n':
272                 case ' ':
273                         toggle_enabled(cat, curopt);
274                         changed = 1;
275                         break;
276                 case 'h':
277                 case 'H':
278                         show_help(menu);
279                         changed = 1;
280                         break;
281                 case KEY_F(7):
282                         set_all(cat, 0);
283                         changed = 1;
284                         break;
285                 case KEY_F(8):
286                         set_all(cat, 1);
287                         changed = 1;
288                 default:
289                         break;  
290                 }
291                 if (c == 'x' || c == 'X' || c == 'Q' || c == 'q')
292                         break;  
293                 draw_category_menu(menu, cat, start, end, curopt, changed);
294         }
295
296         wrefresh(menu);
297
298         return c;
299 }
300
301 void draw_title_window(WINDOW *title)
302 {
303         wmove(title, 1, (max_x / 2) - (strlen(MENU_TITLE1) / 2));
304         waddstr(title, MENU_TITLE1);
305         wmove(title, 2, (max_x / 2) - (strlen(MENU_TITLE2) / 2));
306         waddstr(title, MENU_TITLE2);
307         wmove(title, 3, (max_x / 2) - (strlen(MENU_TITLE3) / 2));
308         waddstr(title, MENU_TITLE3);
309         wmove(title, 5, (max_x / 2) - (strlen(MENU_HELP) / 2));
310         waddstr(title, MENU_HELP);
311         wrefresh(title);
312 }
313
314
315
316 int run_menu(void)
317 {
318         WINDOW *title;
319         WINDOW *menu;
320         int maxopt;
321         int curopt = 0;
322         int c;
323         int res = 0;
324
325         initscr();
326         getmaxyx(stdscr, max_y, max_x);
327         signal(SIGWINCH, winch_handler); /* handle window resizing in xterm */
328
329         if (max_x < MIN_X - 1 || max_y < MIN_Y - 1) {
330                 fprintf(stderr, "Terminal must be at least %d x %d.\n", MIN_X, MIN_Y);
331                 endwin();
332                 return -1;
333         }
334
335         cbreak(); /* don't buffer input until the enter key is pressed */
336         noecho(); /* don't echo user input to the screen */
337         keypad(stdscr, TRUE); /* allow the use of arrow keys */
338         clear();
339         refresh();
340
341         maxopt = count_categories() - 1;
342         
343         /* We have two windows - the title window at the top, and the menu window gets the rest */
344         title = newwin(TITLE_HEIGHT, max_x, 0, 0);
345         menu = newwin(max_y - TITLE_HEIGHT, max_x, TITLE_HEIGHT, 0);
346         draw_title_window(title);       
347         draw_main_menu(menu, curopt);
348         
349         while ((c = getch())) {
350                 switch (c) {
351                 case KEY_UP:
352                         if (curopt > 0)
353                                 curopt--;
354                         break;
355                 case KEY_DOWN:
356                         if (curopt < maxopt)
357                                 curopt++;
358                         break;
359                 case KEY_RIGHT:
360                 case KEY_ENTER:
361                 case '\n':
362                 case ' ':
363                         c = run_category_menu(menu, curopt);
364                         break;
365                 case 'h':
366                 case 'H':
367                         show_help(menu);
368                 default:
369                         break;  
370                 }
371                 if (c == 'q' || c == 'Q' || c == 27) {
372                         res = -1;
373                         break;
374                 }
375                 if (c == 'x' || c == 'X' || c == 's' || c == 'S')
376                         break;  
377                 draw_main_menu(menu, curopt);
378         }
379
380         endwin();
381
382         return res;
383 }