mirror of
https://git.hardenedbsd.org/hardenedbsd/HardenedBSD.git
synced 2024-11-29 04:21:26 +01:00
679 lines
15 KiB
C
679 lines
15 KiB
C
/*-
|
||
* Copyright (c) 1995
|
||
* Paul Richards. All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions
|
||
* are met:
|
||
* 1. Redistributions of source code must retain the above copyright
|
||
* notice, this list of conditions and the following disclaimer,
|
||
* verbatim and that no modifications are made prior to this
|
||
* point in the file.
|
||
* 2. Redistributions in binary form must reproduce the above copyright
|
||
* notice, this list of conditions and the following disclaimer in the
|
||
* documentation and/or other materials provided with the distribution.
|
||
* 3. All advertising materials mentioning features or use of this software
|
||
* must display the following acknowledgement:
|
||
* This product includes software developed by Paul Richards.
|
||
* 4. The name Paul Richards may not be used to endorse or promote products
|
||
* derived from this software without specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY PAUL RICHARDS ``AS IS'' AND
|
||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||
* ARE DISCLAIMED. IN NO EVENT SHALL PAUL RICHARDS BE LIABLE
|
||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||
* SUCH DAMAGE.
|
||
*
|
||
*/
|
||
|
||
#include <strhash.h>
|
||
#include <ctype.h>
|
||
#include <err.h>
|
||
#include <ncurses.h>
|
||
#include <forms.h>
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
|
||
#include "internal.h"
|
||
|
||
extern hash_table *global_bindings;
|
||
|
||
struct attr_cmd {
|
||
char *name;
|
||
int attr;
|
||
};
|
||
|
||
static struct attr_cmd attr_cmds[] = {
|
||
{ "standout", 0x00010000},
|
||
{ "underline", 0x00020000},
|
||
{ "reverse", 0x00040000},
|
||
{ "blink", 0x00080000},
|
||
{ "bold", 0x00200000 }
|
||
};
|
||
|
||
int done=0;
|
||
|
||
int
|
||
init_field(char *key, void *data, void *arg)
|
||
{
|
||
struct Tuple *tuple = (struct Tuple *)data;
|
||
struct Tuple *def_tuple;
|
||
struct Field *def, *field;
|
||
int i;
|
||
int len, lim;
|
||
int strwidth;
|
||
|
||
field = (struct Field *)tuple->addr;
|
||
|
||
/* Field definitions are global, at least for now */
|
||
def_tuple = form_get_tuple(global_bindings, field->defname, FT_FIELD_DEF);
|
||
if (!def_tuple) {
|
||
warnx("Field definition not found -- skipping field");
|
||
return (-1);
|
||
}
|
||
|
||
def = (struct Field *)def_tuple->addr;
|
||
field->height = def->height;
|
||
field->width = def->width;
|
||
field->attr = def->attr;
|
||
field->selattr = def->selattr;
|
||
field->type = def->type;
|
||
switch (field->type) {
|
||
case FF_INPUT:
|
||
field->field.input = malloc(sizeof (struct InputField));
|
||
if (!field->field.input) {
|
||
warnx("Couldn't allocate memory for input field");
|
||
return (-1);
|
||
}
|
||
field->field.input->limit = def->field.input->limit;
|
||
|
||
/* Force height to one regardless, at least for now :-) */
|
||
field->height = 1;
|
||
if (!field->width && !field->field.input->limit) {
|
||
field->width = calc_string_width(def->field.input->label);
|
||
field->field.input->limit = field->width;
|
||
} else if (!field->width)
|
||
field->width = field->field.input->limit;
|
||
else if (!field->field.input->limit)
|
||
field->field.input->limit = field->width;
|
||
if (field->field.input->limit < field->width)
|
||
field->width = field->field.input->limit;
|
||
|
||
strwidth = strlen(def->field.input->label);
|
||
field->field.input->input = malloc(strwidth + 1);
|
||
if (!field->field.input->input) {
|
||
warnx("Couldn't allocate memory for input field text");
|
||
return (-1);
|
||
}
|
||
field->field.input->label = malloc(strwidth + 1);
|
||
if (!field->field.input->label) {
|
||
warnx("Couldn't allocate memory for input field label");
|
||
return (-1);
|
||
}
|
||
strncpy(field->field.input->label,
|
||
def->field.input->label,
|
||
strwidth + 1);
|
||
field->field.input->lbl_flag = def->field.input->lbl_flag;
|
||
|
||
/*
|
||
* If it's a label then clear the input string
|
||
* otherwise copy the default there.
|
||
*/
|
||
if (field->field.input->lbl_flag)
|
||
field->field.input->input[0] = '\0';
|
||
else if (field->field.input->label) {
|
||
strncpy(field->field.input->input,
|
||
field->field.input->label,
|
||
strwidth + 1);
|
||
field->field.input->input[strwidth] = 0;
|
||
}
|
||
break;
|
||
case FF_TEXT:
|
||
field->field.text = malloc(sizeof (struct TextField));
|
||
if (!field->field.text) {
|
||
warnx("Couldn't allocate memory for text field");
|
||
return (FS_ERROR);
|
||
}
|
||
strwidth = strlen(def->field.text->text);
|
||
if (!field->width)
|
||
field->width = calc_string_width(def->field.text->text);
|
||
field->field.text->text = malloc(strwidth + 1);
|
||
if (!field->field.text->text) {
|
||
warnx("Couldn't allocate memory for text field text");
|
||
return (FS_ERROR);
|
||
} else
|
||
strncpy(field->field.text->text,
|
||
def->field.text->text,
|
||
strwidth + 1);
|
||
if (!field->height)
|
||
calc_field_height(field, field->field.text->text);
|
||
break;
|
||
case FF_MENU:
|
||
field->field.menu = malloc(sizeof (struct MenuField));
|
||
if (!field->field.menu) {
|
||
warnx("Couldn't allocate memory for menu field");
|
||
return (FS_ERROR);
|
||
}
|
||
field->field.menu->no_options = 0;
|
||
field->height = 1;
|
||
lim = 0;
|
||
for (i=0; i < def->field.menu->no_options; i++) {
|
||
field->field.menu->no_options =
|
||
add_menu_option(field->field.menu,
|
||
def->field.menu->options[i]);
|
||
if (!field->field.menu->no_options) {
|
||
warnx("Couldn't add menu option");
|
||
return (FS_ERROR);
|
||
}
|
||
len = calc_string_width(def->field.menu->options[i]);
|
||
if (len > lim)
|
||
lim = len;
|
||
}
|
||
if (!field->width)
|
||
field->width = lim;
|
||
break;
|
||
case FF_ACTION:
|
||
field->field.action = malloc(sizeof (struct ActionField));
|
||
if (!field->field.action) {
|
||
warnx("Couldn't allocate memory for action field");
|
||
return (FS_ERROR);
|
||
}
|
||
if (!field->width)
|
||
field->width = calc_string_width(def->field.action->text);
|
||
strwidth = strlen(def->field.action->text);
|
||
field->field.action->text = malloc(strwidth + 1);
|
||
if (!field->field.action->text) {
|
||
warnx("Couldn't allocate memory for text field text");
|
||
return (FS_ERROR);
|
||
} else
|
||
strncpy(field->field.action->text,
|
||
def->field.action->text,
|
||
strwidth + 1);
|
||
if (!field->height)
|
||
calc_field_height(field, field->field.action->text);
|
||
field->field.action->fn = def->field.action->fn;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return (1);
|
||
}
|
||
|
||
void
|
||
display_field(WINDOW *window, struct Field *field)
|
||
{
|
||
wattrset(window, field->attr);
|
||
wmove(window, field->y, field->x);
|
||
switch (field->type) {
|
||
case FF_TEXT:
|
||
display_text(window, field);
|
||
break;
|
||
case FF_MENU:
|
||
display_menu(window, field);
|
||
break;
|
||
case FF_INPUT:
|
||
display_input(window, field);
|
||
break;
|
||
case FF_ACTION:
|
||
display_action(window, field);
|
||
break;
|
||
case FF_UNKNOWN:
|
||
default:
|
||
break;
|
||
}
|
||
wattrset(window, 0);
|
||
wrefresh(window);
|
||
}
|
||
|
||
void
|
||
display_text(WINDOW *window, struct Field *field)
|
||
{
|
||
|
||
if (print_string(window, field->y, field->x, field->height,
|
||
field->width, field->field.text->text) == ERR)
|
||
print_status("Illegal scroll in print_string");
|
||
}
|
||
|
||
void
|
||
display_input(WINDOW *window, struct Field *field)
|
||
{
|
||
if (field->field.input->lbl_flag) {
|
||
if (print_string(window, field->y, field->x, field->height,
|
||
field->width, field->field.input->label) == ERR)
|
||
print_status("Illegal scroll in print_string");
|
||
} else
|
||
if (print_string(window, field->y, field->x, field->height,
|
||
field->width, field->field.input->input) == ERR)
|
||
print_status("Illegal scroll in print_string");
|
||
}
|
||
|
||
void
|
||
display_menu(WINDOW *window, struct Field *field)
|
||
{
|
||
if (print_string(window, field->y, field->x,
|
||
field->height, field->width,
|
||
field->field.menu->options[field->field.menu->selected]) == ERR)
|
||
print_status("Illegal scroll in print_string");
|
||
}
|
||
|
||
void
|
||
display_action(WINDOW *window, struct Field *field)
|
||
{
|
||
if (print_string(window, field->y, field->x, field->height,
|
||
field->width,
|
||
field->field.action->text) == ERR)
|
||
print_status("Illegal scroll in print_string");
|
||
}
|
||
|
||
int
|
||
do_action(struct Form *form)
|
||
{
|
||
struct Field *field = form->current_field;
|
||
struct Tuple *tuple;
|
||
int ch;
|
||
void (* fn)();
|
||
|
||
display_action(form->window, field);
|
||
wmove(form->window, field->y, field->x);
|
||
|
||
for (;;) {
|
||
|
||
ch = wgetch(form->window);
|
||
|
||
if (ch == FK_ACCEPT) {
|
||
tuple = form_get_tuple(form->bindings, field->field.action->fn, FT_FUNC);
|
||
if (!tuple) {
|
||
print_status("No function bound to action");
|
||
beep();
|
||
continue;
|
||
} else {
|
||
fn = tuple->addr;
|
||
(*fn)(form);
|
||
return (FS_OK);
|
||
}
|
||
} else
|
||
ch = do_key_bind(form, ch);
|
||
|
||
if (ch == FS_OK)
|
||
return (FS_OK);
|
||
else if (ch == FS_ERROR)
|
||
continue;
|
||
}
|
||
}
|
||
|
||
int
|
||
do_menu(struct Form *form)
|
||
{
|
||
struct Field *field = form->current_field;
|
||
int ch;
|
||
|
||
|
||
for (;;) {
|
||
|
||
display_menu(form->window, field);
|
||
wmove(form->window, field->y, field->x);
|
||
|
||
ch = wgetch(form->window);
|
||
|
||
switch (ch) {
|
||
case ' ':
|
||
print_status("");
|
||
field->field.menu->selected++;
|
||
if (field->field.menu->selected >= field->field.menu->no_options)
|
||
field->field.menu->selected = 0;
|
||
ch = FS_OK;
|
||
break;
|
||
default:
|
||
ch = do_key_bind(form, ch);
|
||
break;
|
||
}
|
||
|
||
if (ch == FS_OK)
|
||
return (FS_OK);
|
||
else if (ch == FS_ERROR) {
|
||
beep();
|
||
continue;
|
||
} else {
|
||
print_status("Hit the space bar to toggle through options");
|
||
beep();
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
|
||
int
|
||
do_field(struct Form *form)
|
||
{
|
||
struct Tuple *tuple;
|
||
struct Field *field = form->current_field;
|
||
void (* fn)();
|
||
int status;
|
||
|
||
/* Do field entry tasks */
|
||
if (field->enter) {
|
||
tuple = form_get_tuple(form->bindings, field->enter, FT_FUNC);
|
||
|
||
if (tuple) {
|
||
fn = tuple->addr;
|
||
(*fn)(form);
|
||
}
|
||
}
|
||
|
||
switch (field->type) {
|
||
case FF_TEXT:
|
||
status = FS_OK;
|
||
display_text(form->window, field);
|
||
break;
|
||
case FF_INPUT:
|
||
status = do_input(form);
|
||
break;
|
||
case FF_MENU:
|
||
status = do_menu(form);
|
||
break;
|
||
case FF_ACTION:
|
||
status = do_action(form);
|
||
break;
|
||
default:
|
||
status = FF_UNKNOWN;
|
||
beep();
|
||
print_status("Unknown field type");
|
||
form->current_field = form->prev_field;
|
||
break;
|
||
}
|
||
|
||
/* Do field leave tasks */
|
||
if (field->leave) {
|
||
tuple = form_get_tuple(form->bindings, field->leave, FT_FUNC);
|
||
|
||
if (tuple) {
|
||
fn = tuple->addr;
|
||
(*fn)(form);
|
||
}
|
||
}
|
||
|
||
return (status);
|
||
}
|
||
|
||
int
|
||
parse_attr(WINDOW *window, char *string)
|
||
{
|
||
int inc = 0;
|
||
struct attr_cmd *attr;
|
||
|
||
if (*(string) == '\\')
|
||
return (1);
|
||
|
||
while (!isspace(*(string + inc))) {
|
||
inc++;
|
||
}
|
||
|
||
for (attr = attr_cmds; attr->name; attr++) {
|
||
if (strncmp(attr->name, string, inc))
|
||
continue;
|
||
else {
|
||
wattron(window, attr->attr);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Skip trailing space after the attribute string */
|
||
while (isspace(*(string + inc)))
|
||
inc++;
|
||
|
||
return (inc);
|
||
}
|
||
|
||
int
|
||
print_string(WINDOW *window, int y, int x,
|
||
int height, int fwidth, char *string)
|
||
{
|
||
int len, skip;
|
||
int width;
|
||
|
||
if (!string)
|
||
len = -1;
|
||
|
||
len = strlen(string);
|
||
|
||
if (wmove(window, y, x) == ERR)
|
||
return (ERR);
|
||
while (height--) {
|
||
width = fwidth;
|
||
while (width--) {
|
||
if (len-- > 0) {
|
||
if (*string == '\\') {
|
||
string++;
|
||
len--;
|
||
skip = parse_attr(window, string);
|
||
len -= skip;
|
||
string += skip;
|
||
}
|
||
if (waddch(window, *string++) == ERR)
|
||
return (ERR);
|
||
} else if (waddch(window, ' ') == ERR)
|
||
return (ERR);
|
||
}
|
||
if (wmove(window, ++y, x) == ERR)
|
||
return (ERR);
|
||
}
|
||
return (OK);
|
||
}
|
||
|
||
void
|
||
print_status(char *msg)
|
||
{
|
||
if (wmove(stdscr, LINES-1, 0) == ERR) {
|
||
endwin();
|
||
exit(1);
|
||
}
|
||
|
||
wclrtoeol(stdscr);
|
||
|
||
wstandout(stdscr);
|
||
if (wprintw(stdscr, "%s",
|
||
msg) == ERR) {
|
||
endwin();
|
||
exit(1);
|
||
}
|
||
wstandend(stdscr);
|
||
wrefresh(stdscr);
|
||
}
|
||
|
||
|
||
int
|
||
do_input(struct Form *form)
|
||
{
|
||
struct Field *field = form->current_field;
|
||
int len;
|
||
int disp_off=0, abspos=0, cursor = 0;
|
||
unsigned int ch;
|
||
|
||
#define DISPOFF ((len < field->width) ? 0 : len - field->width)
|
||
#define CURSPOS ((len < field->width) ? len : field->width)
|
||
|
||
len = strlen(field->field.input->input);
|
||
display_input(form->window, field);
|
||
|
||
cursor = CURSPOS;
|
||
abspos = cursor;
|
||
|
||
for (;;) {
|
||
|
||
wmove(form->window, field->y, field->x+cursor);
|
||
wrefresh(form->window);
|
||
|
||
ch = wgetch(form->window);
|
||
ch = do_key_bind(form, ch);
|
||
|
||
/*
|
||
* If there was a valid motion command then we've
|
||
* moved to a new field so just return. If the motion
|
||
* command was invalid then just go around and get another
|
||
* keystroke. Otherwise, it was not a motion command.
|
||
*/
|
||
|
||
if (ch == FS_OK)
|
||
return (FS_OK);
|
||
else if (ch == FS_ERROR)
|
||
continue;
|
||
|
||
print_status("");
|
||
|
||
if (field->field.input->lbl_flag) {
|
||
field->field.input->lbl_flag = 0;
|
||
}
|
||
if ((ch == FK_CHOME) || (ch == '')) {
|
||
disp_off = 0;
|
||
cursor = 0;
|
||
abspos = 0;
|
||
} else if ((ch == FK_CEND) || (ch == '')) {
|
||
disp_off = DISPOFF;
|
||
abspos = len;
|
||
cursor = CURSPOS;
|
||
} else if (ch == FK_CDEL) {
|
||
if (!(len-abspos))
|
||
beep();
|
||
else {
|
||
bcopy(field->field.input->input+abspos+1,
|
||
field->field.input->input+abspos,
|
||
len - abspos);
|
||
--len;
|
||
}
|
||
} else if ((ch == FK_CLEFT) || (ch == FK_CBS) || (ch == '')) {
|
||
if (!abspos)
|
||
beep();
|
||
else {
|
||
if (ch == FK_CBS) {
|
||
bcopy(field->field.input->input+abspos,
|
||
field->field.input->input+abspos-1,
|
||
len-abspos+1);
|
||
--len;
|
||
}
|
||
--abspos;
|
||
--cursor;
|
||
if ((disp_off) && (cursor < 0)) {
|
||
--disp_off;
|
||
++cursor;
|
||
}
|
||
}
|
||
} else if ((ch == FK_CRIGHT) || (ch == '')) {
|
||
if (abspos == len)
|
||
beep();
|
||
else {
|
||
++abspos;
|
||
if (++cursor >= field->width) {
|
||
++disp_off;
|
||
--cursor;
|
||
}
|
||
}
|
||
} else if ((isprint(ch)) && (len < field->field.input->limit)){
|
||
bcopy(field->field.input->input+abspos,
|
||
field->field.input->input+abspos+1, len-abspos+1);
|
||
field->field.input->input[abspos++] = ch;
|
||
len++;
|
||
if (++cursor > field->width) {
|
||
++disp_off;
|
||
--cursor;
|
||
}
|
||
} else
|
||
beep();
|
||
print_string(form->window, field->y, field->x, field->height,
|
||
field->width, field->field.input->input+disp_off);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Calculate length of printable part of the string,
|
||
* stripping out the attribute modifiers.
|
||
*/
|
||
|
||
int
|
||
calc_string_width(char *string)
|
||
{
|
||
int len, width=0;
|
||
|
||
if (!string)
|
||
return (0);
|
||
|
||
len = strlen(string);
|
||
|
||
while (len) {
|
||
if (*string != '\\') {
|
||
width++;
|
||
len--;
|
||
string++;
|
||
continue;
|
||
} else {
|
||
string++;
|
||
len--;
|
||
if (*string == '\\') {
|
||
string++;
|
||
width++;
|
||
len--;
|
||
continue;
|
||
} else {
|
||
while (!isspace(*string)) {
|
||
string++;
|
||
len--;
|
||
}
|
||
while (isspace(*string)) {
|
||
string ++;
|
||
len--;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return (width);
|
||
}
|
||
|
||
/* Calculate a default height for a field */
|
||
|
||
void
|
||
calc_field_height(struct Field *field, char *string)
|
||
{
|
||
|
||
int len;
|
||
|
||
len = calc_string_width(string);
|
||
|
||
if (!field->width) {
|
||
/*
|
||
* This is a failsafe, this routine shouldn't be called
|
||
* with a width of 0, the width should be determined
|
||
* first.
|
||
*/
|
||
field->height = 1;
|
||
return;
|
||
}
|
||
|
||
if (len < field->width) {
|
||
field->height = 1;
|
||
return;
|
||
} else
|
||
field->height = len / field->width;
|
||
|
||
if ((field->height*field->width) < len)
|
||
field->height++;
|
||
|
||
return;
|
||
}
|
||
|
||
void
|
||
exit_form(struct Form *form)
|
||
{
|
||
form->status = FS_EXIT;
|
||
}
|
||
|
||
void
|
||
cancel_form(struct Form *form)
|
||
{
|
||
form->status = FS_CANCEL;
|
||
}
|