Thanks to the fine work of Russell Bryant and Dancho Lazarov, we now have autoconf...
[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 "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
41 #define TITLE_HEIGHT    5
42
43 #define MIN_X           80
44 #define MIN_Y           20
45
46 #define PAGE_OFFSET     10
47
48
49 /*! Maximum number of characters horizontally */
50 int max_x = 0;
51 /*! Maximum number of characters vertically */
52 int max_y = 0;
53
54 const char * const help_info[] = {
55         "scroll        => up/down arrows",
56         "(de)select    => Enter",
57         "select all    => F8",
58         "deselect all  => F7",
59         "back          => left arrow",
60         "quit          => q",
61         "save and quit => x",
62         "",
63         "XXX means dependencies have not been met"
64 };
65
66 void winch_handler(int sig);
67 void show_help(WINDOW *win);
68 void draw_main_menu(WINDOW *menu, int curopt);
69 void draw_category_menu(WINDOW *menu, struct category *cat, int start, int end, int curopt);
70 int run_category_menu(WINDOW *menu, int cat_num);
71 int run_category_menu(WINDOW *menu, int cat_num);
72 void draw_title_window(WINDOW *title);
73
74 /*! \brief Handle a window resize in xterm */
75 void winch_handler(int sig)
76 {
77         getmaxyx(stdscr, max_y, max_x);
78
79         if (max_x < MIN_X - 1 || max_y < MIN_Y - 1) {
80                 fprintf(stderr, "Terminal must be at least 80 x 25.\n");
81                 max_x = MIN_X - 1;
82                 max_y = MIN_Y - 1;
83         }
84 }
85
86 /*! \brief Display help information */
87 void show_help(WINDOW *win)
88 {
89         int i;
90
91         wclear(win);
92         for (i = 0; i < (sizeof(help_info) / sizeof(help_info[0])); i++) {
93                 wmove(win, i, max_x / 2 - 15);
94                 waddstr(win, help_info[i]);
95         }
96         wrefresh(win);
97         getch(); /* display the help until the user hits a key */
98 }
99
100 void draw_main_menu(WINDOW *menu, int curopt)
101 {
102         struct category *cat;
103         char buf[64];
104         int i = 0;
105
106         wclear(menu);
107
108         AST_LIST_TRAVERSE(&categories, cat, list) {
109                 wmove(menu, i++, max_x / 2 - 10);
110                 if (!strlen_zero(cat->displayname))
111                         snprintf(buf, sizeof(buf), "%d.%s %s", i, i < 10 ? " " : "", cat->displayname);
112                 else
113                         snprintf(buf, sizeof(buf), "%d.%s %s", i, i < 10 ? " " : "", cat->name);
114                 waddstr(menu, buf);
115         }
116
117         wmove(menu, curopt, (max_x / 2) - 15);
118         waddstr(menu, "--->");
119         wmove(menu, 0, 0);
120
121         wrefresh(menu);
122 }
123
124 void draw_category_menu(WINDOW *menu, struct category *cat, int start, int end, int curopt)
125 {
126         int i = 0;
127         int j = 0;
128         struct member *mem;
129         char buf[64];
130
131         wclear(menu);
132
133         AST_LIST_TRAVERSE(&cat->members, mem, list) {
134                 if (i < start) {
135                         i++;
136                         continue;
137                 }
138                 wmove(menu, j++, max_x / 2 - 10);
139                 i++;
140                 if (mem->depsfailed)
141                         snprintf(buf, sizeof(buf), "XXX %d.%s %s", i, i < 10 ? " " : "", mem->name);
142                 else
143                         snprintf(buf, sizeof(buf), "[%s] %d.%s %s", mem->enabled ? "*" : " ", i, i < 10 ? " " : "", mem->name);
144                 waddstr(menu, buf);
145                 if (i == end)
146                         break;
147         }
148
149         wmove(menu, curopt - start, max_x / 2 - 9);
150
151         wrefresh(menu);
152 }
153
154 int run_category_menu(WINDOW *menu, int cat_num)
155 {
156         struct category *cat;
157         int i = 0;
158         int start = 0;
159         int end = max_y - TITLE_HEIGHT - 2;
160         int c;
161         int curopt = 0;
162         int maxopt;
163
164         AST_LIST_TRAVERSE(&categories, cat, list) {
165                 if (i++ == cat_num)
166                         break;
167         }
168         if (!cat)
169                 return -1;
170
171         maxopt = count_members(cat) - 1;
172
173         draw_category_menu(menu, cat, start, end, curopt);
174
175         while ((c = getch())) {
176                 switch (c) {
177                 case KEY_UP:
178                         if (curopt > 0) {
179                                 curopt--;
180                                 if (curopt < start) {
181                                         start--;
182                                         end--;
183                                 }
184                         }
185                         break;
186                 case KEY_DOWN:
187                         if (curopt < maxopt) {
188                                 curopt++;
189                                 if (curopt > end - 1) {
190                                         start++;
191                                         end++;
192                                 }
193                         }
194                         break;
195                 case KEY_NPAGE:
196                         /* XXX Move down the list by PAGE_OFFSET */
197                         break;
198                 case KEY_PPAGE:
199                         /* XXX Move up the list by PAGE_OFFSET */
200                         break;
201                 case KEY_LEFT:
202                         return 0;
203                 case KEY_RIGHT:
204                 case KEY_ENTER:
205                 case '\n':
206                 case ' ':
207                         toggle_enabled(cat, curopt);
208                         break;
209                 case 'h':
210                 case 'H':
211                         show_help(menu);
212                         break;
213                 case KEY_F(7):
214                         set_all(cat, 0);
215                         break;
216                 case KEY_F(8):
217                         set_all(cat, 1);
218                 default:
219                         break;  
220                 }
221                 if (c == 'x' || c == 'q')
222                         break;  
223                 draw_category_menu(menu, cat, start, end, curopt);
224         }
225
226         wrefresh(menu);
227
228         return c;
229 }
230
231 void draw_title_window(WINDOW *title)
232 {
233         wmove(title, 1, (max_x / 2) - (strlen(MENU_TITLE1) / 2));
234         waddstr(title, MENU_TITLE1);
235         wmove(title, 2, (max_x / 2) - (strlen(MENU_TITLE2) / 2));
236         waddstr(title, MENU_TITLE2);
237         wmove(title, 3, (max_x / 2) - (strlen(MENU_TITLE3) / 2));
238         waddstr(title, MENU_TITLE3);
239         wmove(title, 0, 0);
240         wrefresh(title);
241 }
242
243
244
245 int run_menu(void)
246 {
247         WINDOW *title;
248         WINDOW *menu;
249         int maxopt;
250         int curopt = 0;
251         int c;
252         int res = 0;
253
254         initscr();
255         getmaxyx(stdscr, max_y, max_x);
256         signal(SIGWINCH, winch_handler); /* handle window resizing in xterm */
257
258         if (max_x < MIN_X - 1 || max_y < MIN_Y - 1) {
259                 fprintf(stderr, "Terminal must be at least %d x %d.\n", MIN_X, MIN_Y);
260                 endwin();
261                 return -1;
262         }
263
264         cbreak(); /* don't buffer input until the enter key is pressed */
265         noecho(); /* don't echo user input to the screen */
266         keypad(stdscr, TRUE); /* allow the use of arrow keys */
267         clear();
268         refresh();
269
270         maxopt = count_categories() - 1;
271         
272         /* We have two windows - the title window at the top, and the menu window gets the rest */
273         title = newwin(TITLE_HEIGHT, max_x, 0, 0);
274         menu = newwin(max_y - TITLE_HEIGHT, max_x, TITLE_HEIGHT, 0);
275         draw_title_window(title);       
276         draw_main_menu(menu, curopt);
277         
278         while ((c = getch())) {
279                 switch (c) {
280                 case KEY_UP:
281                         if (curopt > 0)
282                                 curopt--;
283                         break;
284                 case KEY_DOWN:
285                         if (curopt < maxopt)
286                                 curopt++;
287                         break;
288                 case KEY_RIGHT:
289                 case KEY_ENTER:
290                 case '\n':
291                 case ' ':
292                         c = run_category_menu(menu, curopt);
293                         break;
294                 case 'h':
295                 case 'H':
296                         show_help(menu);
297                 default:
298                         break;  
299                 }
300                 if (c == 'q') {
301                         res = -1;
302                         break;
303                 }
304                 if (c == 'x')
305                         break;  
306                 draw_main_menu(menu, curopt);
307         }
308
309         endwin();
310
311         return res;
312 }