Beispiel #1
0
/*ARGSUSED*/
int
menu_import(WINDOW *win, node_t *current, node_t *list)
{
    char inv_path[MAXPATHLEN];
    struct stat s;
    char *fstabname;
    data_t *d;

    for(;;) {
	inv_path[0] = '\0';

	if(get_string(win, "Path to inventory to be imported: ", inv_path, MAXPATHLEN) == ERR) {
	    put_error("Error: invalid input");
	    continue;
	}
	if(strlen(inv_path) == 0) {
	    clear_line(stdscr, LINES - 1);
	    return BOOL_FALSE;
	}
	if(stat(inv_path, &s) < 0 || !S_ISDIR(s.st_mode)) {
	    put_error("Error: invalid path");
	    continue;
	}
	clear_line(stdscr, LINES - 1);

	fstabname = GetFstabFullPath(inv_path);
	if(fstabname == NULL) {
	    put_footer("internal memory error: import inventory", ALIGN_LEFT);
	    exit(1);
	}

	while(current->next != NULL) {
	    current = current->next;
	}
	generate_fstab_menu(inv_path, current, 0, fstabname);
	free(fstabname);

	while(current->next != NULL) {
	    current = current->next;
	    d = current->data;
	    d->text[1] = 'I';
	    d->imported = BOOL_TRUE;
	}
	redraw_screen = BOOL_TRUE;
	break;
    }

    return BOOL_FALSE;
}
Beispiel #2
0
int
menu(WINDOW *win, int line, int col, node_t *list, int keyc, menukey_t *keyv)
{
    int c;
    int k;
    int quit;
    char txt[256];
    node_t *current;
    node_t *last;
    data_t *d;
    int current_line;
    int last_line;
    int size;

    current = list;
    last = current;
    current_line = 0;
    last_line = current_line;

    redraw_screen = BOOL_TRUE;

    quit = BOOL_FALSE;
    while(quit != BOOL_TRUE) {
        if(current == NULL && current->data == NULL) {
            current = list;
        }
        d = (data_t *)(current->data);

        if(redraw_screen == BOOL_TRUE) {
            wclear(win);
            snprintf(txt, sizeof(txt), "%s: %s", g_programName, g_programVersion);
            put_header(txt, ALIGN_LEFT);
            if(d->hidden == BOOL_TRUE) {
                current = list;
                current_line = 0;
                d = (data_t *)(current->data);
            }
            put_all_options(win, list, current);
            redraw_screen = BOOL_FALSE;

            if(d->ops != NULL && d->ops->op_highlight != NULL) {
                quit = d->ops->op_highlight(win, current, list);
            }
        }
        else if (last != current || redraw_options) {
            put_option(win, last_line, ((data_t *)(last->data))->text, 0);
            put_option(win, current_line, d->text, A_REVERSE);

            redraw_options = BOOL_FALSE;

            if(((data_t *)(last->data))->ops != NULL
                    && ((data_t *)(last->data))->ops->op_unhighlight != NULL) {
                quit = ((data_t *)(last->data))->ops->op_unhighlight(win, current, list);
            }
            if(d->ops != NULL && d->ops->op_highlight != NULL) {
                quit = d->ops->op_highlight(win, current, list);
            }
        }

        last = current;
        last_line = current_line;

        wrefresh(stdscr);
        wrefresh(infowin);
        size = (LINES - 2) - INFO_SIZE;
        prefresh(win,
                 current_line - (size - 1), 0,
                 line, col,
                 size, COLS - 1);

        if(quit == BOOL_TRUE)
            continue;

        c=wgetch(win);
        switch(c) {
        case '?':
        case KEY_F(1):
            /* online help */
            put_helpscreen(keyc, keyv);
            redraw_screen = BOOL_TRUE;
            break;
        case KEY_UP:
        case 'k':
            /* go to previous option */
        {
            data_t *d;
            node_t *n = current->prev;

            while(n != NULL) {
                d = ((data_t *)(n->data));
                if(d == NULL) {
                    n = n->prev;
                    continue;
                }
                if(d->hidden == BOOL_FALSE) {
                    break;
                }
                n = n->prev;
            }
            if(n != NULL) {
                current = n;
                current_line--;
            }
        }
        break;
        case KEY_DOWN:
        case 'j':
            /* go to next option */
        {
            data_t *d;
            node_t *n = current->next;

            while(n != NULL) {
                d = ((data_t *)(n->data));
                if(d == NULL) {
                    n = n->next;
                    continue;
                }
                if(d->hidden == BOOL_FALSE) {
                    break;
                }
                n = n->next;
            }
            if(n != NULL) {
                current = n;
                current_line++;
            }
        }
        break;
        case KEY_RIGHT:
        case 'l':
            /* go to next child */
        {
            node_t *n = current->next;
            int l;

            if(current != NULL && ((data_t *)(current->data)) == NULL) {
                break;
            }
            l = ((data_t *)(current->data))->level;
            if(n != NULL && ((data_t *)(n->data)) != NULL && ((data_t *)(n->data))->level > l) {
                if(((data_t *)(n->data))->hidden == BOOL_TRUE) {
                    menu_expand(win, current, list);
                }
                current = n;
                current_line++;
            }
        }
        break;
        case KEY_LEFT:
        case 'h':
            /* go to parent */
        {
            data_t *d;
            node_t *n = current->prev;
            int l = 0;
            int i;

            if(current != NULL && ((data_t *)(current->data)) != NULL) {
                l = ((data_t *)(current->data))->level;
            }
            i = current_line - 1;
            while(n != NULL) {
                d = ((data_t *)(n->data));
                if(d == NULL) {
                    n = n->prev;
                    continue;
                }
                if(d->hidden == BOOL_TRUE) {
                    n = n->prev;
                    continue;
                }
                if(d->level < l) {
                    break;
                }
                n = n->prev;
                i--;
            }
            if(n != NULL) {
                current = n;
                current_line = i;;
            }
        }
        break;
        case ERR:
            if(errno == EINTR) {
                /* mainmenu window has been recreated - use new one */
                win = mainmenu;
            }
            break;
        default:
            for(k = 0; k < keyc; k++) {
                if(c == keyv[k].key || tolower(c) == keyv[k].key) {
                    if (keyv[k].fn != NULL) {
                        quit = keyv[k].fn(win, current, list);
                        break;
                    }
                    else {
                        put_footer("internal error: can't execute function", ALIGN_CENTRE);
                        break;
                    }
                }
            }
            break;
        }
    }

    return 0;
}