void
save_destroy(ui_t *ui)
{
save_info_t *info;
int i;
// Get panel information
if ((info = save_info(ui))) {
// Remove panel form and fields
unpost_form(info->form);
free_form(info->form);
for (i = 0; i < FLD_SAVE_COUNT; i++)
free_field(info->fields[i]);
// Remove panel window and custom info
sng_free(info);
}
// Delete panel
ui_panel_destroy(ui);
// Resume capture
capture_set_paused(0);
// Disable cursor position
curs_set(0);
}
void
free_term_gui(void)
{
if (menu_list) {
unpost_menu(menu_list);
free_menu(menu_list);
}
if (list_items) {
for (int i = 0; i < choices_cnt; i++) {
free_item(list_items[i]);
}
free(list_items);
}
unpost_form(form);
if (form)
free_form(form);
free_field(field[0]);
endwin();
}
void viper_form_destroy(FORM *form,gboolean free_windows)
{
WINDOW *parent;
WINDOW *window;
WINDOW *subwin;
FIELD **fields;
gint count;
unpost_form(form);
window=form_win(form);
subwin=form_sub(form);
parent=window->_parent;
count=field_count(form);
fields=form_fields(form);
free_form(form);
while(count>0)
{
free_field(fields[count-1]);
count--;
}
g_free(fields);
if(free_windows==FALSE) return;
/* delete subwin if it is completely independent. */
if(subwin!=parent && subwin!=window && subwin!=NULL) delwin(subwin);
/* delete window if it is not the parent window. */
if(parent!=NULL && window!=parent && window!=NULL) delwin(window);
return;
}
void
call_list_destroy(PANEL *panel)
{
call_list_info_t *info;
// Free its status data
if ((info = call_list_info(panel))) {
// Deallocate forms data
if (info->form) {
unpost_form(info->form);
free_form(info->form);
free_field(info->fields[FLD_LIST_FILTER]);
}
// Deallocate group data
call_group_destroy(info->group);
// Deallocate panel windows
delwin(info->list_win);
sng_free(info);
}
// Deallocate panel window
delwin(panel_window(panel));
// Deallocate panel pointer
del_panel(panel);
}
/*
* Delete the popup allocated memory.
* This *won't* free popup_btn_action.
*/
void popup_delete(void)
{
int i;
if (popup_form) {
unpost_form(popup_form);
for (i = 0; popup_fields[i] != NULL; i++) {
free(field_buffer(popup_fields[i], 0));
free_field(popup_fields[i]);
}
free_form(popup_form);
free(popup_fields);
}
unpost_menu(popup_menu);
free_menu(popup_menu);
for (i = 0; popup_items[i] != NULL; i++)
free_item(popup_items[i]);
free(popup_items);
delwin(win_form);
delwin(win_menu);
delwin(win_body);
win_body = NULL;
popup_btn_action = NULL;
popup_menu = NULL;
}
static void on_close(void)
{
unpost_form(form);
free_form(form);
free_field(fields[0]);
free_field(fields[1]);
widget_free(&form_widget);
}
InputForm::~InputForm()
{
unpost_form(form);
free_form(form);
for (int i = 0;i < choices;i++)
{
free_field(field[i]);
}
}
ListBox::~ListBox() {
unpost_form(m_pForm);
free_form(m_pForm);
for (int i = 0; i < m_numRows; i++) {
if (m_pFields[i] != 0) {
free_field(m_pFields[i]);
}
}
}
/*
* delete the internal form
*/
static void wdg_input_form_destroy(struct wdg_object *wo)
{
WDG_WO_EXT(struct wdg_input_handle, ww);
/* delete the form */
unpost_form(ww->form);
free_form(ww->form);
ww->form = NULL;
delwin(ww->fwin);
}
static void
erase_form(FORM * f)
{
WINDOW *w = form_win(f);
WINDOW *s = form_sub(f);
unpost_form(f);
werase(w);
wrefresh(w);
delwin(s);
delwin(w);
}
void brsh_teardown(void)
{
if (frm_input)
{
unpost_form(frm_input);
free_form(frm_input);
}
if (fld_input) free_field(fld_input);
frm_input = NULL;
fld_input = NULL;
endwin();
}
void delete_input_form() {
unpost_form(url_form);
if (url_form) {
free_form(url_form);
url_form = NULL;
}
if (url_field[0]) {
free_field(url_field[0]);
url_field[0] = NULL;
}
}
void quit(void)
{
int i;
unpost_form(fo);
free_form(fo);
for(i=0; i<=3; i++)
{
free_field(fi[i]);
}
free(fi);
endwin();
}
DialogForm::~DialogForm() {
unpost_form(m_pForm);
// free_form(m_pForm); TODO: Fix segfault
for (int i = 0; i < m_numFields; i++) {
if (m_pFields[i] != 0) {
void *usrPtr = field_userptr(m_pFields[i]);
if (usrPtr != 0) {
delete (FieldType*)usrPtr; //TODO: Fix potentially unsafe conversion
}
free_field(m_pFields[i]);
}
}
curs_set(0);
refresh();
}
int main()
{ FIELD *f1[2];
FORM *frm1;
chtype ch;
int error;
HOOK fptr=getbuf;
initscr();
f1[0]=new_field(24,80,0,0,1,1);
assert(f1[0]!=NULL);
f1[1]=NULL;
frm1=new_form(f1);
assert(frm1!=NULL);
set_field_fore(f1[0],A_REVERSE);
field_opts_off(f1[0],O_STATIC);
//set_field_buffer(f1[0],0,"Sajid");
set_field_type(f1[0],TYPE_ALPHA,80);
set_field_term(f1[0],fptr);
post_form(frm1);
wrefresh(stdscr);
keypad(stdscr,TRUE);
while((ch=getch())!=KEY_F(3))
{ switch(ch)
{ case KEY_LEFT:
error=form_driver(frm1,REQ_PREV_CHAR);
if(error==E_REQUEST_DENIED)
form_driver(frm1,REQ_SCR_BCHAR);
break;
case KEY_RIGHT:
form_driver(frm1,REQ_NEXT_CHAR);
break;
default:
form_driver(frm1,ch);
break;
}
}
unpost_form(frm1);
free_form(frm1);
free_field(f1[0]);
getch();
printw(ptr);
endwin();
}
static void on_window_size_changed(void)
{
form_driver(form, REQ_VALIDATION); /* save field value */
unpost_form(form);
if (!create())
return;
/*
* This call fails because ncurses does not allow changing options of
* the current field, and we cannot change the current field because
* there is only one. The only way to make this work would be to throw
* away and recreate all fields.
*/
field_opts_off(fields[1], O_BLANK);
post_form(form);
}
void ListBox::createForm() {
if (m_pForm != 0) {
unpost_form(m_pForm);
free_form(m_pForm);
}
m_pForm = new_form(m_pFields);
int rows, cols;
scale_form(m_pForm, &rows, &cols);
set_form_win(m_pForm, m_pPanel->getWindow());
set_form_sub(m_pForm, derwin(m_pPanel->getWindow(), getHeight() - 2, getWidth() - 2, getY() + 1, getX() + 1));
post_form(m_pForm);
form_driver(m_pForm, REQ_LAST_FIELD);
if (isSelected()) {
selectField(REQ_PREV_FIELD);
}
}
static int
trafvol_section_destroy(void)
{
size_t i = 0;
// Un post form and free the memory
unpost_form(TrafVolSection.form);
free_form(TrafVolSection.form);
for(i = 0; i < TrafVolSection.n_fields; i++)
{
free_field(TrafVolSection.fields[i]);
}
free(TrafVolSection.fields);
del_panel(TrafVolSection.panel[0]);
destroy_win(TrafVolSection.win);
return(0);
}
void
column_select_destroy(ui_t *ui)
{
int i;
column_select_info_t *info = column_select_info(ui);
// Remove menu and items
unpost_menu(info->menu);
free_menu(info->menu);
for (i = 0; i < SIP_ATTR_COUNT; i++)
free_item(info->items[i]);
// Remove form and fields
unpost_form(info->form);
free_form(info->form);
for (i = 0; i < FLD_COLUMNS_COUNT; i++)
free_field(info->fields[i]);
sng_free(info);
// Remove panel window and custom info
ui_panel_destroy(ui);
}
int kullanici_onayla()
{
FIELD *field[3];
FORM *my_form;
int ch;
touchwin(ana_win);
wrefresh(ana_win);
init_pair(1, COLOR_WHITE, COLOR_BLUE);
init_pair(2, COLOR_WHITE, COLOR_BLUE);
/*calisma yili 4 karakter*/
field[0] = new_field(1, 10, 18, 42, 0, 0);
/*firma 2 karakter*/
field[1] = new_field(1, 10, 20, 42, 0, 0);
field[2] = NULL;
set_field_fore(field[0], COLOR_PAIR(1));
set_field_fore(field[1], COLOR_PAIR(1));
/*geri plan rengi olsun*/
set_field_back(field[0], COLOR_PAIR(2));
set_field_back(field[1], COLOR_PAIR(2));
/*
set_field_type(field[0], TYPE_INTEGER);
set_field_type(field[1], TYPE_INTEGER);
*/
field_opts_off(field[0], O_AUTOSKIP);
field_opts_off(field[1], O_AUTOSKIP);
/*sifre alani olan ikinci field password biçiminde olmali/
field_opts_off(field[1], O_PUBLIC);
/*geri plan rengi olmasin*/
/* set_field_back(field[0], A_UNDERLINE);
set_field_back(field[1], A_UNDERLINE);
*/
my_form = new_form(field);
post_form(my_form);
refresh();
set_current_field(my_form, field[0]);
mvprintw(18, 25, _("User name :") );
mvprintw(20, 25, _("Password :"******"This application under GPL license.") );
attroff(A_BLINK);
attroff(A_BOLD);
attron(A_BOLD);
mvprintw(LINES-3, 5, _("F2-> Begin ESC-> Cancel") );
mvprintw(18, 5, _("F5-> Settings") );
attroff(A_BOLD);
mvprintw(7,3, _(" Acik "));
mvprintw(8,3," _| _| _| ");
mvprintw(9,3," _|_|_| _| _|_| _|_|_|_| _|_|_| _|_| _|_| ");
mvprintw(10,3," _| _|_| _| _|_|_|_| _| _| _| _| _|_|_|_| ");
mvprintw(11,3," _| _|_| _| _| _| _| _| _| _| ");
mvprintw(12,3," _| _|_|_| _| _|_|_| _|_| _| _| _| _|_|_| ");
refresh();
while((ch = getch()) )
{ switch(ch)
{
case 8: /*KEY_BACKSPACE hatali kod vermekte 8 dogru olandir konsolda 8 xterm key_backspace*/
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case KEY_BACKSPACE:
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case 9: /*TAB tusuna basýlmasý durumunda sonraki field konumlan*/
form_driver(my_form, REQ_NEXT_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case 10: /*ENTER tuþuna basýlmasý durumunda sonraki feild gececek*/
form_driver(my_form, REQ_NEXT_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_DC: /*del tusu*/
form_driver(my_form,REQ_DEL_CHAR);
break;
case KEY_HOME:
form_driver(my_form,REQ_BEG_LINE);
break;
case KEY_END:
form_driver(my_form,REQ_END_LINE);
break;
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_LEFT:
form_driver(my_form,REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form,REQ_RIGHT_CHAR);
break;
case 27: /*esc durumunda*/
unpost_form(my_form);
free_form(my_form);
free_field(field[0]);
free_field(field[1]);
endwin();
exit(0);
break;
case KEY_F(5): /*ayarlara gecis*/
ayarlar();
unpost_form(my_form);
free_form(my_form);
free_field(field[0]);
free_field(field[1]);
endwin();
exit (0);
break;
case KEY_F(2): /*f2 durumunda*/
form_driver(my_form, REQ_PREV_FIELD);
strcpy(query, "select kullanici, sifre, haklar from kullanicilar");
if ( pgsql_sorgula(query) ==1 ) { mesaj(sql_sorgulama_hatasi); return 1;}
for (i=0;i<pgsql_row_miktar;i++)
{
sprintf(kullanici,"%s", pgsql_kayit_field() );
sprintf(sifre,"%s", pgsql_kayit_field() );
sprintf(haklar,"%s", pgsql_kayit_field() );
if ( strcmp(g_strstrip(field_buffer(field[0],0)), kullanici) ==NULL )
{
if ( (sifre_kripto_coz( g_strstrip(field_buffer(field[1],0)) , sifre) == 0) || (strcmp(g_strstrip(field_buffer(field[1],0)), sifre) == NULL ) )
{
//kullanýcý root ise haklar full olmalý
//databaseden degistirme ihtimali olabilir
if ( strstr( kullanici, "root") )
{sprintf(haklar,"%s", "1111111111111111111111111111111111111111111111111111111111111111");}
beep();
unpost_form(my_form);
free_form(my_form);
free_field(field[0]);
free_field(field[1]);
touchwin(ana_win);
wrefresh(ana_win);
return;
}
else
{
set_field_buffer(field[0],0," ");
set_field_buffer(field[1],0," ");
refresh();
//beep sesi
beep();
}
}
}
break;
default:
form_driver(my_form, ch);
break;
}
}
return 0;
/*son*/
}
char *input_box(size_t length, const char *title, const char *description)
{
WINDOW *ib_win = NULL;
PANEL *my_panels[1];
FIELD **fields;
FORM *my_form = NULL;
int height, width, startx, starty, max_height, max_width, ch = 0, rows,
cols, quit = 0, i;
char *result_ptr = NULL, *temp_ptr = NULL;
/* create a buffer with the size of 'length' */
if (!(temp_ptr = malloc(length))) {
vrmr_error(-1, VR_ERR, gettext("malloc failed: %s"), strerror(errno));
return (NULL);
}
// set the window size
getmaxyx(stdscr, max_height, max_width);
height = 8;
if (length < 16) {
width = 37; // minimum TODO: why 37?
} else if ((int)length + 8 > max_width) {
free(temp_ptr);
return NULL;
} else {
width = (int)length + 8;
if ((int)StrLen(title) + 8 > width)
width = (int)StrLen(title) + 8;
if ((int)StrLen(description) + 8 > width)
width = (int)StrLen(description) + 8;
}
// print on the centre of the screen
starty = (max_height - height) / 2;
startx = (max_width - width) / 2;
// create window
ib_win = create_newwin(
height, width, starty, startx, title, vccnf.color_win);
my_panels[0] = new_panel(ib_win);
fields = (FIELD **)calloc(1 + 1, sizeof(FIELD *));
fields[0] = new_field_wrap(
1, (int)length - 1, 3, (int)(((width - length) / 2) - 2), 0, 0);
set_field_back(fields[0], vccnf.color_win_rev);
field_opts_off(fields[0], O_AUTOSKIP);
set_field_status(fields[0], FALSE);
my_form = new_form(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);
mvwprintw(ib_win, 2, 4, "%s", description);
mvwprintw(ib_win, 6, 4, gettext("Note: whitespaces not allowed."));
update_panels();
doupdate();
while (quit == 0) {
ch = wgetch(ib_win);
switch (ch) {
case 27:
case KEY_F(10):
case 10: // enter
// Go to next field
form_driver_wrap(my_form, REQ_NEXT_FIELD);
form_driver_wrap(my_form, REQ_END_LINE);
quit = 1;
break;
case KEY_BACKSPACE:
case 127:
form_driver_wrap(my_form, REQ_PREV_CHAR);
form_driver_wrap(my_form, REQ_DEL_CHAR);
form_driver_wrap(my_form, REQ_END_LINE);
break;
case KEY_DC:
form_driver_wrap(my_form, REQ_PREV_CHAR);
form_driver_wrap(my_form, REQ_DEL_CHAR);
form_driver_wrap(my_form, REQ_END_LINE);
break;
default:
// If this is a normal character, it gets printed
form_driver_wrap(my_form, ch);
break;
}
}
// status_print(status_win, "data: '%s' (%d)", field_buffer(fields[0], 0),
// length);
(void)strlcpy(temp_ptr, field_buffer(fields[0], 0), length);
// get the length of the entry
i = strlen(temp_ptr);
while (i--) {
if (isspace(temp_ptr[i]))
temp_ptr[i] = '\0';
else
break;
}
if (!(result_ptr = strdup(temp_ptr))) {
vrmr_error(-1, VR_ERR, gettext("malloc failed: %s"), strerror(errno));
goto end;
}
if (result_ptr[0] == '\0') {
free(result_ptr);
result_ptr = NULL;
}
end:
free(temp_ptr);
unpost_form(my_form);
free_form(my_form);
free_field(fields[0]);
free(fields);
del_panel(my_panels[0]);
destroy_win(ib_win);
update_panels();
doupdate();
return (result_ptr);
}
void viewEditTeamProperties(FootBallGame::TeamNumber teamNumber) {
const char *fieldBuffer;
const ITEM *currentItem;
const char *itemName;
ITEM **items;
const int window_nlines = 10,
window_ncols = 90;
char *choices[] = {
"Ok",
"Cancel",
};
for(;;) {
// Create new window.
WINDOW *window = newwin(window_nlines,
window_ncols,
headerWindow_begin_y + headerWindow_nlines + 1,
0);
// Set new window options.
keypad(window, TRUE);
// Team the team
FootBallTeam *team = game.getFootBallTeam(teamNumber);
// Create the form fields
FIELD *field[2];
field[0] = new_field(1, 20, 2, 22, 0, 0);
field[1] = NULL;
// Set feild options
set_field_back(field[0], A_UNDERLINE);
field_opts_off(field[0], O_AUTOSKIP);
set_field_type(field[0], TYPE_REGEXP, "^[A-Za-z ]*$");
if (team) {
String teamName = team->getTeamName();
set_field_buffer(field[0], 0, teamName.c_str());
}
// Create the form
FORM *form = new_form(field);
// Attach the form to the window
set_form_win(form, window);
set_form_sub(form, derwin(window, 4, 90, 0, 0));
// Setup the menu
int nChoices = ARRAY_SIZE(choices)+1;
items = new ITEM* [nChoices];
for (int i = 0; i < nChoices-1; i++)
items[i] = new_item(choices[i], NULL);
items[nChoices-1] = NULL;
// Create the menu
MENU *menu = new_menu(items);
// Menu options
set_menu_format(menu, 1, 2);
set_menu_mark(menu, NULL);
// Attach the menu to the window
set_menu_win(menu, window);
set_menu_sub(menu, derwin(window, 1, 20, 4, 17));
// Make window and menu visible;
post_form(form);
post_menu(menu);
mvwprintw(window, 0, 10, "Team Properties: ");
mvwprintw(window, 2, 10, "Team Name: ");
wrefresh(window);
refresh();
// Start user interaction loop.
int c;
// The restart variable is used to tell the function to rebuild the
// menu by starting at the top of the for(;;) loop above.
bool restart = false;
while (!restart && (c = wgetch(window))) {
switch(c) {
case KEY_DOWN:
case 0x09:
// Go to next field
form_driver(form, REQ_NEXT_FIELD);
// GO to the end of the presend buffer
// Leaves nicely at the last character
form_driver(form, REQ_END_LINE);
break;
case KEY_UP:
// Go to previous field
form_driver(form, REQ_PREV_FIELD);
form_driver(form, REQ_END_LINE);
break;
case 0x7F:
form_driver(form, REQ_DEL_PREV);
break;
case KEY_LEFT:
menu_driver(menu, REQ_LEFT_ITEM);
break;
case KEY_RIGHT:
menu_driver(menu, REQ_RIGHT_ITEM);
break;
case 10: // Enter
// When the user hits enter determine the currently selected
// item and do nessary actions.
currentItem = current_item(menu);
itemName = item_name(currentItem);
if (strcmp(itemName, choices[0]) == 0) {
form_driver(form, REQ_VALIDATION);
fieldBuffer = field_buffer(field[0], 0);
if (fieldBuffer != NULL && strcmp(fieldBuffer, "") != 0) {
if (team == NULL) {
team = new FootBallTeam;
game.setFootBallTeam(teamNumber, team);
}
team->setTeamName(fieldBuffer);
}
}
// Delete allocated data
delwin(window);
unpost_form(form);
free_form(form);
unpost_menu(menu);
free_menu(menu);
for (unsigned i = 0; i < ARRAY_SIZE(field); i++)
free_field(field[i]);
for (int i = 0; i < nChoices-1; i++)
free_item(items[i]);
delete[] items;
return;
default:
// If this is a normal character, it gets printed.
form_driver(form, c);
break;
}
}
}
}
void viewNewPlayer(FootBallGame::TeamNumber teamNumber) {
const char *itemName;
const ITEM *currentItem;
const int window_nlines = 10,
window_ncols = 90;
char *choices[] = {
"Add",
"Cancel",
};
for (;;) {
// Create new window.
WINDOW *window = newwin(window_nlines,
window_ncols,
headerWindow_begin_y + headerWindow_nlines + 1,
0);
// Set new window options.
keypad(window, TRUE);
// Create the form fields
FIELD *field[6];
for (unsigned i = 0; i < ARRAY_SIZE(field)-1; i++)
field[i] = new_field(1, 26, i+2, 23, 0, 0);
field[ARRAY_SIZE(field)-1] = NULL;
// Set feild options
for (unsigned i = 0; i < ARRAY_SIZE(field)-1; i++) {
set_field_back(field[i], A_UNDERLINE);
field_opts_off(field[i], O_AUTOSKIP);
}
// Set the field types
set_field_type(field[0], TYPE_REGEXP, "^[A-Za-z ]*$");
set_field_type(field[1], TYPE_INTEGER, 0, 1, 999);
set_field_type(field[2], TYPE_REGEXP, "^[A-Za-z ]*$");
set_field_type(field[3], TYPE_NUMERIC, 2, 1.00, 1500.00);
set_field_type(field[4], TYPE_NUMERIC, 2, 1.00, 300.00);
// Create the form
FORM *form = new_form(field);
set_form_win(form, window);
set_form_sub(form, derwin(window, 10, 90, 0, 0));
// Setup the menu items
int nChoices = ARRAY_SIZE(choices)+1;
ITEM **items = new ITEM* [nChoices];
for (int i = 0; i < nChoices-1; i++)
items[i] = new_item(choices[i], NULL);
items[nChoices-1] = NULL;
// Create the menu
MENU *menu = new_menu(items);
// Menu options
set_menu_format(menu, 1, 2);
set_menu_mark(menu, NULL);
// Attach the menu to the window
set_menu_win(menu, window);
set_menu_sub(menu, derwin(window, 1, 20, 8, 17));
// Make window and menu visible;
post_form(form);
post_menu(menu);
mvwprintw(window, 0, 10, "Player Properties: ");
mvwprintw(window, 2, 10, "Name: ");
mvwprintw(window, 3, 10, "Number: ");
mvwprintw(window, 4, 10, "Position: ");
mvwprintw(window, 5, 10, "weight (kg): ");
mvwprintw(window, 6, 10, "height (cm): ");
wrefresh(window);
refresh();
// Start user interaction loop.
int c;
// The restart variable is used to tell the function to rebuild the
// menu by starting at the top of the for(;;) loop above.
bool restart = false;
while (!restart && (c = wgetch(window))) {
mvprintw(LINES-1, 0, " ");
refresh();
switch(c) {
case KEY_DOWN:
case 0x09:
// Go to next field
form_driver(form, REQ_NEXT_FIELD);
// GO to the end of the presend buffer
// Leaves nicely at the last character
form_driver(form, REQ_END_LINE);
break;
case KEY_UP:
// Go to previous field
form_driver(form, REQ_PREV_FIELD);
form_driver(form, REQ_END_LINE);
break;
case 0x7F:
form_driver(form, REQ_DEL_PREV);
break;
case KEY_LEFT:
menu_driver(menu, REQ_LEFT_ITEM);
break;
case KEY_RIGHT:
menu_driver(menu, REQ_RIGHT_ITEM);
break;
case 10:
// When the user hits enter determine the currently selected
// item and do nessary actions.
currentItem = current_item(menu);
itemName = item_name(currentItem);
// Cancel
if (strncmp(itemName, choices[1], strlen(choices[1])) == 0) {
// Delete allocated data
unpost_form(form);
unpost_menu(menu);
free_form(form);
free_menu(menu);
for (unsigned i = 0; i < ARRAY_SIZE(field)-1; i++)
free_field(field[i]);
for (int i = 0; i < nChoices; i++)
free_item(items[i]);
delete [] items;
delwin(window);
return;
} else if (strncmp(itemName, choices[0], strlen(choices[0])) == 0) {
form_driver(form, REQ_VALIDATION);
bool invalid = false;
for (unsigned i = 0; i < ARRAY_SIZE(field)-1; i++)
if (field_status(field[i])==false)
invalid = true;;
if (invalid == false) {
FootBallPlayer *player = new FootBallPlayer;
player->setName(field_buffer(field[0], 0));
player->setNumber(atoi(field_buffer(field[1], 0)));
player->setPosition(field_buffer(field[2], 0));
player->setWeight(strtof(field_buffer(field[3], 0), NULL));
player->setHeight(strtof(field_buffer(field[4], 0), NULL));
FootBallTeam *team = game.getFootBallTeam(teamNumber);
if (team == NULL) {
team = new FootBallTeam;
game.setFootBallTeam(teamNumber, team);
}
team->addFootBallPlayer(player);
// Delete allocated data
unpost_form(form);
unpost_menu(menu);
free_form(form);
free_menu(menu);
for (unsigned i = 0; i < ARRAY_SIZE(field)-1; i++)
free_field(field[i]);
for (int i = 0; i < nChoices; i++)
free_item(items[i]);
delete [] items;
delwin(window);
return;
} else {
mvprintw(LINES-1, 0, "Fill out the form correctly!!");
refresh();
}
}
break;
default:
// If this is a normal character, it gets
// printed
form_driver(form, c);
break;
}
}
}
}
void actions_menu(const char *curr_path) {
const char *screen_title = "Actions";
FIELD *field[2];
FORM *my_form;
initscr();
curs_set(1);
cbreak();
clear();
noecho();
keypad(stdscr, TRUE);
field[0] = new_field( 1, MAX_CANUM, 4, 25, 0, 0 );
field[1] = NULL;
set_field_back(field[0], A_UNDERLINE);
field_opts_off(field[0], O_AUTOSKIP);
field_opts_on(field[0], O_BLANK);
my_form = new_form(field);
post_form(my_form);
refresh();
mvprintw( 0, 0, menu_path( curr_path, screen_title ) );
mvprintw( 2, 10, "Enter case number then press (Enter) to start. | (F4) = Exit" );
mvprintw( 4, 10, "Case Num: " );
refresh();
move( 4, 25 );
set_current_field( my_form, field[0] );
int done = 0;
int ch;
do {
ch = getch();
switch ( ch ) {
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 DEL:
form_driver( my_form, REQ_DEL_CHAR );
break;
case ENTER:
{
size_t count = 0;
char case_num[MAX_CANUM];
form_driver(my_form, REQ_NEXT_FIELD);
strcpy(case_num, compress_str(field_buffer(field[0], 0) ));
if ( query_select_count_from_case_for(case_num, &count) ) {
clear_line(20, 10);
mvprintw( 20, 10, db_get_error_msg() );
move( 4, 25 );
} else {
if ( count ) {
actions_dataentry_scr( menu_path( curr_path, screen_title ), case_num );
done = 1;
break;
}
}
}
break;
default:
if ( ch == '\'' )
break;
form_driver( my_form, ch );
break;
}
} while ( ( ch != KEY_F(4) ) && ( done != 1 ) );
unpost_form( my_form );
free_form( my_form );
free_field( field[0] );
endwin();
return;
}
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;
}
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;
}
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;
}
void set_new_db_conn(const char *curr_path) {
const int n_fields = 5;
const int width = 20;
const int starty = 4;
const int startx = 20;
FIELD *field[n_fields];
FORM *my_form;
char *screen_title = "New DB Connection";
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, 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_PUBLIC);
set_field_back(field[3], A_UNDERLINE);
field_opts_off(field[3], O_AUTOSKIP);
my_form = new_form(field);
post_form(my_form);
refresh();
mvprintw(0, 0, menu_path(curr_path, screen_title));
mvprintw(4, 10, "Server: ");
mvprintw(6, 10, "User: "******"Password: "******"DB: ");
mvprintw(14, 10, "(F2) = Save and Exit | (F4) = Exit without saving");
move(4, 20);
refresh();
int ch;
do {
ch = getch();
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_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);
break;
case KEY_BACKSPACE:
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case DEL:
form_driver(my_form, REQ_DEL_CHAR);
break;
default:
if (is_space(ch) == 0)
form_driver(my_form, ch);
break;
}
} while( (ch != KEY_F(2)) && (ch != KEY_F(4)) );
if (ch == KEY_F(2)) {
char *server = field_buffer(field[0], 0);
char *admin = field_buffer(field[1], 0);
char *pass = field_buffer(field[2], 0);
char *db = field_buffer(field[3], 0);
strcpy(server, compress_str(server));
strcpy(admin, compress_str(admin));
strcpy(pass, compress_str(pass));
strcpy(db, compress_str(db));
int result = set_db_cnf(server, admin, pass, db);
mvprintw(16, 10, "**Warning: The system will apply changes to the configuration now.");
close_db();
init_db();
mvprintw(18, 10, "Press any key to continue...");
ch = getch();
if (connect_to_db() == 1) {
mvprintw(20, 10, "[!] Unable to connect to database with new configuration.");
} else {
mvprintw(20, 10, "[!] Connection successful.");
}
ch = getch();
}
unpost_form(my_form);
free_form(my_form);
for (size_t i = 0; i < n_fields -1; ++i) {
free_field(field[i]);
}
endwin();
return;
}
void from_to_selector(const char *curr_path, char **from, char **to, int *action) {
const size_t n_fields = 3;
const size_t starty = 6;
const size_t startx = 25;
FIELD *field[n_fields];
FORM *my_form;
int width[] = { MAX_FROM_DATE, MAX_TO_DATE };
int height[] = { 1, 1 };
initscr();
curs_set(1);
cbreak();
clear();
noecho();
keypad(stdscr, TRUE);
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 );
my_form = new_form(field);
post_form(my_form);
refresh();
mvprintw( 0, 0, curr_path );
mvprintw( 4, 10, "Enter period for report:" );
mvprintw( 6, 10, "From: " );
mvprintw( 8, 10, "To: " );
mvprintw( 10, 10, "(F2) = Execute | (ESC) = Previous Screen" );
move( 6, 25 );
set_current_field( my_form, field[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 );
form_driver( my_form, REQ_END_LINE );
break;
case KEY_F(2):
{
char my_from[MAX_FROM_DATE];
strncpy( my_from, compress_str(field_buffer( field[0], 0 )), MAX_FROM_DATE );
*from = malloc( strlen( my_from ) + 1 );
strcpy( *from, my_from );
char my_to[MAX_TO_DATE];
strncpy( my_to, compress_str(field_buffer( field[1], 0 )), MAX_TO_DATE );
*to = malloc( strlen( my_to ) + 1 );
strcpy( *to, my_to );
}
break;
case DEL:
form_driver(my_form, REQ_DEL_CHAR);
break;
default:
if ( ch == '\'' )
break;
form_driver( my_form, ch );
break;
}
} while ( (ch != ESC) && (ch != KEY_F(2)) );
*action = ch;
unpost_form( my_form );
free_form( my_form );
for ( size_t i = 0; i < n_fields - 1; ++i )
free_field( field[i] );
return;
}
int uponadd()
{
FIELD *field[3];
FORM *my_form;
WINDOW *my_form_win;
int ch, rows, cols;
int ext=0;
/* Initialize curses */
initscr();
start_color();
cbreak();
noecho();
keypad(stdscr, TRUE);
/* Initialize few color pairs */
init_pair(1, COLOR_RED, COLOR_BLACK);
/* Initialize the fields */
field[0] = new_field(1, 40, 1, 0, 0, 0);
field[1] = new_field(1, 40, 3, 0, 0, 0);
field[2] = NULL;
/* Set field options */
set_field_back(field[0], A_UNDERLINE);
field_opts_off(field[0], O_AUTOSKIP); /* Don't go to next field when this */
/* Field is filled up */
set_field_back(field[1], A_UNDERLINE);
field_opts_off(field[1], O_AUTOSKIP);
int trash =set_field_type(field[0],TYPE_ALPHA,1);
trash=set_field_type(field[1],TYPE_INTEGER,1);
/* Create the form and post it */
my_form = new_form(field);
/* Calculate the area required for the form */
scale_form(my_form, &rows, &cols);
/* Create the window to be associated with the form */
int xx,yy;
getmaxyx(stdscr,yy,xx);
my_form_win = newwin(rows + 4, cols + 4, (yy/2), (xx/2)-18);
keypad(my_form_win, TRUE);
/* Set main window and sub window */
set_form_win(my_form, my_form_win);
set_form_sub(my_form, derwin(my_form_win,rows,cols,2,2));
/* Print a border around the main window and print a title */
box(my_form_win, 0, 0);
print_in_middle(my_form_win, 1, 0, cols + 4, "Add contact", COLOR_PAIR(1));
post_form(my_form);
wrefresh(my_form_win);
mvprintw(LINES - 2, 0, "Use arrow keys to switch between fields | Press ESC to cancel");
move((y/2)+3,(x/2)-16);
refresh();
/* Loop through to get user requests */
while((ch = wgetch(my_form_win)) != 27)
{ switch(ch)
{ case KEY_DOWN:
/* Go to next field */
form_driver(my_form, REQ_NEXT_FIELD);
/* Go to the end of the present buffer */
/* Leaves nicely at the last character */
form_driver(my_form, REQ_END_LINE);
break;
case KEY_UP:
/* Go to previous field */
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_BACKSPACE:
/* Go to previous field */
form_driver(my_form,REQ_DEL_PREV);
break;
case KEY_DC:
form_driver(my_form,REQ_DEL_CHAR);
break;
case KEY_HOME:
form_driver(my_form,REQ_BEG_FIELD);
break;
case KEY_END:
form_driver(my_form,REQ_END_FIELD);
break;
case KEY_LEFT:
form_driver(my_form,REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form,REQ_RIGHT_CHAR);
break;
case 9:
form_driver(my_form,REQ_NEXT_FIELD);
break;
case 10:
{
char *str=malloc(1000);
form_driver(my_form,REQ_BEG_FIELD);
sprintf(str, "%s", field_buffer(field[0],0));
size_t len = 0;
char *frontp = str - 1;
char *endp = NULL;
len = strlen(str);
endp = str + len;
while( isspace(*(++frontp)) );
while( isspace(*(--endp)) && endp != frontp );
if( str + len - 1 != endp )
*(endp + 1) = '\0';
else if( frontp != str && endp == frontp )
*str = '\0';
endp = str;
if( frontp != str )
{
while( *frontp ) *endp++ = *frontp++;
*endp = '\0';
}
char *stp=malloc(1000);
strcpy(stp,str);
//mvprintw(LINES - 3, 0, "%s %d",stp,strlen(stp));
//refresh();
sprintf(str, "%s", field_buffer(field[1],0));
len=0;
frontp=str-1;
endp=NULL;
len = strlen(str);
endp = str + len;
while( isspace(*(++frontp)) );
while( isspace(*(--endp)) && endp != frontp );
if( str + len - 1 != endp )
*(endp + 1) = '\0';
else if( frontp != str && endp == frontp )
*str = '\0';
endp = str;
if( frontp != str )
{
while( *frontp ) *endp++ = *frontp++;
*endp = '\0';
}
if((strlen(stp)>0) && (strlen(str)>0))
{
newcontact(stp,str);
ext=1;
}
else if(strlen(str)==0)
form_driver(my_form, REQ_NEXT_FIELD);
}
default:
/* If this is a normal character, it gets */
/* Printed */
form_driver(my_form, ch);
break;
}
if(ext==1)
break;
}
/* Un post form and free the memory */
unpost_form(my_form);
free_form(my_form);
free_field(field[0]);
free_field(field[1]);
endwin();
return ext;
}
