/*
* Move using the given form driver request.
* De-highlights the old selection and highlights the new one.
*/
void ListBox::selectField(int formDriverReq) {
//Unhighlight cur field
set_field_back(current_field(m_pForm), A_NORMAL);
form_driver(m_pForm, formDriverReq);
form_driver(m_pForm, REQ_BEG_LINE);
set_field_back(current_field(m_pForm), A_STANDOUT);
}
void ListBox::setCurRow(int r) {
set_field_back(current_field(m_pForm), A_NORMAL);
form_driver(m_pForm, REQ_FIRST_FIELD);
for (int i = 0; i < r; i++) {
form_driver(m_pForm, REQ_NEXT_FIELD);
}
form_driver(m_pForm, REQ_BEG_LINE);
set_field_back(current_field(m_pForm), A_STANDOUT);
m_curRow = r;
}
/*
* stransform keys into menu commands
*/
static int wdg_input_virtualize(struct wdg_object *wo, int key)
{
WDG_WO_EXT(struct wdg_input_handle, ww);
int c;
switch (key) {
case KEY_RETURN:
case KEY_EXIT:
c = MAX_FORM_COMMAND + 1;
break;
case KEY_UP:
case KEY_LEFT:
c = REQ_PREV_FIELD;
/* we are moving... unfocus the current field */
set_field_back(current_field(ww->form), A_UNDERLINE);
break;
case KEY_DOWN:
case KEY_RIGHT:
c = REQ_NEXT_FIELD;
/* we are moving... unfocus the current field */
set_field_back(current_field(ww->form), A_UNDERLINE);
break;
case KEY_BACKSPACE:
case '\b':
case 127: /* how many code does it have ?? argh !! */
c = REQ_DEL_PREV;
break;
case KEY_DC:
c = REQ_DEL_CHAR;
break;
case KEY_HOME:
c = REQ_BEG_FIELD;
break;
case KEY_END:
c = REQ_END_FIELD;
break;
default:
c = key;
break;
}
/*
* Force the field that the user is typing into to be in reverse video,
* while the other fields are shown underlined.
*/
//if (c <= KEY_MAX)
// set_field_back(current_field(ww->form), A_REVERSE);
//else if (c <= MAX_FORM_COMMAND)
// set_field_back(current_field(ww->form), A_UNDERLINE);
return c;
}
gint viper_form_driver(FORM *form,gint request,guint32 flags,
chtype active,chtype normal,gshort cursor_color)
{
WINDOW *window;
chtype eraser;
chtype temp_ch;
gint x,y;
gint retval;
gshort fg,bg;
if(form==NULL) return ERR;
if(form_sub(form)!=form_win(form)) window=form_sub(form);
else window=form_win(form);
getyx(window,y,x);
eraser=field_back(current_field(form));
mvwchgat(window,y,x,1,(eraser & A_ATTRIBUTES),
PAIR_NUMBER(eraser & A_COLOR),NULL);
retval=form_driver(form,request);
if(flags & FORM_COLORIZE)
viper_form_colorize(form,active,normal,active,normal);
if(flags & FORM_CURSOR_NONE) return retval;
temp_ch=termattrs();
if((flags & FORM_CURSOR_ULINE) && !(temp_ch & A_UNDERLINE)) return ERR;
getyx(window,y,x);
temp_ch=field_fore(current_field(form));
if(flags & FORM_CURSOR_ULINE)
mvwchgat(window,y,x,1,(temp_ch & A_ATTRIBUTES) | A_UNDERLINE,
PAIR_NUMBER(temp_ch & A_COLOR),NULL);
else
{
pair_content(PAIR_NUMBER(temp_ch & A_COLOR),&fg,&bg);
if(cursor_color!=-1)
{
bg=cursor_color;
mvwchgat(window,y,x,1,A_NORMAL,viper_color_pair(fg,bg),NULL);
}
else mvwchgat(window,y,x,1,A_REVERSE,viper_color_pair(fg,bg),NULL);
}
return E_OK;
}
/*
* sends command to the form
*/
static int wdg_input_driver(struct wdg_object *wo, int key, struct wdg_mouse_event *mouse)
{
WDG_WO_EXT(struct wdg_input_handle, ww);
int c, v;
/* variable currently not used */
(void) mouse;
WDG_DEBUG_MSG("keypress driver: %d", key);
/* virtualize the command */
c = form_driver(ww->form, (v = wdg_input_virtualize(wo, key)) );
set_field_back(current_field(ww->form), A_REVERSE);
/* one item has been selected */
if (c == E_UNKNOWN_COMMAND) {
/* send a command to the form in order to validate the current field */
form_driver(ww->form, REQ_NEXT_FIELD);
/*
* put the temp buffer in the real one
* call the callback
* and destroy the object
*/
wdg_input_consolidate(wo);
return WDG_EFINISHED;
}
wnoutrefresh(ww->fwin);
return WDG_E_SUCCESS;
}
int
save_draw(ui_t *ui)
{
char field_value[80];
// Get panel information
save_info_t *info = save_info(ui);
// Get filter stats
sip_stats_t stats = sip_calls_stats();
mvwprintw(ui->win, 7, 3, "( ) all dialogs ");
mvwprintw(ui->win, 8, 3, "( ) selected dialogs [%d]", call_group_count(info->group));
mvwprintw(ui->win, 9, 3, "( ) filtered dialogs [%d]", stats.displayed);
// Print 'current SIP message' field label if required
if (info->msg != NULL)
mvwprintw(ui->win, 10, 3, "( ) current SIP message");
mvwprintw(ui->win, 7, 35, "( ) .pcap (SIP)");
mvwprintw(ui->win, 8, 35, "( ) .pcap (SIP + RTP)");
mvwprintw(ui->win, 9, 35, "( ) .txt");
// Get filename field value.
memset(field_value, 0, sizeof(field_value));
strcpy(field_value, field_buffer(info->fields[FLD_SAVE_FILE], 0));
strtrim(field_value);
mvwprintw(ui->win, 4, 60, " ");
if (strstr(field_value, ".pcap")) {
info->saveformat = (setting_enabled(SETTING_CAPTURE_RTP))? SAVE_PCAP_RTP : SAVE_PCAP;
} else if (strstr(field_value, ".txt")) {
info->saveformat = SAVE_TXT;
} else {
if (info->saveformat == SAVE_PCAP || info->saveformat == SAVE_PCAP_RTP)
mvwprintw(ui->win, 4, 60, ".pcap");
else
mvwprintw(ui->win, 4, 60, ".txt ");
}
set_field_buffer(info->fields[FLD_SAVE_ALL], 0, (info->savemode == SAVE_ALL) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_SELECTED], 0,
(info->savemode == SAVE_SELECTED) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_DISPLAYED], 0,
(info->savemode == SAVE_DISPLAYED) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_MESSAGE], 0,
(info->savemode == SAVE_MESSAGE) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_PCAP], 0, (info->saveformat == SAVE_PCAP) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_PCAP_RTP], 0, (info->saveformat == SAVE_PCAP_RTP) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_TXT], 0, (info->saveformat == SAVE_TXT) ? "*" : " ");
// Show disabled options with makers
if (!setting_enabled(SETTING_CAPTURE_RTP))
set_field_buffer(info->fields[FLD_SAVE_PCAP_RTP], 0, "-");
set_current_field(info->form, current_field(info->form));
form_driver(info->form, REQ_VALIDATION);
return 0;
}
static int
offset_in_field(FORM * form)
{
FIELD *field = current_field(form);
int currow, curcol;
form_getyx(form, currow, curcol);
return curcol + currow * field->dcols;
}
void ListBox::setSelected(bool sel) {
Component::setSelected(sel);
if (sel) {
selectField(REQ_FIRST_FIELD);
} else {
set_field_back(current_field(m_pForm), A_NORMAL);
form_driver(m_pForm, REQ_BEG_LINE);
}
m_curRow = 0;
wrefresh(m_pPanel->getWindow());
}
bool DialogForm::isFieldValid() {
FIELD* pField = current_field(m_pForm);
if (pField == 0) {
return true;
}
//Get field type
/*void* usrPtr = field_userptr(pField);
FieldType type = usrPtr == 0 ? FIELDTYPE_NONE : *(FieldType*)usrPtr;
//Get field text
std::string fieldText = field_buffer(pField, 0);
StringUtil::trimEnd(fieldText);*/
//Check if field is valid
if (form_driver(m_pForm, REQ_VALIDATION) == E_INVALID_FIELD/* || (type == FIELDTYPE_EMAIL && !isValidEmail(fieldText)) || (type == FIELDTYPE_NAME && !isValidName(fieldText))*/) {
//Field is invalid, highlight it
set_field_back(current_field(m_pForm), A_STANDOUT);
return false;
}
set_field_back(current_field(m_pForm), A_UNDERLINE);
return true;
}
static int
my_form_driver(FORM * form, int c)
{
static bool insert_mode = TRUE;
FIELD *field;
switch (c) {
case MY_QUIT:
if (form_driver(form, REQ_VALIDATION) == E_OK)
return (TRUE);
break;
case MY_HELP:
help_edit_field();
break;
case MY_EDT_MODE:
if ((field = current_field(form)) != 0) {
set_current_field(form, another_field(form, field));
if ((unsigned) field_opts(field) & O_EDIT) {
field_opts_off(field, O_EDIT);
set_field_status(field, 0);
} else {
field_opts_on(field, O_EDIT);
}
set_current_field(form, field);
}
break;
case MY_INS_MODE:
/* there should be a form_status() function, but there is none */
if (!insert_mode) {
if (form_driver(form, REQ_INS_MODE) == E_OK) {
insert_mode = TRUE;
}
} else {
if (form_driver(form, REQ_OVL_MODE) == E_OK) {
insert_mode = FALSE;
}
}
show_insert_mode(insert_mode);
refresh();
break;
default:
beep();
break;
}
return (FALSE);
}
/*
* create the internal form
*/
static void wdg_input_form_create(struct wdg_object *wo)
{
WDG_WO_EXT(struct wdg_input_handle, ww);
int mrows, mcols;
size_t c = wdg_get_ncols(wo);
size_t x = wdg_get_begin_x(wo);
size_t y = wdg_get_begin_y(wo);
/* the form is already posted */
if (ww->form)
return;
/* create the form */
ww->form = new_form(ww->fields);
/* get the geometry to make a window */
scale_form(ww->form, &mrows, &mcols);
/* create the window for the form */
ww->fwin = newwin(mrows, MAX(mcols, (int)c - 4), y + 1, x + 2);
/* set the color */
wbkgd(ww->fwin, COLOR_PAIR(wo->window_color));
keypad(ww->fwin, TRUE);
/* associate with the form */
set_form_win(ww->form, ww->fwin);
/* the subwin for the form */
set_form_sub(ww->form, derwin(ww->fwin, mrows + 1, mcols, 1, 1));
/* make the active field in reverse mode */
set_field_back(current_field(ww->form), A_REVERSE);
/* display the form */
post_form(ww->form);
wnoutrefresh(ww->fwin);
}
bool ListBox::handleKeyPress(int key) {
if (key == KEY_UP) {
//Move up a field
selectField(REQ_PREV_FIELD);
m_curRow = (m_curRow == 0) ? m_numRows - 1 : m_curRow - 1;
return true;
} else if (key == KEY_DOWN || key == 9) { //Tab key
//Move down a field
selectField(REQ_NEXT_FIELD);
m_curRow = (m_curRow == m_numRows - 1) ? 0 : m_curRow + 1;
return true;
} else if (key == KEY_BACKSPACE || key == 127) {
//Delete prev. char
// form_driver(m_pForm, REQ_DEL_PREV);
return true;
} else if (key == 330) { //Delete key TODO: Fix this
//Delete next char
// form_driver(m_pForm, REQ_DEL_PREV);
return true;
} else {
FIELD *pField = current_field(m_pForm);
if (field_userptr(pField) != 0) {
#ifdef DEBUG
dout << "Create new row" << std::endl;
#endif
addRow("");
if (key == CuTAES::KEY_ENT) {
//Clear field
set_field_buffer(pField, 0, "");
return true;
}
}
//Send key to form driver
form_driver(m_pForm, key);
}
wrefresh(m_pPanel->getWindow());
return false;
}
void exec_action_context_service_config(int ch)
{
FIELD *field;
int cur_page = form_page(my_form);
switch (ch) {
case KEY_DOWN:
form_driver(my_form, REQ_NEXT_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_NPAGE:
form_driver(my_form, REQ_NEXT_PAGE);
set_form_page(my_form, ++cur_page);
__renderers_services_config_paging();
break;
case KEY_PPAGE:
form_driver(my_form, REQ_PREV_PAGE);
set_form_page(my_form, --cur_page);
__renderers_services_config_paging();
break;
case KEY_ENTER:
case 10:
field = current_field(my_form);
__ncurses_print_info_in_footer(false,
field_buffer(field, 0));
break;
}
}
void viper_form_colorize(FORM *form,chtype field_active,chtype field_normal,
chtype text_active,chtype text_normal)
{
FIELD **fields;
fields=form_fields(form);
while(*fields!=NULL)
{
if(*fields==current_field(form))
{
set_field_fore(*fields,text_active);
set_field_back(*fields,field_active);
}
else
{
set_field_fore(*fields,text_normal);
set_field_back(*fields,field_normal);
}
fields++;
}
return;
}
void summons_dataentry_scr(const char *curr_path, const char *case_num) {
const size_t n_fields = 6;
const size_t starty = 6;
const size_t startx = 25;
FIELD *field[n_fields];
FORM *my_form;
Summon_t record;
int width[] = { MAX_SUMM_NAME, MAX_SUMM_STATUS, MAX_SUMM_REASON,
MAX_SUMM_CITY, MAX_SUMM_DATE
};
for ( size_t i = 0; i < n_fields - 1; ++i )
field[i] = new_field(1, width[i], starty + i * 2, startx, 0, 0);
field[n_fields - 1] = NULL;
set_field_back( field[0], A_UNDERLINE );
field_opts_off( field[0], O_AUTOSKIP );
set_field_back( field[1], A_UNDERLINE );
field_opts_on( field[1], O_BLANK );
field_opts_off( field[1], O_AUTOSKIP );
set_field_back( field[2], A_UNDERLINE );
field_opts_off( field[2], O_AUTOSKIP );
field_opts_on( field[2], O_BLANK );
set_field_back( field[3], A_UNDERLINE );
field_opts_off( field[3], O_AUTOSKIP );
field_opts_on( field[3], O_BLANK );
set_field_back( field[4], A_UNDERLINE );
field_opts_off( field[4], O_AUTOSKIP );
my_form = new_form(field);
post_form(my_form);
refresh();
mvprintw( 0, 0, curr_path );
mvprintw( 4, 10, "Case Number: %s", case_num );
mvprintw( 6, 10, "Person: " );
mvprintw( 8, 10, "Status: " );
mvprintw( 10, 10, "Reason: " );
mvprintw( 12, 10, "City: " );
mvprintw( 14, 10, "Date Summoned: " );
mvprintw( 16, 10, "(F1) = Options | (F2) = Update | (F3) = Delete | (F5) = List | (ESC) = Main Menu" );
set_visible_fields( field, 1, 5 );
move( 6, 25 );
set_current_field( my_form, field[0] );
record.id = 0;
int ch;
do {
ch = getch();
switch ( ch ) {
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_LEFT:
form_driver(my_form, REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form, REQ_RIGHT_CHAR);
break;
case KEY_BACKSPACE:
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case ENTER:
form_driver( my_form, REQ_NEXT_FIELD );
if ( current_field( my_form ) == field[0] )
form_driver( my_form, REQ_END_LINE );
break;
case KEY_F(1):
clear_lines( 20, 40 );
{
FIELD * curr_fld = current_field( my_form );
size_t error = 0;
size_t in_target_fld = 0;
char fld_name[7];
if ( curr_fld == field[1] ) {
error = query_select_all_codes_from_summon_status();
in_target_fld = 1;
strncpy( fld_name, "Status", 7 );
} else if ( curr_fld == field[2] ) {
error = query_select_all_codes_from_summon_reasons();
in_target_fld = 1;
strncpy( fld_name, "Reason", 7 );
} else if ( curr_fld == field[3] ) {
if ( query_select_all_codes_from_city_rates() ) {
clear_line(20, 10);
mvprintw( 20, 10, db_get_error_msg() );
move( 12, 25 );
set_current_field( my_form, curr_fld );
} else {
const SCode_t const * scode_ptr;
size_t count = 0;
size_t column = 10;
mvprintw( 20, 5, "Cities:" );
while ( ( scode_ptr = get_scode_from_result() ) != NULL ) {
mvprintw( 21 + count++, column, "[%s] %s", scode_ptr->code, scode_ptr->name );
if ( count == 30 ) {
column += 20;
count = 0;
}
}
free_scode_result();
}
}
if ( !error && in_target_fld ) {
const Code_t const * code_ptr;
size_t count = 0;
mvprintw( 20, 5, "%s Options:", fld_name );
while ( ( code_ptr = get_code_from_result() ) != NULL )
mvprintw( 21 + count++, 10, "[%d] %s", code_ptr->code, code_ptr->desc );
free_code_result();
}
int row, col;
get_cursor_pos( curr_fld, &row, &col );
move( row, col );
set_current_field( my_form, curr_fld );
}
break;
case KEY_F(2):
clear_lines( 20, 40 );
char person_name[MAX_SUMM_NAME];
strncpy( person_name, field_buffer(field[0], 0), MAX_SUMM_NAME );
if ( is_empty_str( person_name, MAX_SUMM_NAME ) ) {
mvprintw( 20, 10, "[!] Summon must at least have the person's name." );
move( 6, 25 );
set_current_field( my_form, field[0] );
break;
}
strncpy( record.case_num, case_num, MAX_CANUM );
strncpy( record.name, field_buffer(field[0], 0), MAX_SUMM_NAME );
record.status = atoi( compress_str( field_buffer(field[1], 0) ) );
record.reason = atoi( compress_str( field_buffer(field[2], 0) ) );
strncpy( record.city_code, compress_str( field_buffer(field[3], 0) ), MAX_SUMM_CITY );
strncpy( record.summon_date, compress_str( field_buffer(field[4], 0) ), MAX_SUMM_DATE );
if ( query_update_summon( &record ) ) {
mvprintw( 20, 10, db_get_error_msg() );
move( 6, 25 );
set_current_field( my_form, field[0] );
} else {
clear_fields( field, 0, 4 );
mvprintw( 20, 10, "[!] Summon has been updated." );
move( 6, 25 );
set_current_field( my_form, field[0] );
record.id = 0;
}
break;
case KEY_F(3):
clear_lines( 20, 40 );
if ( record.id > 0 ) {
mvprintw( 20, 10, "[?] Delete summon '%u' ? [Y/n]", record.id );
int ch = toupper( getch() );
if ( ch == 'Y' ) {
if ( query_delete_summon( record.id ) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
clear_fields( field, 0, 4 );
mvprintw( 20, 10, "[!] Summon '%u' has been deleted.", record.id );
move( 6, 25 );
set_current_field( my_form, field[0] );
record.id = 0;
}
}
}
break;
case KEY_F(5):
clear_lines( 20, 40 );
if ( query_select_all_from_summons_for( case_num ) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
Summon_t *summ_ptr;
Summon_t *summons[MAX_SUMM_SET];
size_t count = 0;
while ( ( summ_ptr = get_summon_from_result() ) != NULL ) {
summons[count] = summ_ptr;
count++;
}
if ( count ) {
size_t selection;
char code_buff[4];
summons_list_scr( summons, count, &selection );
if ( selection > 0 ) {
summ_ptr = summons[selection - 1];
record.id = summ_ptr->id;
set_field_buffer( field[0], 0, summ_ptr->name );
snprintf( code_buff, 4, "%d", summ_ptr->status );
set_field_buffer( field[1], 0, code_buff );
snprintf( code_buff, 4, "%d", summ_ptr->reason );
set_field_buffer( field[2], 0, code_buff );
set_field_buffer( field[3], 0, summ_ptr->city_code );
set_field_buffer( field[4], 0, summ_ptr->summon_date );
}
free_summon_result();
} else {
mvprintw( 20, 10, "[!] Case %s has no summons.", case_num );
}
}
set_current_field( my_form, field[0] );
move( 6, 25 );
break;
default:
{
FIELD * curr_fld = current_field( my_form );
if ( ch == '\'' )
break;
if ( curr_fld == field[1] || curr_fld == field[2] ) {
if ( !isdigit( ch ) )
break;
} else if ( curr_fld == field[3] ) {
if ( !isalpha( ch ) )
break;
else
ch = toupper( ch );
}
form_driver( my_form, ch );
break;
}
}
} while ( ch != ESC );
unpost_form( my_form );
free_form( my_form );
for ( size_t i = 0; i < n_fields - 1; ++i )
free_field( field[i] );
return;
}
int
column_select_handle_key_form(ui_t *ui, int key)
{
int field_idx, new_field_idx;
char field_value[48];
int action = -1;
// Get panel information
column_select_info_t *info = column_select_info(ui);
// Get current field id
field_idx = field_index(current_field(info->form));
// Get current field value.
memset(field_value, 0, sizeof(field_value));
strcpy(field_value, field_buffer(current_field(info->form), 0));
strtrim(field_value);
// Check actions for this key
while ((action = key_find_action(key, action)) != ERR) {
// Check if we handle this action
switch (action) {
case ACTION_RIGHT:
case ACTION_NEXT_FIELD:
form_driver(info->form, REQ_NEXT_FIELD);
break;
case ACTION_LEFT:
case ACTION_PREV_FIELD:
form_driver(info->form, REQ_PREV_FIELD);
break;
case ACTION_SELECT:
case ACTION_CONFIRM:
switch(field_idx) {
case FLD_COLUMNS_ACCEPT:
column_select_update_columns(ui);
ui_destroy(ui);
return KEY_HANDLED;
case FLD_COLUMNS_CANCEL:
ui_destroy(ui);
return KEY_HANDLED;
case FLD_COLUMNS_SAVE:
column_select_update_columns(ui);
column_select_save_columns(ui);
ui_destroy(ui);
return KEY_HANDLED;
}
break;
default:
// Parse next action
continue;
}
// This panel has handled the key successfully
break;
}
// Validate all input data
form_driver(info->form, REQ_VALIDATION);
// Change background and cursor of "button fields"
set_field_back(info->fields[FLD_COLUMNS_ACCEPT], A_NORMAL);
set_field_back(info->fields[FLD_COLUMNS_SAVE], A_NORMAL);
set_field_back(info->fields[FLD_COLUMNS_CANCEL], A_NORMAL);
// Get current selected field
new_field_idx = field_index(current_field(info->form));
// Swap between menu and form
if (field_idx == FLD_COLUMNS_CANCEL && new_field_idx == FLD_COLUMNS_ACCEPT) {
set_menu_fore(info->menu, COLOR_PAIR(CP_DEF_ON_BLUE));
info->form_active = 0;
} else {
// Change current field background
set_field_back(info->fields[new_field_idx], A_REVERSE);
}
// Return if this panel has handled or not the key
return (action == ERR) ? KEY_NOT_HANDLED : KEY_HANDLED;
}
void cases_menu(const char *curr_path) {
const char *screen_title = "Cases";
const size_t n_fields = 7;
const size_t starty = 4;
const size_t startx = 25;
FIELD *field[n_fields];
FORM *my_form;
int width[] = { MAX_CANUM, MAX_CINUM,
MAX_PHYADD, MAX_POSADD,
MAX_STATUS, MAX_DELDATE
};
initscr();
curs_set(1);
cbreak();
clear();
noecho();
keypad(stdscr, TRUE);
for (size_t i = 0; i < n_fields - 1; ++i) {
field[i] = new_field(1, width[i], starty + i * 2, startx, 0, 0);
}
field[n_fields - 1] = NULL;
set_field_back(field[0], A_UNDERLINE);
field_opts_off(field[0], O_AUTOSKIP);
field_opts_on(field[0], O_BLANK);
set_field_back(field[1], A_UNDERLINE);
field_opts_off(field[1], O_AUTOSKIP);
set_field_back(field[2], A_UNDERLINE);
field_opts_off(field[2], O_AUTOSKIP);
set_field_back(field[3], A_UNDERLINE);
field_opts_off(field[3], O_AUTOSKIP);
set_field_back(field[4], A_UNDERLINE);
field_opts_off(field[4], O_AUTOSKIP);
set_field_back(field[5], A_UNDERLINE);
field_opts_off(field[5], O_AUTOSKIP);
my_form = new_form(field);
post_form(my_form);
refresh();
mvprintw(0, 0, menu_path(curr_path, screen_title));
mvprintw(4, 10, "Case Num: ");
mvprintw(6, 10, "Civil Num: ");
mvprintw(8, 10, "Physical Add: ");
mvprintw(10, 10, "Postal Add: ");
mvprintw(12, 10, "Status: ");
mvprintw(14, 10, "Delivery Date: ");
mvprintw(16, 10, "(F1) = Options | (F2) = Update | (F3) = Delete | (F4) = Exit");
move(4, 25);
refresh();
int ch;
do {
ch = getch();
switch(ch) {
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_LEFT:
form_driver(my_form, REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form, REQ_RIGHT_CHAR);
break;
case ENTER:
form_driver( my_form, REQ_NEXT_FIELD );
form_driver( my_form, REQ_END_LINE );
if (field_status(field[0])) {
size_t count = 0;
char case_num[MAX_CANUM];
clear_line( 20, 10 );
strcpy( case_num, compress_str(field_buffer(field[0], 0) ) );
if ( query_select_count_from_case_for(case_num, &count) ) {
mvprintw( 20, 10, db_get_error_msg() );
move( 4, 25 );
} else {
if ( count ) {
//call routine to fill in fields
Case_t record;
if ( query_select_all_from_case_for(case_num, &record) ) {
mvprintw( 20, 10, db_get_error_msg() );
move( 4, 25 );
} else {
char status_buff[4];
set_field_buffer( field[1], 0, record.civil );
set_field_buffer( field[2], 0, record.physical_add );
set_field_buffer( field[3], 0, record.postal_add );
snprintf( status_buff, 4, "%d", record.status );
set_field_buffer( field[4], 0, status_buff );
set_field_buffer( field[5], 0, record.delivery_date );
}
} else {
clear_fields( field, 1, 5 );
mvprintw( 20, 10, "[!] Case %s does not exist.", case_num );
move( 6, 25 );
set_current_field( my_form, field[0] );
}
}
set_field_status( field[0], 0 );
}
break;
case KEY_BACKSPACE:
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case ESC:
{
FIELD * curr_field = current_field( my_form );
int row, col;
get_cursor_pos( curr_field, &row, &col );
clear_lines( 20, 40 );
move( row, col );
set_current_field( my_form, curr_field );
}
break;
case KEY_F(1):
if ( current_field( my_form ) == field[4] ) {
clear_lines( 20, 30 );
if ( query_select_all_codes_from_case_status() ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
const Code_t const * code_ptr;
size_t count = 0;
mvprintw( 20, 5, "Status Options:" );
while ( ( code_ptr = get_code_from_result() ) != NULL ) {
mvprintw( 21 + count, 10, "[%d] %s", code_ptr->code, code_ptr->desc );
count++;
}
free_code_result();
move( 12, 25 );
set_current_field( my_form, field[4] );
}
}
break;
case KEY_F(2):
{
size_t count = 0;
char case_num[MAX_CANUM];
clear_lines( 20, 30 );
strncpy( case_num, compress_str(field_buffer(field[0], 0) ), MAX_CANUM );
if ( query_select_count_from_case_for( case_num, &count ) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
Case_t record;
strncpy( record.number, compress_str(field_buffer(field[0], 0)), MAX_CANUM );
strncpy( record.civil, compress_str(field_buffer(field[1], 0)), MAX_CINUM );
strncpy( record.physical_add, field_buffer(field[2], 0), MAX_PHYADD );
strncpy( record.postal_add, field_buffer(field[3], 0), MAX_POSADD );
record.status = atoi( compress_str(field_buffer(field[4], 0)) );
strncpy( record.delivery_date, compress_str(field_buffer(field[5], 0)), MAX_DELDATE );
if ( count ) {
// update existing record
if ( query_update_case( &record ) == 0 ) {
mvprintw( 20, 10, "[!] Case has been updated." );
} else {
mvprintw( 20, 10, db_get_error_msg() );
}
} else {
// create new record
if ( query_create_new_case( &record ) == 0 ) {
mvprintw (20, 10, "[!] Case has been created successfully." );
} else {
mvprintw( 20, 10, db_get_error_msg() );
}
}
}
move(4, 25);
set_current_field( my_form, field[0] );
}
break;
case KEY_F(3):
{
size_t count = 0;
char case_num[MAX_CANUM];
clear_lines(20, 30);
strncpy(case_num, compress_str(field_buffer(field[0], 0) ), MAX_CANUM);
if ( strlen(case_num) ) {
if ( query_select_count_from_case_for(case_num, &count) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
if (count) {
mvprintw(20, 10, "[?] Delete case '%s' ? [Y/n]", case_num);
int ch = toupper(getch());
if (ch == 'Y') {
if ( query_delete_case(case_num) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
clear_fields(field, 0, 5);
mvprintw(20, 10, "[!] Case '%s' has been deleted.");
}
}
} else {
mvprintw(20, 10, "[!] Case '%s' does not exist.", case_num);
}
}
} else {
mvprintw(20, 10, "[!] Must enter a valid Case Number to be deleted.");
}
}
move(4, 25);
set_current_field(my_form, field[0]);
break;
case DEL:
form_driver(my_form, REQ_DEL_CHAR);
break;
default:
{
FIELD * curr_fld = current_field( my_form );
if ( ch == '\'' )
break;
if ( curr_fld == field[4] ) {
if ( !isdigit( ch ) )
break;
}
}
form_driver(my_form, ch);
break;
}
} while( ch != KEY_F(4) );
unpost_form(my_form);
free_form(my_form);
for (size_t i = 0; i < n_fields -1; ++i) {
free_field(field[i]);
}
endwin();
return;
}
int
save_raw_handle_key(PANEL *panel, int key)
{
int field_idx;
char field_value[48];
int action = -1;
// Get panel information
save_raw_info_t *info = (save_raw_info_t*) panel_userptr(panel);
// Get current field id
field_idx = field_index(current_field(info->form));
// Get current field value.
// We trim spaces with sscanf because and empty field is stored as
// space characters
memset(field_value, 0, sizeof(field_value));
sscanf(field_buffer(current_field(info->form), 0), "%[^ ]", field_value);
// Check actions for this key
while ((action = key_find_action(key, action)) != ERR) {
// Check if we handle this action
switch (action) {
case ACTION_PRINTABLE:
if (field_idx == FLD_SAVE_RAW_SAVE)
form_driver(info->form, key);
break;
case ACTION_NEXT_FIELD:
form_driver(info->form, REQ_NEXT_FIELD);
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_PREV_FIELD:
form_driver(info->form, REQ_PREV_FIELD);
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_RIGHT:
form_driver(info->form, REQ_RIGHT_CHAR);
break;
case ACTION_LEFT:
form_driver(info->form, REQ_LEFT_CHAR);
break;
case ACTION_BEGIN:
form_driver(info->form, REQ_BEG_LINE);
break;
case ACTION_END:
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_DELETE:
form_driver(info->form, REQ_DEL_CHAR);
break;
case ACTION_BACKSPACE:
if (strlen(field_value) > 0)
form_driver(info->form, REQ_DEL_PREV);
break;
case ACTION_CLEAR:
form_driver(info->form, REQ_CLR_FIELD);
break;
case ACTION_CONFIRM:
if (field_idx != FLD_SAVE_RAW_CANCEL) {
if (!strcasecmp(field_value, "")) {
save_raw_error_message(panel, "Invalid filename");
return 0;
}
return save_raw_to_file(panel);
}
return 27;
default:
// Parse next action
continue;
}
// We've handled this key, stop checking actions
break;
}
// Validate all input data
form_driver(info->form, REQ_VALIDATION);
// Change background and cursor of "button fields"
set_field_back(info->fields[FLD_SAVE_RAW_SAVE], A_NORMAL);
set_field_back(info->fields[FLD_SAVE_RAW_CANCEL], A_NORMAL);
curs_set(1);
// Change current field background
field_idx = field_index(current_field(info->form));
if (field_idx == FLD_SAVE_RAW_SAVE || field_idx == FLD_SAVE_RAW_CANCEL) {
set_field_back(info->fields[field_idx], A_REVERSE);
curs_set(0);
}
// Return if this panel has handled or not the key
return (action == ERR) ? key : 0;
}
static void
show_current_field(WINDOW *win, FORM * form)
{
FIELD *field;
FIELDTYPE *type;
char *buffer;
int nbuf;
int field_rows, field_cols, field_max;
int currow, curcol;
if (has_colors()) {
wbkgd(win, (chtype) COLOR_PAIR(1));
}
werase(win);
form_getyx(form, currow, curcol);
wprintw(win, "Cursor: %d,%d", currow, curcol);
if (data_ahead(form))
waddstr(win, " ahead");
if (data_behind(form))
waddstr(win, " behind");
waddch(win, '\n');
if ((field = current_field(form)) != 0) {
wprintw(win, "Page %d%s, Field %d/%d%s:",
form_page(form),
new_page(field) ? "*" : "",
field_index(field), field_count(form),
field_arg(field) ? "(arg)" : "");
if ((type = field_type(field)) != 0) {
if (type == TYPE_ALNUM)
waddstr(win, "ALNUM");
else if (type == TYPE_ALPHA)
waddstr(win, "ALPHA");
else if (type == TYPE_ENUM)
waddstr(win, "ENUM");
else if (type == TYPE_INTEGER)
waddstr(win, "INTEGER");
#ifdef NCURSES_VERSION
else if (type == TYPE_IPV4)
waddstr(win, "IPV4");
#endif
else if (type == TYPE_NUMERIC)
waddstr(win, "NUMERIC");
else if (type == TYPE_REGEXP)
waddstr(win, "REGEXP");
else
waddstr(win, "other");
}
if ((unsigned) field_opts(field) & O_EDIT)
waddstr(win, " editable");
else
waddstr(win, " readonly");
if (field_status(field))
waddstr(win, " modified");
if (dynamic_field_info(field, &field_rows, &field_cols, &field_max)
!= ERR) {
wprintw(win, " size %dx%d (max %d)",
field_rows, field_cols, field_max);
}
waddch(win, ' ');
(void) wattrset(win, (int) field_fore(field));
waddstr(win, "fore");
wattroff(win, (int) field_fore(field));
waddch(win, '/');
(void) wattrset(win, (int) field_back(field));
waddstr(win, "back");
wattroff(win, (int) field_back(field));
wprintw(win, ", pad '%c'",
field_pad(field));
waddstr(win, "\n");
for (nbuf = 0; nbuf <= 2; ++nbuf) {
if ((buffer = field_buffer(field, nbuf)) != 0) {
wprintw(win, "buffer %d:", nbuf);
(void) wattrset(win, A_REVERSE);
waddstr(win, buffer);
wattroff(win, A_REVERSE);
waddstr(win, "\n");
}
}
}
wrefresh(win);
}
int main(void)
{
int ch, i;
initscr();
atexit(quit);
clear();
noecho();
cbreak();
keypad(stdscr, TRUE);
start_color();
init_pair(1, COLOR_YELLOW, COLOR_BLUE);
init_pair(2, COLOR_BLACK, COLOR_WHITE);
bkgd(COLOR_PAIR(1));
fi = (FIELD **)calloc(4, sizeof(FIELD *));
fi[0] = new_field(1, 10, 2, 3, 0, 0);
fi[1] = new_field(1, 10, 2, 18, 0, 0);
fi[2] = new_field(1, 15, 2, 33, 0, 0);
fi[3] = 0;
for(i=0; i<3; i++)
{
set_field_fore(fi[i], COLOR_PAIR(2));
set_field_back(fi[i], COLOR_PAIR(2));
}
fo = new_form(fi);
post_form(fo);
mvaddstr(2, 15, "+");
mvaddstr(2, 30, "=");
mvaddstr(5, 3, "Programm mittels F1-Funktionstaste beenden");
refresh();
while((ch=getch()) != KEY_F(1))
{
switch(ch)
{
case KEY_RIGHT:
{
char str[20];
form_driver(fo, REQ_NEXT_FIELD);
if(field_index(current_field(fo)) == 2)
{
snprintf(str, 20, "%s%s", field_buffer(fi[0], 0), field_buffer(fi[1], 0));
set_field_buffer(fi[2], 0, str);
refresh();
}
break;
}
case KEY_LEFT:
form_driver(fo, REQ_PREV_FIELD);
break;
default: /* Feldeingabe */
form_driver(fo, ch);
}
}
return (0);
}
static VALUE rbncurs_c_current_field(VALUE rb_form) {
FORM* form = get_form(rb_form);
return wrap_field(current_field(form));
}
int main()
{
int ch, done;
ITEM *cur;
/* coreboot data structures */
lib_get_sysinfo();
struct cb_cmos_option_table *opttbl = get_system_option_table();
if (opttbl == NULL) {
printf("Could not find coreboot option table\n");
halt();
}
/* display initialization */
initscr();
keypad(stdscr, TRUE);
cbreak();
noecho();
start_color();
leaveok(stdscr, TRUE);
curs_set(1);
erase();
box(stdscr, 0, 0);
mvaddstr(0, 2, "coreboot configuration utility");
/* prep CMOS layout into libcurses data structures */
/* determine number of options, and maximum option name length */
int numopts=0;
int maxlength=0;
struct cb_cmos_entries *option = first_cmos_entry(opttbl);
while (option) {
if ((option->config != 'r') && (strcmp("check_sum", option->name) != 0)) {
maxlength = max(maxlength, strlen(option->name));
numopts++;
}
option = next_cmos_entry(option);
}
if (numopts == 0) {
printf("NO CMOS OPTIONS FOUND. EXITING!!!");
return 1;
}
FIELD **fields = malloc(sizeof(FIELD*)*(2*numopts+1));
int i;
/* walk over options, fetch details */
option = first_cmos_entry(opttbl);
for (i=0;i<numopts;i++) {
while ((option->config == 'r') || (strcmp("check_sum", option->name) == 0)) {
option = next_cmos_entry(option);
}
fields[2*i] = new_field(1, strlen(option->name), i*2, 1, 0, 0);
set_field_buffer(fields[2*i], 0, option->name);
field_opts_off(fields[2*i], O_ACTIVE);
fields[2*i+1] = new_field(1, 40, i*2, maxlength+2, 0, 0);
char *buf = NULL;
int fail = get_option_as_string(use_nvram, opttbl, &buf, option->name);
switch (option->config) {
case 'h': {
set_field_type(fields[2*i+1], TYPE_INTEGER, 0, 0, (1<<option->length)-1);
field_opts_on(fields[2*i+1], O_BLANK);
break;
}
case 's': {
set_max_field(fields[2*i+1], option->length/8);
field_opts_off(fields[2*i+1], O_STATIC);
break;
}
case 'e': {
int numvals = 0;
struct cb_cmos_enums *cmos_enum = first_cmos_enum_of_id(opttbl, option->config_id);
/* if invalid data in CMOS, set buf to first enum */
if (fail && cmos_enum) {
buf = cmos_enum->text;
}
while (cmos_enum) {
numvals++;
cmos_enum = next_cmos_enum_of_id(cmos_enum, option->config_id);
}
char **values = malloc(sizeof(char*)*numvals + 1);
int cnt = 0;
cmos_enum = first_cmos_enum_of_id(opttbl, option->config_id);
while (cmos_enum) {
values[cnt] = cmos_enum->text;
cnt++;
cmos_enum = next_cmos_enum_of_id(cmos_enum, option->config_id);
}
values[cnt] = NULL;
field_opts_off(fields[2*i+1], O_EDIT);
set_field_type(fields[2*i+1], TYPE_ENUM, values, 1, 1);
free(values); // copied by set_field_type
break;
}
default:
break;
}
if (buf) set_field_buffer(fields[2*i+1], 0, buf);
#if HOSTED
// underline is non-trivial on VGA text
set_field_back(fields[2*i+1], A_UNDERLINE);
#endif
field_opts_off(fields[2*i+1], O_BLANK | O_AUTOSKIP | O_NULLOK);
option = next_cmos_entry(option);
}
fields[2*numopts]=NULL;
FORM *form = new_form(fields);
int numlines = min(numopts*2, 16);
WINDOW *w = newwin(numlines+2, 70, 2, 1);
WINDOW *inner_w = newpad(numopts*2, 68);
box(w, 0, 0);
mvwaddstr(w, 0, 2, "Press F1 when done");
set_form_win(form, w);
set_form_sub(form, inner_w);
post_form(form);
done = 0;
while(!done) {
ch=getch();
if (ch == ERR) continue;
switch (ch) {
case KEY_DOWN:
form_driver(form, REQ_NEXT_FIELD);
break;
case KEY_UP:
form_driver(form, REQ_PREV_FIELD);
break;
case KEY_LEFT:
if (field_type(current_field(form)) == TYPE_ENUM) {
form_driver(form, REQ_PREV_CHOICE);
} else {
form_driver(form, REQ_LEFT_CHAR);
}
break;
case KEY_RIGHT:
if (field_type(current_field(form)) == TYPE_ENUM) {
form_driver(form, REQ_NEXT_CHOICE);
} else {
form_driver(form, REQ_RIGHT_CHAR);
}
break;
case KEY_BACKSPACE:
case '\b':
form_driver(form, REQ_DEL_PREV);
break;
case KEY_DC:
form_driver(form, REQ_DEL_CHAR);
break;
case KEY_F(1):
done=1;
break;
default:
form_driver(form, ch);
break;
}
render_form(form);
}
for (i = 0; i < numopts; i++) {
char *name = field_buffer(fields[2*i], 0);
char *value = field_buffer(fields[2*i+1], 0);
char *ptr;
for (ptr = value + strlen (value) - 1;
ptr >= value && *ptr == ' '; ptr--);
ptr[1] = '\0';
set_option_from_string(use_nvram, opttbl, value, name);
}
unpost_form(form);
free_form(form);
touchwin(stdscr);
refresh();
endwin();
/* TODO: reboot */
halt();
}
void actions_dataentry_scr(const char *curr_path, const char *case_num) {
const size_t n_fields = 4;
const size_t starty = 6;
const size_t startx = 25;
FIELD *field[n_fields];
FORM *my_form;
Action_t record;
int width[] = { MAX_ACT_DATE - 1, MAX_ACT_TYPE, MAX_ACT_NOTE - 200 };
int height[] = { 1, 1, 4 };
for ( size_t i = 0; i < n_fields - 1; ++i )
field[i] = new_field(height[i], width[i], starty + i * 2, startx, 0, 0);
field[n_fields - 1] = NULL;
set_field_back( field[0], A_UNDERLINE );
field_opts_off( field[0], O_AUTOSKIP );
set_field_back( field[1], A_UNDERLINE );
field_opts_off( field[1], O_AUTOSKIP );
set_field_back( field[2], A_UNDERLINE );
field_opts_off( field[2], O_AUTOSKIP );
field_opts_off( field[2], O_STATIC );
set_max_field( field[2], MAX_ACT_NOTE );
my_form = new_form(field);
post_form(my_form);
refresh();
int note_count = MAX_ACT_NOTE;
char note_msg[4];
char date_str[MAX_ACT_DATE];
get_curr_date( date_str );
mvprintw( 0, 0, curr_path );
mvprintw( 4, 10, "Case Number: %s", case_num );
mvprintw( 6, 10, "Entry Date: " );
mvprintw( 8, 10, "Type: " );
mvprintw( 10, 10, "Note: " );
mvprintw( 15, 77, "%d", note_count );
mvprintw( 16, 10, "(F2) = Add | (ESC) = Previous Screen" );
set_visible_fields( field, 1, 3 );
size_t actions_count = actions_list( case_num );
move( 6, 25 );
set_field_buffer( field[0], 0, date_str );
set_current_field( my_form, field[0] );
record.id = 0;
int ch;
do {
ch = getch();
switch ( ch ) {
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_LEFT:
form_driver(my_form, REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form, REQ_RIGHT_CHAR);
break;
case KEY_BACKSPACE:
{
FIELD * curr_fld = current_field( my_form );
if ( curr_fld == field[2] ) {
snprintf( note_msg, 4, "%d", ++note_count );
display_msg( 15, 77, my_form, curr_fld, note_msg );
}
}
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case DEL:
{
FIELD * curr_fld = current_field( my_form );
if ( curr_fld == field[2] ) {
snprintf( note_msg, 4, "%d", ++note_count );
display_msg( 15, 77, my_form, curr_fld, note_msg );
}
}
form_driver( my_form, REQ_DEL_CHAR );
break;
case ENTER:
form_driver( my_form, REQ_NEXT_FIELD );
form_driver( my_form, REQ_END_LINE );
break;
case KEY_F(1):
{
FIELD * curr_fld = current_field( my_form );
if ( curr_fld == field[1] ) {
if ( query_select_all_codes_from_action_types() ) {
clear_line(18, 10);
mvprintw( 18, 10, db_get_error_msg() );
} else {
const Code_t const * code_ptr;
size_t count = 0;
mvprintw( 8, 75, "Type Options:" );
while ( ( code_ptr = get_code_from_result() ) != NULL )
mvprintw( 9 + count++, 81, "[%d] %s", code_ptr->code, code_ptr->desc );
free_code_result();
int row, col;
get_cursor_pos( curr_fld, &row, &col );
move( row, col );
set_current_field( my_form, curr_fld );
}
}
}
break;
case KEY_F(2):
{
clear_line( 18, 10 );
strncpy( record.case_num, case_num, MAX_CANUM );
strncpy( record.entry_date, compress_str( field_buffer(field[0], 0) ), MAX_ACT_DATE );
record.type = atoi( compress_str( field_buffer(field[1], 0) ) );
strncpy( record.note, field_buffer(field[2], 0), MAX_ACT_NOTE );
if ( is_empty_str( record.note, MAX_ACT_NOTE ) ) {
mvprintw( 18, 10, "[!] Action must at least have a note." );
move( 10, 25 );
set_current_field( my_form, field[2] );
break;
}
if ( query_add_action( &record ) ) {
mvprintw( 18, 10, db_get_error_msg() );
} else {
clear_fields( field, 0, 2 );
actions_count++;
print_action( &record, actions_count );
note_count = MAX_ACT_NOTE;
mvprintw( 15, 77, "%d", note_count );
}
move( 6, 25 );
set_current_field( my_form, field[0] );
}
break;
default:
{
FIELD * curr_fld = current_field( my_form );
if ( ch == '\'' )
break;
if ( curr_fld == field[1] ) {
if ( !isdigit( ch ) )
break;
} else if ( curr_fld == field[2] ) {
snprintf( note_msg, 4, "%d", --note_count );
display_msg( 15, 77, my_form, curr_fld, note_msg );
}
}
form_driver( my_form, ch );
break;
}
} while ( ch != ESC );
unpost_form( my_form );
free_form( my_form );
for ( size_t i = 0; i < n_fields - 1; ++i )
free_field( field[i] );
return;
}
int
call_list_handle_form_key(PANEL *panel, int key)
{
int field_idx;
char dfilter[256];
int action = -1;
// Get panel information
call_list_info_t *info = call_list_info(panel);
// Get current field id
field_idx = field_index(current_field(info->form));
// Check actions for this key
while ((action = key_find_action(key, action)) != ERR) {
// Check if we handle this action
switch (action) {
case ACTION_PRINTABLE:
// If this is a normal character on input field, print it
form_driver(info->form, key);
break;
case ACTION_PREV_SCREEN:
case ACTION_NEXT_FIELD:
case ACTION_CONFIRM:
case ACTION_SELECT:
case ACTION_UP:
case ACTION_DOWN:
// Activate list
call_list_form_activate(panel, 0);
break;
case ACTION_RIGHT:
form_driver(info->form, REQ_RIGHT_CHAR);
break;
case ACTION_LEFT:
form_driver(info->form, REQ_LEFT_CHAR);
break;
case ACTION_BEGIN:
form_driver(info->form, REQ_BEG_LINE);
break;
case ACTION_END:
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_CLEAR:
form_driver(info->form, REQ_BEG_LINE);
form_driver(info->form, REQ_CLR_EOL);
break;
case ACTION_DELETE:
form_driver(info->form, REQ_DEL_CHAR);
break;
case ACTION_BACKSPACE:
form_driver(info->form, REQ_DEL_PREV);
break;
default:
// Parse next action
continue;
}
// We've handled this key, stop checking actions
break;
}
// Filter has changed, re-apply filter to displayed calls
if (action == ACTION_PRINTABLE || action == ACTION_BACKSPACE ||
action == ACTION_DELETE || action == ACTION_CLEAR) {
// Updated displayed results
call_list_clear(panel);
// Reset filters on each key stroke
filter_reset_calls();
}
// Validate all input data
form_driver(info->form, REQ_VALIDATION);
// Store dfilter input
// We trim spaces with sscanf because and empty field is stored as space characters
memset(dfilter, 0, sizeof(dfilter));
strcpy(dfilter, field_buffer(info->fields[FLD_LIST_FILTER], 0));
strtrim(dfilter);
// Set display filter
filter_set(FILTER_CALL_LIST, strlen(dfilter) ? dfilter : NULL);
// Return if this panel has handled or not the key
return (action == ERR) ? key : 0;
}
int
save_handle_key(ui_t *ui, int key)
{
int field_idx;
int action = -1;
// Get panel information
save_info_t *info = save_info(ui);
// Get current field id
field_idx = field_index(current_field(info->form));
// Check actions for this key
while ((action = key_find_action(key, action)) != ERR) {
// Check if we handle this action
switch (action) {
case ACTION_PRINTABLE:
if (field_idx == FLD_SAVE_PATH || field_idx == FLD_SAVE_FILE) {
form_driver(info->form, key);
break;
}
continue;
case ACTION_NEXT_FIELD:
form_driver(info->form, REQ_NEXT_FIELD);
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_PREV_FIELD:
form_driver(info->form, REQ_PREV_FIELD);
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_RIGHT:
form_driver(info->form, REQ_RIGHT_CHAR);
break;
case ACTION_LEFT:
form_driver(info->form, REQ_LEFT_CHAR);
break;
case ACTION_BEGIN:
form_driver(info->form, REQ_BEG_LINE);
break;
case ACTION_END:
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_DELETE:
form_driver(info->form, REQ_DEL_CHAR);
break;
case ACTION_BACKSPACE:
form_driver(info->form, REQ_DEL_PREV);
break;
case ACTION_CLEAR:
form_driver(info->form, REQ_CLR_FIELD);
break;
case ACTION_SELECT:
switch (field_idx) {
case FLD_SAVE_ALL:
info->savemode = SAVE_ALL;
break;
case FLD_SAVE_SELECTED:
info->savemode = SAVE_SELECTED;
break;
case FLD_SAVE_DISPLAYED:
info->savemode = SAVE_DISPLAYED;
break;
case FLD_SAVE_MESSAGE:
info->savemode = SAVE_MESSAGE;
break;
case FLD_SAVE_PCAP:
info->saveformat = SAVE_PCAP;
break;
case FLD_SAVE_PCAP_RTP:
info->saveformat = SAVE_PCAP_RTP;
break;
case FLD_SAVE_TXT:
info->saveformat = SAVE_TXT;
break;
case FLD_SAVE_FILE:
form_driver(info->form, key);
break;
default:
break;
}
break;
case ACTION_CONFIRM:
if (field_idx != FLD_SAVE_CANCEL) {
save_to_file(ui);
}
ui_destroy(ui);
return KEY_HANDLED;
default:
// Parse next action
continue;
}
// This panel has handled the key successfully
break;
}
// Validate all input data
form_driver(info->form, REQ_VALIDATION);
// Change background and cursor of "button fields"
set_field_back(info->fields[FLD_SAVE_SAVE], A_NORMAL);
set_field_back(info->fields[FLD_SAVE_CANCEL], A_NORMAL);
curs_set(1);
// Change current field background
field_idx = field_index(current_field(info->form));
if (field_idx == FLD_SAVE_SAVE || field_idx == FLD_SAVE_CANCEL) {
set_field_back(info->fields[field_idx], A_REVERSE);
curs_set(0);
}
// Return if this panel has handled or not the key
return (action == ERR) ? KEY_NOT_HANDLED : KEY_HANDLED;
}
int
filter_input_box(const int debuglvl, struct vrmr_filter *filter)
{
WINDOW *ib_win = NULL;
PANEL *my_panels[1];
FIELD *cur = NULL,
*prev = NULL;
FORM *my_form = NULL;
int height = 0,
width = 0,
startx = 0,
starty = 0,
max_height = 0,
max_width = 0,
ch = 0,
rows = 0,
cols = 0,
quit = 0;
size_t i = 0;
char not_defined = FALSE;
/* init fields */
memset(&FiFi, 0, sizeof(struct FilterFields_));
/* set the window size */
getmaxyx(stdscr, max_height, max_width);
height = 9;
width = 48;
/* print on the center of the screen */
starty = (max_height - height) / 2;
startx = (max_width - width) / 2;
/* create window */
ib_win = create_newwin(height, width, starty, startx, gettext("Filter"), vccnf.color_win);
if(ib_win == NULL)
{
vrmr_error(-1, VR_ERR, gettext("creating window failed."));
return(-1);
}
my_panels[0] = new_panel(ib_win);
if(my_panels[0] == NULL)
{
vrmr_error(-1, VR_ERR, gettext("creating panel failed."));
return(-1);
}
FiFi.n_fields = 2;
FiFi.fields = (FIELD **)calloc(FiFi.n_fields + 1, sizeof(FIELD *));
if(FiFi.fields == NULL)
{
vrmr_error(-1, VR_ERR, gettext("calloc failed: %s (in: %s:%d)."),
strerror(errno), __FUNC__, __LINE__);
return(-1);
}
FiFi.string_fld = (FiFi.fields[0] = new_field(1, 31, 3, 4, 0, 0));
FiFi.check_fld = (FiFi.fields[1] = new_field(1, 1, 5, 5, 0, 0));
set_field_back(FiFi.string_fld, vccnf.color_win_rev);
field_opts_off(FiFi.string_fld, O_AUTOSKIP);
set_field_status(FiFi.string_fld, FALSE);
set_field_buffer_wrap(debuglvl, FiFi.string_fld, 0, filter->str);
set_field_back(FiFi.check_fld, vccnf.color_win);
field_opts_off(FiFi.check_fld, O_AUTOSKIP);
set_field_status(FiFi.check_fld, FALSE);
set_field_buffer_wrap(debuglvl, FiFi.check_fld, 0, filter->neg ? "X" : " ");
my_form = new_form(FiFi.fields);
scale_form(my_form, &rows, &cols);
keypad(ib_win, TRUE);
set_form_win(my_form, ib_win);
set_form_sub(my_form, derwin(ib_win, rows, cols, 1, 2));
post_form(my_form);
/* XXX: we really should have a wrapper function to just print
* in the middle of a window to prevent hacks like this. */
char *s = gettext("Enter filter (leave empty for no filter)");
mvwprintw(ib_win, 2, (width - StrLen(s))/2, s);
mvwprintw(ib_win, 6, 6, "[");
mvwprintw(ib_win, 6, 8, "]");
mvwprintw(ib_win, 6, 11, gettext("show lines that don't match"));
update_panels();
doupdate();
if(!(cur = current_field(my_form)))
{
vrmr_error(-1, VR_INTERR, "NULL pointer (in: %s:%d).",
__FUNC__, __LINE__);
return(-1);
}
while(quit == 0)
{
/* draw nice markers */
draw_field_active_mark(cur, prev, ib_win, my_form, vccnf.color_win_mark|A_BOLD);
not_defined = 0;
/* get user input */
ch = wgetch(ib_win);
if(cur == FiFi.check_fld)
{
if(nav_field_toggleX(debuglvl, my_form, ch) < 0)
not_defined = 1;
}
else if(cur == FiFi.string_fld)
{
if(nav_field_simpletext(debuglvl, my_form, ch) < 0)
not_defined = 1;
}
else
{
not_defined = 1;
}
/* the rest is handled here */
if(not_defined)
{
switch(ch)
{
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_DOWN:
case 9: // tab
form_driver(my_form, REQ_NEXT_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case 10: // enter
if(cur == FiFi.check_fld)
{
quit = 1;
}
else
{
form_driver(my_form, REQ_NEXT_FIELD);
form_driver(my_form, REQ_END_LINE);
}
break;
case 27:
case KEY_F(10):
case 'q':
case 'Q':
quit = 1;
break;
}
}
/* before we get the new 'cur', store cur in prev */
prev = cur;
if(!(cur = current_field(my_form)))
{
vrmr_error(-1, VR_INTERR, "NULL pointer (in: %s).", __FUNC__);
return(-1);
}
/* draw and set cursor */
wrefresh(ib_win);
pos_form_cursor(my_form);
}
/* save here */
if(filter_save(debuglvl, filter) < 0)
{
vrmr_error(-1, VR_ERR, gettext("setting filter failed."));
}
unpost_form(my_form);
free_form(my_form);
for(i=0; i < FiFi.n_fields; i++)
{
free_field(FiFi.fields[i]);
}
free(FiFi.fields);
del_panel(my_panels[0]);
destroy_win(ib_win);
update_panels();
doupdate();
return(0);
}
static int
offset_in_field(FORM * form)
{
FIELD *field = current_field(form);
return form->curcol + form->currow * field->dcols;
}
int
filter_handle_key(PANEL *panel, int key)
{
int field_idx;
char field_value[30];
int action = -1;
// Get panel information
filter_info_t *info = filter_info(panel);
// Get current field id
field_idx = field_index(current_field(info->form));
// Get current field value.
// We trim spaces with sscanf because and empty field is stored as
// space characters
memset(field_value, 0, sizeof(field_value));
strcpy(field_value, field_buffer(current_field(info->form), 0));
strtrim(field_value);
// Check actions for this key
while ((action = key_find_action(key, action)) != ERR) {
// Check if we handle this action
switch (action) {
case ACTION_PRINTABLE:
// If this is a normal character on input field, print it
if (field_idx == FLD_FILTER_SIPFROM || field_idx == FLD_FILTER_SIPTO
|| field_idx == FLD_FILTER_SRC || field_idx == FLD_FILTER_DST
|| field_idx == FLD_FILTER_PAYLOAD) {
form_driver(info->form, key);
break;
}
continue;
case ACTION_NEXT_FIELD:
form_driver(info->form, REQ_NEXT_FIELD);
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_PREV_FIELD:
form_driver(info->form, REQ_PREV_FIELD);
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_RIGHT:
form_driver(info->form, REQ_RIGHT_CHAR);
break;
case ACTION_LEFT:
form_driver(info->form, REQ_LEFT_CHAR);
break;
case ACTION_BEGIN:
form_driver(info->form, REQ_BEG_LINE);
break;
case ACTION_END:
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_CLEAR:
form_driver(info->form, REQ_CLR_FIELD);
break;
case KEY_DC:
form_driver(info->form, REQ_DEL_CHAR);
break;
case ACTION_DELETE:
form_driver(info->form, REQ_DEL_CHAR);
break;
case ACTION_BACKSPACE:
if (strlen(field_value) > 0)
form_driver(info->form, REQ_DEL_PREV);
break;
case ACTION_SELECT:
switch (field_idx) {
case FLD_FILTER_REGISTER:
case FLD_FILTER_INVITE:
case FLD_FILTER_SUBSCRIBE:
case FLD_FILTER_NOTIFY:
case FLD_FILTER_OPTIONS:
case FLD_FILTER_PUBLISH:
case FLD_FILTER_MESSAGE:
if (field_value[0] == '*') {
form_driver(info->form, REQ_DEL_CHAR);
} else {
form_driver(info->form, '*');
}
break;
case FLD_FILTER_CANCEL:
return KEY_ESC;
case FLD_FILTER_FILTER:
filter_save_options(panel);
return KEY_ESC;
}
break;
case ACTION_CONFIRM:
if (field_idx != FLD_FILTER_CANCEL)
filter_save_options(panel);
return KEY_ESC;
default:
// Parse next action
continue;
}
// This panel has handled the key successfully
break;
}
// Validate all input data
form_driver(info->form, REQ_VALIDATION);
// Change background and cursor of "button fields"
set_field_back(info->fields[FLD_FILTER_FILTER], A_NORMAL);
set_field_back(info->fields[FLD_FILTER_CANCEL], A_NORMAL);
curs_set(1);
// Change current field background
field_idx = field_index(current_field(info->form));
if (field_idx == FLD_FILTER_FILTER || field_idx == FLD_FILTER_CANCEL) {
set_field_back(info->fields[field_idx], A_REVERSE);
curs_set(0);
}
// Return if this panel has handled or not the key
return (action == ERR) ? key : 0;
}
int
edit_field(FORM * form, int *result)
{
int ch = wgetch(form_win(form));
int status;
FIELD *before;
unsigned n;
char lengths[80];
int length;
char *buffer;
int before_row;
int before_col;
int before_off = offset_in_field(form);
form_getyx(form, before_row, before_col);
before = current_field(form);
set_field_back(before, A_NORMAL);
if (ch <= KEY_MAX) {
set_field_back(before, A_REVERSE);
} else if (ch <= MAX_FORM_COMMAND) {
inactive_field(before);
}
*result = ch;
for (n = 0; n < SIZEOF(commands); ++n) {
if (commands[n].code == ch) {
*result = commands[n].result;
break;
}
}
status = form_driver(form, *result);
if (status == E_OK) {
bool modified = TRUE;
length = 0;
if ((buffer = field_buffer(before, 1)) != 0)
length = atoi(buffer);
if (length < before_off)
length = before_off;
switch (*result) {
case REQ_CLR_EOF:
length = before_off;
break;
case REQ_CLR_EOL:
if (before_row + 1 == before->rows)
length = before_off;
break;
case REQ_CLR_FIELD:
length = 0;
break;
case REQ_DEL_CHAR:
if (length > before_off)
--length;
break;
case REQ_DEL_PREV:
if (length > 0) {
if (before_col > 0) {
--length;
} else if (before_row > 0) {
length -= before->cols + before_col;
}
}
break;
case REQ_NEW_LINE:
length += before->cols;
break;
#if 0
/* FIXME: finish these */
case REQ_DEL_LINE: /* delete line */
case REQ_DEL_WORD: /* delete word at cursor */
case REQ_INS_CHAR: /* insert blank char at cursor */
case REQ_INS_LINE: /* insert blank line at cursor */
case REQ_INS_MODE: /* begin insert mode */
case REQ_OVL_MODE: /* begin overlay mode */
#endif
/* ignore all of the motion commands */
case REQ_SCR_BCHAR: /* FALLTHRU */
case REQ_SCR_BHPAGE: /* FALLTHRU */
case REQ_SCR_BLINE: /* FALLTHRU */
case REQ_SCR_BPAGE: /* FALLTHRU */
case REQ_SCR_FCHAR: /* FALLTHRU */
case REQ_SCR_FHPAGE: /* FALLTHRU */
case REQ_SCR_FLINE: /* FALLTHRU */
case REQ_SCR_FPAGE: /* FALLTHRU */
case REQ_SCR_HBHALF: /* FALLTHRU */
case REQ_SCR_HBLINE: /* FALLTHRU */
case REQ_SCR_HFHALF: /* FALLTHRU */
case REQ_SCR_HFLINE: /* FALLTHRU */
case REQ_BEG_FIELD: /* FALLTHRU */
case REQ_BEG_LINE: /* FALLTHRU */
case REQ_DOWN_CHAR: /* FALLTHRU */
case REQ_DOWN_FIELD: /* FALLTHRU */
case REQ_END_FIELD: /* FALLTHRU */
case REQ_END_LINE: /* FALLTHRU */
case REQ_FIRST_FIELD: /* FALLTHRU */
case REQ_FIRST_PAGE: /* FALLTHRU */
case REQ_LAST_FIELD: /* FALLTHRU */
case REQ_LAST_PAGE: /* FALLTHRU */
case REQ_LEFT_CHAR: /* FALLTHRU */
case REQ_LEFT_FIELD: /* FALLTHRU */
case REQ_NEXT_CHAR: /* FALLTHRU */
case REQ_NEXT_CHOICE: /* FALLTHRU */
case REQ_NEXT_FIELD: /* FALLTHRU */
case REQ_NEXT_LINE: /* FALLTHRU */
case REQ_NEXT_PAGE: /* FALLTHRU */
case REQ_NEXT_WORD: /* FALLTHRU */
case REQ_PREV_CHAR: /* FALLTHRU */
case REQ_PREV_CHOICE: /* FALLTHRU */
case REQ_PREV_FIELD: /* FALLTHRU */
case REQ_PREV_LINE: /* FALLTHRU */
case REQ_PREV_PAGE: /* FALLTHRU */
case REQ_PREV_WORD: /* FALLTHRU */
case REQ_RIGHT_CHAR: /* FALLTHRU */
case REQ_RIGHT_FIELD: /* FALLTHRU */
case REQ_SFIRST_FIELD: /* FALLTHRU */
case REQ_SLAST_FIELD: /* FALLTHRU */
case REQ_SNEXT_FIELD: /* FALLTHRU */
case REQ_SPREV_FIELD: /* FALLTHRU */
case REQ_UP_CHAR: /* FALLTHRU */
case REQ_UP_FIELD: /* FALLTHRU */
case REQ_VALIDATION: /* FALLTHRU */
modified = FALSE;
break;
default:
modified = FALSE;
if (ch >= MIN_FORM_COMMAND) {
beep();
} else if (isprint(ch)) {
modified = TRUE;
}
break;
}
/*
* If we do not force a re-validation, then field_buffer 0 will
* be lagging by one character.
*/
if (modified && form_driver(form, REQ_VALIDATION) == E_OK && *result
< MIN_FORM_COMMAND)
++length;
sprintf(lengths, "%d", length);
set_field_buffer(before, 1, lengths);
}
if (current_field(form) != before)
inactive_field(before);
return status;
}
int eq_run (kr_client_t *client, char *sysname) {
WINDOW *eq_win,*tmpw;
PANEL *eq_mainpan,*eq_subpan,*ctrl_subp;
FORM *eq_form;
FIELD **field;
FIELD **ctrl_field;
FORM *ctrl_form;
/* Panels Structs */
ctrls_show_t *ctrls;
eq_port_t *eqport;
db_show_t *db;
hz_show_t *hz;
bw_show_t *bw;
eq_saved_val_t *vals;
int i;
int max_co,subx,suby,gap;
int offs = 0;
int field_idx;
int in_ctrl = 0;
int nbands = KRAD_EQ_MAX_BANDS;
int showed_bands = 1;
int idx;
char num[3];
int ch;
int res;
int bandn;
clear ();
char *fieldname[3] = {"Power","Frequency","Bandwidth"};
int nctrls = 3;
eq_win = newwin (0,0,0,0);
field = calloc (nbands+1,sizeof (FIELD*));
ctrl_field = calloc (nctrls+1,sizeof (FIELD*));
max_co = getmaxx (eq_win);
gap = floor ((max_co) / nbands);
vals = NULL;
bandn = 0;
ch = 0;
for (i=0;i<nbands;i++) {
field[i] = new_field (1,2,1, offs, 0, 0);
set_field_just (field[i], JUSTIFY_CENTER);
itoa (i,num,digits (i) + 1 );
set_field_buffer (field[i], 0, num);
field_opts_off (field[i], O_AUTOSKIP | O_EDIT);
offs += gap;
}
field[nbands] = NULL;
offs = 0;
gap = floor ((max_co ) / nctrls);
for (i=0;i<nctrls;i++) {
ctrl_field[i] = new_field (1,strlen (fieldname[i]),1, offs, 0, 0);
set_field_just (ctrl_field[i], JUSTIFY_CENTER);
set_field_buffer (ctrl_field[i], 0, fieldname[i]);
field_opts_off (ctrl_field[i], O_AUTOSKIP | O_EDIT);
offs += gap;
}
/* Controls generation */
ctrls = eq_ctrls_gen (eq_win,showed_bands);
vals = calloc (1,sizeof (eq_saved_val_t));
eqport = calloc (1,sizeof (eq_port_t));
db = ctrls->db;
hz = ctrls->hz;
bw = ctrls->bw;
eqport->name = sysname;
eqport->vals = vals;
eqport->ctrls = ctrls;
/* Eq form init */
eq_form = new_form (field);
wattron (eq_win,COLOR_PAIR (2) | A_BOLD);
mvwprintw (eq_win,getmaxy (eq_win) * 0.05,floor ((max_co/2)-((strlen (sysname)+14)/2)),"Equalizer for %s",sysname);
wattroff (eq_win,COLOR_PAIR (2) | A_BOLD);
set_form_win (eq_form, eq_win);
scale_form (eq_form, &suby, &subx);
set_form_sub (eq_form, derwin (eq_win,suby, subx , getmaxy (eq_win) * 0.10 , (max_co - subx) / 2 ));
eq_mainpan = new_panel (eq_win);
eq_subpan = new_panel (form_sub (eq_form));
top_panel (eq_mainpan);
top_panel (eq_subpan);
post_form (eq_form);
keypad (eq_win, TRUE);
set_current_field (eq_form,field[0]);
set_field_fore (current_field (eq_form),A_BOLD | COLOR_PAIR (3));
/* Eq ctrls form init */
ctrl_form = new_form (ctrl_field);
set_form_win (ctrl_form, eq_win);
scale_form (ctrl_form, &suby, &subx);
set_form_sub (ctrl_form, derwin (eq_win,suby, subx , getmaxy (eq_win) * 0.90 , (max_co - subx) / 2 ));
ctrl_subp = new_panel (form_sub (ctrl_form));
top_panel (ctrl_subp);
post_form (ctrl_form);
field_idx = field_index (current_field (eq_form));
/* Let's show controls! */
kr_mixer_portgroups (client);
show_all_panels (ctrls,showed_bands);
update_panels ();
doupdate ();
while (ch != 'q') {
res = krm_poll (client,-1);
switch (res) {
case 0:
continue;
case 1:
ch = getch ();
break;
case 2:
eqport->band = bandn;
kr_delivery_recv (client);
eq_delivery_handler (client,eqport);
continue;
case -1:
continue;
}
switch (ch) {
case KEY_LEFT:
if (in_ctrl) {
set_field_fore (current_field (ctrl_form),A_NORMAL);
form_driver (ctrl_form, REQ_PREV_FIELD);
set_field_fore (current_field (ctrl_form),A_BOLD | COLOR_PAIR (1));
idx = field_index (current_field (ctrl_form));
}
else {
set_field_fore (current_field (eq_form),A_NORMAL);
form_driver (eq_form, REQ_PREV_FIELD);
set_field_fore (current_field (eq_form),A_BOLD | COLOR_PAIR (3));
bandn = field_index (current_field (eq_form));
kr_mixer_portgroups (client);
}
break;
case KEY_RIGHT:
if (in_ctrl) {
set_field_fore (current_field (ctrl_form),A_NORMAL);
form_driver (ctrl_form, REQ_NEXT_FIELD);
set_field_fore (current_field (ctrl_form),A_BOLD | COLOR_PAIR (1));
idx = field_index (current_field (ctrl_form));
}
else {
set_field_fore (current_field (eq_form),A_NORMAL);
form_driver (eq_form, REQ_NEXT_FIELD);
set_field_fore (current_field (eq_form),A_BOLD | COLOR_PAIR (3));
bandn = field_index (current_field (eq_form));
kr_mixer_portgroups (client);
}
break;
case KEY_UP:
if (in_ctrl) {
switch (idx) {
case 0:
vals->db += 0.50;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "db", vals->db, 0, 0);
break;
case 1:
vals->hz += 5;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "hz", vals->hz, 0, 0);
break;
case 2:
vals->bw += 0.10;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "bw", vals->bw, 0, 0);
break;
}
}
break;
case KEY_DOWN:
if (in_ctrl) {
switch (idx) {
case 0:
vals->db -= 0.5;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "db", vals->db, 0, 0);
break;
case 1:
vals->hz -= 5;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "hz", vals->hz, 0, 0);
break;
case 2:
vals->bw -= 0.10;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "bw", vals->bw, 0, 0);
break;
}
}
break;
case 'w':
if (in_ctrl) {
switch (idx) {
case 0:
vals->db += 0.10;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "db", vals->db, 0, 0);
break;
case 1:
vals->hz += 1;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "hz", vals->hz, 0, 0);
break;
case 2:
break;
}
}
break;
case 's':
if (in_ctrl) {
switch (idx) {
case 0:
vals->db -= 0.10;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "db", vals->db, 0, 0);
break;
case 1:
vals->hz -= 1;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "hz", vals->hz, 0, 0);
break;
case 2:
break;
}
}
break;
case 9:
if (in_ctrl) {
idx = field_index (current_field (ctrl_form));
set_field_fore (ctrl_field[idx],A_NORMAL);
/* ncurses bug I suppose */
form_driver (ctrl_form, REQ_NEXT_FIELD);
form_driver (ctrl_form, REQ_PREV_FIELD);
set_current_field (eq_form,field[field_idx]);
in_ctrl = 0;
}
else {
field_idx = field_index (current_field (eq_form));
set_current_field (ctrl_form,ctrl_field[0]);
set_field_fore (ctrl_field[0],A_BOLD | COLOR_PAIR (1));
/* ncurses bug I suppose */
form_driver (ctrl_form, REQ_NEXT_FIELD);
form_driver (ctrl_form, REQ_PREV_FIELD);
idx = 0;
in_ctrl = 1;
}
break;
default:
break;
}
update_panels ();
doupdate ();
}
/* CLEANUP */
for (i=0;i<showed_bands;i++) {
tmpw = panel_window (db->slider_p[i]);
del_panel (db->slider_p[i]);
delwin (tmpw);
tmpw = panel_window (db->bar_p[i]);
del_panel (db->bar_p[i]);
delwin (tmpw);
tmpw = panel_window (hz->cell_p[i]);
del_panel (hz->cell_p[i]);
delwin (tmpw);
tmpw = panel_window (bw->bar_p[i]);
del_panel (bw->bar_p[i]);
delwin (tmpw);
tmpw = panel_window (bw->slider_p[i]);
del_panel (bw->slider_p[i]);
delwin (tmpw);
tmpw = panel_window (bw->cell_p[i]);
del_panel (bw->cell_p[i]);
delwin (tmpw);
}
free (db->bar_w);
free (db->slider_w);
free (hz->cell_w);
free (bw->bar_w);
free (bw->slider_w);
free (bw->cell_w);
free (db->bar_p);
free (db->slider_p);
free (hz->cell_p);
free (bw->bar_p);
free (bw->slider_p);
free (bw->cell_p);
tmpw = panel_window (db->pan);
del_panel (db->pan);
delwin (tmpw);
tmpw = panel_window (hz->pan);
del_panel (hz->pan);
delwin (tmpw);
tmpw = panel_window (bw->pan);
del_panel (bw->pan);
delwin (tmpw);
free (ctrls);
free (db);
free (hz);
free (bw);
free (vals);
free (eqport);
tmpw = form_sub (ctrl_form);
unpost_form (ctrl_form);
free_form (ctrl_form);
for (i=0;i<nctrls;i++) {
free_field (ctrl_field[i]);
}
free (ctrl_field);
del_panel (ctrl_subp);
delwin (tmpw);
tmpw = form_sub (eq_form);
unpost_form (eq_form);
free_form (eq_form);
for (i=0;i<nbands;i++) {
free_field (field[i]);
}
free (field);
del_panel (eq_subpan);
del_panel (eq_mainpan);
delwin (tmpw);
delwin (eq_win);
return 0;
}
