add the 'clean', 'clean-depend', and 'dist-clean' targets as .PHONY targets
[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 static int max_x = 0;
52 /*! Maximum number of characters vertically */
53 static int max_y = 0;
54
55 static 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 /*! \brief Handle a window resize in xterm */
68 static void winch_handler(int sig)
69 {
70         getmaxyx(stdscr, max_y, max_x);
71
72         if (max_x < MIN_X - 1 || max_y < MIN_Y - 1) {
73                 fprintf(stderr, "Terminal must be at least 80 x 25.\n");
74                 max_x = MIN_X - 1;
75                 max_y = MIN_Y - 1;
76         }
77 }
78
79 /*! \brief Display help information */
80 static void show_help(WINDOW *win)
81 {
82         int i;
83
84         wclear(win);
85         for (i = 0; i < (sizeof(help_info) / sizeof(help_info[0])); i++) {
86                 wmove(win, i, max_x / 2 - 15);
87                 waddstr(win, help_info[i]);
88         }
89         wrefresh(win);
90         getch(); /* display the help until the user hits a key */
91 }
92
93 static void draw_main_menu(WINDOW *menu, int curopt)
94 {
95         struct category *cat;
96         char buf[64];
97         int i = 0;
98
99         wclear(menu);
100
101         AST_LIST_TRAVERSE(&categories, cat, list) {
102                 wmove(menu, i++, max_x / 2 - 10);
103                 if (!strlen_zero(cat->displayname))
104                         snprintf(buf, sizeof(buf), "%d.%s %s", i, i < 10 ? " " : "", cat->displayname);
105                 else
106                         snprintf(buf, sizeof(buf), "%d.%s %s", i, i < 10 ? " " : "", cat->name);
107                 waddstr(menu, buf);
108         }
109
110         wmove(menu, curopt, (max_x / 2) - 15);
111         waddstr(menu, "--->");
112         wmove(menu, 0, 0);
113
114         wrefresh(menu);
115 }
116
117 static void display_mem_info(WINDOW *menu, struct member *mem, int start, int end)
118 {
119         char buf[64];
120         struct depend *dep;
121         struct conflict *con;
122
123         wmove(menu, end - start + 2, max_x / 2 - 16);
124         wclrtoeol(menu);
125         wmove(menu, end - start + 3, max_x / 2 - 16);
126         wclrtoeol(menu);
127         wmove(menu, end - start + 4, max_x / 2 - 16);
128         wclrtoeol(menu);
129
130         if (mem->displayname) {
131                 wmove(menu, end - start + 2, max_x / 2 - 16);
132                 waddstr(menu, mem->displayname);
133         }
134         if (!AST_LIST_EMPTY(&mem->deps)) {
135                 wmove(menu, end - start + 3, max_x / 2 - 16);
136                 strcpy(buf, "Depends on: ");
137                 AST_LIST_TRAVERSE(&mem->deps, dep, list) {
138                         strncat(buf, dep->name, sizeof(buf) - strlen(buf) - 1);
139                         if (AST_LIST_NEXT(dep, list))
140                                 strncat(buf, ", ", sizeof(buf) - strlen(buf) - 1);
141                 }
142                 waddstr(menu, buf);
143         }
144         if (!AST_LIST_EMPTY(&mem->conflicts)) {
145                 wmove(menu, end - start + 4, max_x / 2 - 16);
146                 strcpy(buf, "Conflicts with: ");
147                 AST_LIST_TRAVERSE(&mem->conflicts, con, list) {
148                         strncat(buf, con->name, sizeof(buf) - strlen(buf) - 1);
149                         if (AST_LIST_NEXT(con, list))
150                                 strncat(buf, ", ", sizeof(buf) - strlen(buf) - 1);
151                 }
152                 waddstr(menu, buf);
153         }
154
155 }
156
157 static void draw_category_menu(WINDOW *menu, struct category *cat, int start, int end, int curopt, int changed)
158 {
159         int i = 0;
160         int j = 0;
161         struct member *mem;
162         char buf[64];
163
164         if (!changed) {
165                 /* If all we have to do is move the cursor, 
166                  * then don't clear the screen and start over */
167                 AST_LIST_TRAVERSE(&cat->members, mem, list) {
168                         i++;
169                         if (curopt + 1 == i) {
170                                 display_mem_info(menu, mem, start, end);
171                                 break;
172                         }
173                 }
174                 wmove(menu, curopt - start, max_x / 2 - 9);
175                 wrefresh(menu);
176                 return;
177         }
178
179         wclear(menu);
180
181         i = 0;
182         AST_LIST_TRAVERSE(&cat->members, mem, list) {
183                 if (i < start) {
184                         i++;
185                         continue;
186                 }
187                 wmove(menu, j++, max_x / 2 - 10);
188                 i++;
189                 if (mem->depsfailed)
190                         snprintf(buf, sizeof(buf), "XXX %d.%s %s", i, i < 10 ? " " : "", mem->name);
191                 else
192                         snprintf(buf, sizeof(buf), "[%s] %d.%s %s", mem->enabled ? "*" : " ", i, i < 10 ? " " : "", mem->name);
193                 waddstr(menu, buf);
194                 
195                 if (curopt + 1 == i)
196                         display_mem_info(menu, mem, start, end);
197
198                 if (i == end)
199                         break;
200         }
201
202         wmove(menu, curopt - start, max_x / 2 - 9);
203         wrefresh(menu);
204 }
205
206 static int run_category_menu(WINDOW *menu, int cat_num)
207 {
208         struct category *cat;
209         int i = 0;
210         int start = 0;
211         int end = max_y - TITLE_HEIGHT - 6;
212         int c;
213         int curopt = 0;
214         int maxopt;
215         int changed = 1;
216
217         AST_LIST_TRAVERSE(&categories, cat, list) {
218                 if (i++ == cat_num)
219                         break;
220         }
221         if (!cat)
222                 return -1;
223
224         maxopt = count_members(cat) - 1;
225
226         draw_category_menu(menu, cat, start, end, curopt, changed);
227
228         while ((c = getch())) {
229                 changed = 0;
230                 switch (c) {
231                 case KEY_UP:
232                         if (curopt > 0) {
233                                 curopt--;
234                                 if (curopt < start) {
235                                         start--;
236                                         end--;
237                                         changed = 1;
238                                 }
239                         }
240                         break;
241                 case KEY_DOWN:
242                         if (curopt < maxopt) {
243                                 curopt++;
244                                 if (curopt > end - 1) {
245                                         start++;
246                                         end++;
247                                         changed = 1;
248                                 }
249                         }
250                         break;
251                 case KEY_NPAGE:
252                         /* XXX Move down the list by PAGE_OFFSET */
253                         break;
254                 case KEY_PPAGE:
255                         /* XXX Move up the list by PAGE_OFFSET */
256                         break;
257                 case KEY_LEFT:
258                 case 27:        /* Esc key */
259                         return 0;
260                 case KEY_RIGHT:
261                 case KEY_ENTER:
262                 case '\n':
263                 case ' ':
264                         toggle_enabled(cat, curopt);
265                         changed = 1;
266                         break;
267                 case 'h':
268                 case 'H':
269                         show_help(menu);
270                         changed = 1;
271                         break;
272                 case KEY_F(7):
273                         set_all(cat, 0);
274                         changed = 1;
275                         break;
276                 case KEY_F(8):
277                         set_all(cat, 1);
278                         changed = 1;
279                 default:
280                         break;  
281                 }
282                 if (c == 'x' || c == 'X' || c == 'Q' || c == 'q')
283                         break;  
284                 draw_category_menu(menu, cat, start, end, curopt, changed);
285         }
286
287         wrefresh(menu);
288
289         return c;
290 }
291
292 static void draw_title_window(WINDOW *title)
293 {
294         wmove(title, 1, (max_x / 2) - (strlen(MENU_TITLE1) / 2));
295         waddstr(title, MENU_TITLE1);
296         wmove(title, 2, (max_x / 2) - (strlen(MENU_TITLE2) / 2));
297         waddstr(title, MENU_TITLE2);
298         wmove(title, 3, (max_x / 2) - (strlen(MENU_TITLE3) / 2));
299         waddstr(title, MENU_TITLE3);
300         wmove(title, 5, (max_x / 2) - (strlen(MENU_HELP) / 2));
301         waddstr(title, MENU_HELP);
302         wrefresh(title);
303 }
304
305
306
307 int run_menu(void)
308 {
309         WINDOW *title;
310         WINDOW *menu;
311         int maxopt;
312         int curopt = 0;
313         int c;
314         int res = 0;
315
316         initscr();
317         getmaxyx(stdscr, max_y, max_x);
318         signal(SIGWINCH, winch_handler); /* handle window resizing in xterm */
319
320         if (max_x < MIN_X - 1 || max_y < MIN_Y - 1) {
321                 fprintf(stderr, "Terminal must be at least %d x %d.\n", MIN_X, MIN_Y);
322                 endwin();
323                 return -1;
324         }
325
326         cbreak(); /* don't buffer input until the enter key is pressed */
327         noecho(); /* don't echo user input to the screen */
328         keypad(stdscr, TRUE); /* allow the use of arrow keys */
329         clear();
330         refresh();
331
332         maxopt = count_categories() - 1;
333         
334         /* We have two windows - the title window at the top, and the menu window gets the rest */
335         title = newwin(TITLE_HEIGHT, max_x, 0, 0);
336         menu = newwin(max_y - TITLE_HEIGHT, max_x, TITLE_HEIGHT, 0);
337         draw_title_window(title);       
338         draw_main_menu(menu, curopt);
339         
340         while ((c = getch())) {
341                 switch (c) {
342                 case KEY_UP:
343                         if (curopt > 0)
344                                 curopt--;
345                         break;
346                 case KEY_DOWN:
347                         if (curopt < maxopt)
348                                 curopt++;
349                         break;
350                 case KEY_RIGHT:
351                 case KEY_ENTER:
352                 case '\n':
353                 case ' ':
354                         c = run_category_menu(menu, curopt);
355                         break;
356                 case 'h':
357                 case 'H':
358                         show_help(menu);
359                 default:
360                         break;  
361                 }
362                 if (c == 'q' || c == 'Q' || c == 27) {
363                         res = -1;
364                         break;
365                 }
366                 if (c == 'x' || c == 'X' || c == 's' || c == 'S')
367                         break;  
368                 draw_main_menu(menu, curopt);
369         }
370
371         endwin();
372
373         return res;
374 }