// =======================================================
int CRestoreOptWindow::create(char *szDevice, char *szImageFile, COptions options)
{
BEGIN;
char szTemp[1024];
SNPRINTF(szTemp, i18n("restore partition from image file"));
newtCenteredWindow(78, 20, szTemp);
m_labelOptions = newtLabel(1, 1, i18n("Options"));
m_checkEraseWithNull = newtCheckbox(1, 3, i18n("Erase free blocks with zero values"), (!!options.bEraseWithNull ? 'X' : ' '), " X", NULL);
m_checkSimulateMode = newtCheckbox(1, 2, i18n("Simulation of the restoration (nothing is written)"), (!!options.bSimulateMode ? 'X' : ' '), " X", NULL);
m_labelFinish = newtLabel(1, 5, i18n("If finished successfully:"));
m_radioFinishWait = newtRadiobutton(1, 6, i18n("Wait"), options.dwFinish == FINISH_WAIT, NULL);
m_radioFinishHalt = newtRadiobutton(1, 7, i18n("Halt"), options.dwFinish == FINISH_HALT, m_radioFinishWait);
m_radioFinishReboot = newtRadiobutton(1, 8, i18n("Reboot"), options.dwFinish == FINISH_REBOOT, m_radioFinishHalt);
m_radioFinishQuit = newtRadiobutton(1, 9, i18n("Quit"), options.dwFinish == FINISH_QUIT, m_radioFinishReboot);
addButtons();
m_formMain = newtForm(NULL, NULL, 0);
newtFormAddComponents(m_formMain, m_labelOptions, m_checkSimulateMode, m_checkEraseWithNull, NULL);
newtFormAddComponents(m_formMain, m_labelFinish, m_radioFinishWait, m_radioFinishHalt, m_radioFinishReboot, m_radioFinishQuit, NULL);
//newtFormAddComponents(m_formMain, m_btnRestore, m_btnExit, NULL);
addHotKeys();
newtDrawForm(m_formMain);
RETURN_int(0);
}
// =======================================================
int CRestoringWindow::create(char *szDevice, char *szImageFile, QWORD qwCurPartSize, DWORD dwCompressionMode, char *szOriginalDevice, char *szFileSystem, tm dateCreate, QWORD qwOrigPartSize, COptions * options)
{
BEGIN;
char szTemp[2048];
char szTemp2[2048];
if (options->bSimulateMode)
SNPRINTF(szTemp, i18n("simulate partition restoration from image file"));
else
SNPRINTF(szTemp, i18n("restore partition from image file"));
newtCenteredWindow(78, 20, szTemp);
SNPRINTF(szTemp, i18n("Partition to restore:.............%s"), szDevice);
m_labelPartition = newtLabel(1, 0, szTemp);
SNPRINTF(szTemp, i18n("Size of partition to restore:.....%s = %llu bytes"), formatSize(qwCurPartSize, szTemp2), qwCurPartSize);
m_labelPartitionSize = newtLabel(1, 1, szTemp);
SNPRINTF(szTemp, i18n("Image file to use.................%s"), szImageFile);
m_labelImageFile = newtLabel(1, 2, szTemp);
SNPRINTF(szTemp, i18n("File system:......................%s"), szFileSystem);
m_labelFS = newtLabel(1, 3, szTemp);
m_labelCompression = newtLabel(1, 4, "");
SNPRINTF(szTemp, i18n("Partition was on device:..........%s\n"), szOriginalDevice);
m_labelOldDevice = newtLabel(1, 5, szTemp);
SNPRINTF(szTemp, i18n("Image created on:.................%s\n"), asctime(&dateCreate));
m_labelDate = newtLabel(1, 6, szTemp);
SNPRINTF(szTemp, i18n("Size of the original partition:...%s = %llu bytes"), formatSize(qwOrigPartSize, szTemp2), qwOrigPartSize);
m_labelOriginalPartitionSize = newtLabel(1, 7, szTemp);
// stats
m_labelStatsTime = newtLabel(1, 9, "");
m_labelStatsTimeRemaining = newtLabel(1, 10, "");
m_labelStatsSpeed = newtLabel(1, 11, "");
m_labelStatsSpace = newtLabel(1, 12, "");
m_progressRestoring = newtScale(1, 18, 70, 100);
m_labelPercent = newtLabel(72, 18, "");
m_formMain = newtForm(NULL, NULL, 0);
newtFormAddComponents(m_formMain, m_labelPartition, m_labelPartitionSize, m_labelImageFile, m_labelFS, m_labelCompression, NULL);
newtFormAddComponents(m_formMain, m_labelOldDevice, m_labelDate, m_labelOriginalPartitionSize, NULL);
newtFormAddComponents(m_formMain, m_labelStatsTime, m_labelStatsTimeRemaining, m_labelStatsSpeed, m_labelStatsSpace, NULL);
newtFormAddComponents(m_formMain, m_progressRestoring, m_labelPercent, NULL);
newtDrawForm(m_formMain);
newtRefresh();
RETURN_int(0);
}
// ============================================================================
unsigned int CExceptionsGUI::windowError(char *szTitle, char *szText, char *szButton, char *szCurPath)
{
BEGIN;
//char szTemp[] = "/tmp/image";
unsigned int nRes;
newtComponent btnOther;
newtComponent formMain = newtForm(NULL, NULL, 0);
if (szButton)
btnOther = newtButton(30, 15, szButton);
else
btnOther = newtButton(30, 15, "(none)");
newtComponent btnOk = newtButton(10, 15, i18n("Change"));
newtComponent btnCancel = newtButton(50, 15, i18n("Cancel"));
newtComponent editFilename = newtEntry(5, 10, szCurPath, 45, NULL, 0);
newtComponent labelFilename = newtLabel(5, 9, i18n("Enter new filename"));
newtComponent labelText = newtTextbox(1, 1, 60, 7, 0);
newtTextboxSetText(labelText, szText);
newtComponent widgetTemp;
newtCenteredWindow(67, 20, szTitle);
if (szButton)
newtFormAddComponents(formMain, editFilename, btnOk, btnOther, btnCancel,
labelFilename, labelText, NULL);
else
newtFormAddComponents(formMain, editFilename, btnOk, btnCancel,
labelFilename, labelText, NULL);
widgetTemp = newtRunForm(formMain);
if (widgetTemp == btnCancel)
nRes = ERR_QUIT;
else if (szButton && widgetTemp == btnOther)
nRes = ERR_CONT;
else
{
strncpy(szNewString, newtEntryGetValue(editFilename), 1023);
*(szNewString+1023) = '\0';
while (szNewString[strlen(szNewString)-1] == '/')
szNewString[strlen(szNewString)-1] = '\0';
nRes = ERR_RETRY;
}
newtFormDestroy(formMain);
newtPopWindow();
RETURN_WORD(nRes);
}
// =======================================================
int CRestoreMbrWindow::create()
{
BEGIN;
char szTemp[2048];
SNPRINTF(szTemp, "%s", i18n("Restore an MBR to the hard disk"));
newtCenteredWindow(78, 20, szTemp);
m_labelList1 = newtLabel(1, 1, i18n("Disk with the MBR to restore"));
m_list1 = newtListbox(1, 2, 8, NEWT_FLAG_SCROLL);
m_labelList2 = newtLabel(35, 1, i18n("Original MBR to use"));
m_list2 = newtListbox(35, 2, 8, NEWT_FLAG_SCROLL);
m_labelType = newtLabel(1, 12, i18n("What to restore:"));
m_radioFull = newtRadiobutton(1, 13, i18n("The whole MBR"), true, NULL);
m_radioBoot = newtRadiobutton(1, 14, "Only the boot loader", false, m_radioFull);
m_radioTable = newtRadiobutton(1, 15, "Only the primary partitions table", false, m_radioBoot);
addButtons();
m_formMain = newtForm(NULL, NULL, 0);
newtFormAddComponents(m_formMain, m_labelList1, m_list1, m_labelList2,
m_list2, m_labelType, m_radioFull, m_radioBoot, m_radioTable, NULL);
//m_btnOkay, m_btnCancel, NULL);
addHotKeys();
newtDrawForm(m_formMain);
RETURN_int(0);
}
int
do_dict()
{
newtComponent form, label, entry, text;
struct newtExitStruct es;
char *entryValue, *wordlist;
newtCenteredWindow(70, 20, NULL);
newtPushHelpLine("输入要查找的词，回车确定，上下键滚动，^C退出");
label = newtLabel(2, 1, "请输入要查找的词");
entry = newtEntry(2, 2, "", 40, &entryValue,
NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
text = newtTextbox(2, 3, 66, 17, NEWT_FLAG_WRAP | NEWT_FLAG_SCROLL);
newtTextboxSetText(text, "");
form = newtForm(NULL, NULL, 0);
newtFormAddHotKey(form, Ctrl('c'));
newtFormAddHotKey(form, Ctrl('\r'));
newtFormAddHotKey(form, Ctrl('\n'));
newtFormAddComponents(form, label, entry, text, NULL);
while (1) {
newtFormRun(form, &es);
if ((es.u.key == Ctrl('c')
|| es.u.key == NEWT_KEY_F12)
&& es.reason == NEWT_EXIT_HOTKEY)
break;
wordlist = search_dict(entryValue);
newtTextboxSetText(text, wordlist);
}
newtFormDestroy(form);
newtPopHelpLine();
newtPopWindow();
return 0;
}
// =======================================================
void COptionsWindow::addHotKeys()
{
newtFormAddComponents(m_formMain, m_btnOkay, m_btnExit, m_btnBack, NULL);
newtFormAddHotKey(m_formMain, KEY_EXIT); // Exit
newtFormAddHotKey(m_formMain, KEY_OKAY); // Okay
newtFormAddHotKey(m_formMain, KEY_BACK); // Back
}
int inputBox(const char * text, int height, int width, poptContext optCon,
int flags, char ** result) {
newtComponent form, entry, okay, cancel, answer, tb;
char * val;
int rc = DLG_OKAY;
int top;
val = poptGetArg(optCon);
tb = textbox(height - 3 - buttonHeight, width - 2,
text, flags, &top);
form = newtForm(NULL, NULL, 0);
entry = newtEntry(1, top + 1, val, width - 2, &val,
NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
newtFormAddComponents(form, tb, entry, NULL);
addButtons(height, width, form, &okay, &cancel, flags);
answer = newtRunForm(form);
if (answer == cancel)
rc = DLG_CANCEL;
*result = val;
return rc;
}
static int newtLicenseBox(const char* title, const char* text, int width, int height) {
int ret = 1;
newtCenteredWindow(width, height, title);
newtComponent form = newtForm(NULL, NULL, 0);
newtComponent textbox = newtTextbox(1, 1, width - 2, height - 7,
NEWT_FLAG_WRAP|NEWT_FLAG_SCROLL);
newtTextboxSetText(textbox, text);
newtFormAddComponent(form, textbox);
char choice;
newtComponent checkbox = newtCheckbox(3, height - 3, _("I accept this license"),
' ', " *", &choice);
newtComponent btn = newtButton(width - 15, height - 4, _("OK"));
newtFormAddComponents(form, checkbox, btn, NULL);
newtComponent answer = newtRunForm(form);
if (answer == btn && choice == '*')
ret = 0;
newtFormDestroy(form);
newtPopWindow();
return ret;
}
static int get_user_input(char *msg, char *buf, int buflen)
{
newtComponent form;
newtComponent ok;
newtComponent cancel;
newtComponent inpfield;
const char *input;
int res = -1;
struct newtExitStruct es;
newtCenteredWindow(60,7, msg);
inpfield = newtEntry(5, 2, "", 50, _NEWT_CAST &input, 0);
ok = newtButton(22, 3, "OK");
cancel = newtButton(32, 3, "Cancel");
form = newtForm(NULL, NULL, 0);
newtFormAddComponents(form, inpfield, ok, cancel, NULL);
newtFormRun(form, &es);
strncpy(buf, input, buflen - 1);
if (es.u.co == ok)
res = 0;
else
res = -1;
newtPopWindow();
newtFormDestroy(form);
return res;
}
static int newtWinOkCancel(const char* title, const char* message, int width, int height,
const char* btn_txt_ok, const char* btn_txt_cancel) {
int ret = 1;
unsigned int btn_width_ok = strlen(btn_txt_ok);
unsigned int btn_width_cancel = strlen(btn_txt_cancel);
// Maybe make the box wider to fix both buttons inside
unsigned int min_width = btn_width_ok + btn_width_cancel + 5;
if (width < min_width)
width = min_width;
unsigned int btn_pos_ok = (width / 3) - (btn_width_ok / 2) - 1;
unsigned int btn_pos_cancel = (width * 2 / 3) - (btn_width_cancel / 2) - 1;
// Move buttons a bit if they overlap
while ((btn_pos_ok + btn_width_ok + 5) > btn_pos_cancel) {
// Move the cancel button to the right if there is enough space left
if ((btn_pos_cancel + btn_width_cancel + 2) < width) {
++btn_pos_cancel;
continue;
}
// Move the OK button to the left if possible
if (btn_pos_ok > 1) {
--btn_pos_ok;
continue;
}
// If they still overlap, we cannot fix the situtation
// and break. Should actually never get here, because we
// adjust the width of the window earlier.
break;
}
newtCenteredWindow(width, height, title);
newtComponent form = newtForm(NULL, NULL, 0);
newtComponent textbox = newtTextbox(1, 1, width - 2, height - 6, NEWT_FLAG_WRAP);
newtTextboxSetText(textbox, message);
newtFormAddComponent(form, textbox);
newtComponent btn_ok = newtButton(btn_pos_ok, height - 4, btn_txt_ok);
newtComponent btn_cancel = newtButton(btn_pos_cancel, height - 4, btn_txt_cancel);
newtFormAddComponents(form, btn_ok, btn_cancel, NULL);
newtComponent answer = newtRunForm(form);
if (answer == btn_ok) {
ret = 0;
}
newtFormDestroy(form);
newtPopWindow();
return ret;
}
static int manage_calls(char *host)
{
newtComponent form;
newtComponent quit;
newtComponent hangup;
newtComponent redirect;
newtComponent channels;
struct newtExitStruct es;
char tmp[80];
/* If there's one thing you learn from this code, it is this...
Never, ever fly Air France. Their customer service is absolutely
the worst. I've never heard the words "That's not my problem" as
many times as I have from their staff -- It should, without doubt
be their corporate motto if it isn't already. Don't bother giving
them business because you're just a pain in their side and they
will be sure to let you know the first time you speak to them.
If you ever want to make me happy just tell me that you, too, will
never fly Air France again either (in spite of their excellent
cuisine). */
snprintf(tmp, sizeof(tmp), "Asterisk Manager at %s", host);
newtCenteredWindow(74, 20, tmp);
form = newtForm(NULL, NULL, 0);
newtFormWatchFd(form, session.fd, NEWT_FD_READ);
newtFormSetTimer(form, 100);
quit = newtButton(62, 16, "Quit");
redirect = newtButton(35, 16, "Redirect");
hangup = newtButton(50, 16, "Hangup");
channels = newtListbox(1,1,14, NEWT_FLAG_SCROLL);
newtFormAddComponents(form, channels, redirect, hangup, quit, NULL);
newtListboxSetWidth(channels, 72);
show_doing("Getting Status", "Retrieving system status...");
try_status();
hide_doing();
for(;;) {
newtFormRun(form, &es);
if (has_input(&session) || (es.reason == NEWT_EXIT_FDREADY)) {
if (input_check(&session, NULL)) {
show_message("Disconnected", "Disconnected from remote host");
break;
}
} else if (es.reason == NEWT_EXIT_COMPONENT) {
if (es.u.co == quit)
break;
if (es.u.co == hangup) {
try_hangup(channels);
} else if (es.u.co == redirect) {
try_redirect(channels);
}
}
rebuild_channels(channels);
}
newtFormDestroy(form);
return 0;
}
// =======================================================
int CSaveOptWindow::create(char *szImageFile, COptions options)
{
BEGIN;
char szTemp[2048];
newtCenteredWindow(78, 20, i18n("save partition to image file"));
m_labelCompression = newtLabel(1, 1, i18n("Compression level"));
m_radioCompNone = newtRadiobutton(1, 2, i18n("None (very fast + very big file)"), options.dwCompression == COMPRESS_NONE, NULL);
m_radioCompGzip = newtRadiobutton(1, 3, "Gzip (.gz: medium speed + small image file)", options.dwCompression == COMPRESS_GZIP, m_radioCompNone);
m_radioCompBzip2 = newtRadiobutton(1, 4, "Bzip2 (.bz2: very slow + very small image file)", options.dwCompression == COMPRESS_BZIP2, m_radioCompGzip);
m_labelOptions = newtLabel(1, 7, i18n("Options"));
m_checkCheckBeforeSaving = newtCheckbox(1, 8, i18n("Check partition before saving"), (!!options.bCheckBeforeSaving ? 'X' : ' '), " X", NULL);
m_checkAskDesc = newtCheckbox(1, 9, i18n("Enter description"), (!!options.bAskDesc ? 'X' : ' '), " X", NULL);
m_checkOverwrite = newtCheckbox(1, 10, i18n("Overwrite without prompt"), (!!options.bOverwrite ? 'X' : ' '), " X", NULL);
m_labelSplit = newtLabel(1, 12, i18n("Image split mode"));
m_radioSplitAuto = newtRadiobutton(1, 13, i18n("Automatic split (when no space left)"), !options.qwSplitSize, NULL);
m_radioSplitSize = newtRadiobutton(1, 14, i18n("Into files whose size is:............"), !!options.qwSplitSize, m_radioSplitAuto);
SNPRINTF(szTemp, "%llu", (!!options.qwSplitSize) ? (options.qwSplitSize/1024/1024) : 2048);
m_editSplitSize = newtEntry(43, 14, szTemp, 8, NULL, 0);
m_labelSplitSizeKB = newtLabel(52, 14, i18n("MiB"));
m_checkSplitWait = newtCheckbox(1, 15, i18n("Wait after each volume change"), (!!options.bSplitWait ? 'X' : ' '), " X", NULL);
m_labelFinish = newtLabel(43, 7, i18n("If finished successfully:"));
m_radioFinishWait = newtRadiobutton(43, 8, i18n("Wait"), options.dwFinish == FINISH_WAIT, NULL);
m_radioFinishHalt = newtRadiobutton(43, 9, i18n("Halt"), options.dwFinish == FINISH_HALT, m_radioFinishWait);
m_radioFinishReboot = newtRadiobutton(43, 10, i18n("Reboot"), options.dwFinish == FINISH_REBOOT, m_radioFinishHalt);
m_radioFinishQuit = newtRadiobutton(43,11,i18n("Quit"), options.dwFinish == FINISH_QUIT, m_radioFinishReboot);
m_radioFinishLast = newtRadiobutton(43,12,i18n("Last"), options.dwFinish == FINISH_LAST, m_radioFinishQuit);
addButtons();
m_formMain = newtForm(NULL, NULL, 0);
newtFormAddComponents(m_formMain, m_labelCompression, m_labelOptions, m_labelSplit, NULL);
newtFormAddComponents(m_formMain, m_radioCompNone, m_radioCompGzip, m_radioCompBzip2, m_checkCheckBeforeSaving, m_checkAskDesc, m_checkOverwrite, NULL);
newtFormAddComponents(m_formMain, m_labelFinish, m_radioFinishWait, m_radioFinishHalt, m_radioFinishReboot, m_radioFinishQuit, m_radioFinishLast, NULL);
newtFormAddComponents(m_formMain, m_radioSplitAuto, m_radioSplitSize, m_labelSplitSizeKB, m_editSplitSize, m_checkSplitWait, NULL);
addHotKeys();
newtDrawForm(m_formMain);
RETURN_int(0);
}
// =======================================================
int CInterfaceNewt::askLogin(char *szLogin, char *szPasswd, WORD size)
{
newtComponent editLoginText;
newtComponent editPasswdText;
newtComponent labelLoginText;
newtComponent labelPasswdText;
newtComponent form;
newtComponent btnOk;
newtComponent btnCancel;
newtComponent temp;
int nOk = 0;
while (!nOk)
{
newtCenteredWindow(65, 20, i18n("Password required"));
labelLoginText = newtTextbox(1, 5, 60, 1, 0);
newtTextboxSetText(labelLoginText, i18n("Enter your login"));
editLoginText = newtEntry(1, 6, "", 55, NULL, NEWT_ENTRY_SCROLL);
labelPasswdText = newtTextbox(1, 9, 60, 1, 0);
newtTextboxSetText(labelPasswdText, i18n("Enter your password"));
editPasswdText = newtEntry(1, 10, "", 55, NULL, NEWT_FLAG_HIDDEN);
btnOk = newtButton(15, 14, i18n("Ok"));
btnCancel = newtButton(40, 14, i18n("Cancel"));
form = newtForm(NULL, NULL, 0);
newtFormAddComponents(form, labelLoginText, editLoginText,
labelPasswdText, editPasswdText, btnOk, btnCancel, NULL);
temp = newtRunForm(form);
newtPopWindow();
if (temp == btnCancel)
{
newtFormDestroy(form);
RETURN_int(-1);
}
strncpy(szLogin, newtEntryGetValue(editLoginText), size-1);
*(szLogin+size-1) = '\0';
strncpy(szPasswd, newtEntryGetValue(editPasswdText), size-1);
*(szPasswd+size-1) = '\0';
if (!(*szLogin) || !(*szPasswd))
msgBoxError(i18n("Text cannot be empty"));
else
nOk = 1;
newtFormDestroy(form);
}
return 0;
}
static int show_doing(char *title, char *tmp)
{
struct newtExitStruct es;
newtComponent label;
showform = newtForm(NULL, NULL, 0);
newtCenteredWindow(70,4, title);
label = newtLabel(3,1,tmp);
newtFormAddComponents(showform,label, NULL);
newtFormSetTimer(showform, 200);
newtFormRun(showform, &es);
return 0;
}
static void addButtons(int height, int width, newtComponent form,
newtComponent * okay, newtComponent * cancel,
int flags) {
if (flags & FLAG_NOCANCEL) {
*okay = makeButton((width - 8) / 2, height - buttonHeight - 1, "Ok");
*cancel = NULL;
newtFormAddComponent(form, *okay);
} else {
*okay = makeButton((width - 18) / 3, height - buttonHeight - 1, "Ok");
*cancel = makeButton(((width - 18) / 3) * 2 + 9,
height - buttonHeight - 1, "Cancel");
newtFormAddComponents(form, *okay, *cancel, NULL);
}
}
int messageBox(const char * text, int height, int width, int type, int flags) {
newtComponent form, yes, tb, answer;
newtComponent no = NULL;
int tFlag = (flags & FLAG_SCROLL_TEXT) ? NEWT_FLAG_SCROLL : 0;
form = newtForm(NULL, NULL, 0);
tb = newtTextbox(1, 1, width - 2, height - 3 - buttonHeight,
NEWT_FLAG_WRAP | tFlag);
newtTextboxSetText(tb, text);
newtFormAddComponent(form, tb);
switch ( type ) {
case MSGBOX_INFO:
break;
case MSGBOX_MSG:
yes = makeButton((width - 8) / 2, height - 1 - buttonHeight, "Ok");
newtFormAddComponent(form, yes);
break;
default:
yes = makeButton((width - 16) / 3, height - 1 - buttonHeight, "Yes");
no = makeButton(((width - 16) / 3) * 2 + 9, height - 1 - buttonHeight,
"No");
newtFormAddComponents(form, yes, no, NULL);
if (flags & FLAG_DEFAULT_NO)
newtFormSetCurrent(form, no);
}
if ( type != MSGBOX_INFO ) {
newtRunForm(form);
answer = newtFormGetCurrent(form);
if (answer == no)
return DLG_CANCEL;
}
else {
newtDrawForm(form);
newtRefresh();
}
return DLG_OKAY;
}
/**
* Open an evalcall form with title @p ttl.
* @param ttl The title to use for the evalcall form.
*/
void
open_evalcall_form(char *ttl) {
/*@ buffers ********************************************************* */
char *title;
char *tmp;
/*@ initialize ****************************************************** */
g_isoform_old_progress = -1;
g_mysterious_dot_counter = 0;
assert(ttl != NULL);
asprintf(&title, ttl);
// BERLIOS: We need to unallocate it somewhere
asprintf(&g_isoform_header_str, title);
// center_string (title, 80);
if (g_text_mode) {
log_msg(0, title);
} else {
asprintf(&tmp, title);
/* BERLIOS: center_string is now broken replace it ! */
//center_string(tmp, 80);
newtPushHelpLine(tmp);
paranoid_free(tmp);
}
/* BERLIOS: center_string is now broken replace it ! */
//center_string(g_isoform_header_str, 36);
g_isoform_starttime = get_time();
if (g_text_mode) {
log_msg(0, g_isoform_header_str);
} else {
g_isoform_header = newtLabel(1, 1, g_isoform_header_str);
g_isoform_scale = newtScale(3, 3, 34, 100);
// newtOpenWindow (20, 6, 40, 7, title); // "Please Wait");
newtCenteredWindow(40, 7, title);
g_isoform_main = newtForm(NULL, NULL, 0);
g_isoform_timeline = newtLabel(1, 5, "This is the timeline");
g_isoform_pcline = newtLabel(1, 6, "This is the pcline");
newtFormAddComponents(g_isoform_main, g_isoform_timeline,
g_isoform_pcline, g_isoform_header,
g_isoform_scale, NULL);
newtRefresh();
}
update_evalcall_form(0);
paranoid_free(title);
}
/**
* Ask the user how much compression they would like to use.
* The choices are "None" (0), "Minimum" (1), "Average" (4), and "Maximum" (9).
* @return The compression level (0-9) chosen, or -1 for "Exit".
*/
int
which_compression_level() {
/*@ char ************************************************************ */
int output = none;
/*@ newt ************************************************************ */
newtComponent b1;
newtComponent b2;
newtComponent b3;
newtComponent b4;
newtComponent b5;
newtComponent b_res;
newtComponent myForm;
newtDrawRootText(18, 0, WELCOME_STRING);
newtPushHelpLine
(_(" Please specify the level of compression that you want."));
// newtOpenWindow (23, 3, 34, 13, "How much compression?");
newtCenteredWindow(34, 13, _("How much compression?"));
b1 = newtButton(4, 1, _("Maximum"));
b2 = newtButton(18, 1, _("Average"));
b3 = newtButton(4, 5, _("Minimum"));
b4 = newtButton(18, 5, _(" None "));
b5 = newtButton(4, 9, _(" Exit "));
myForm = newtForm(NULL, NULL, 0);
newtFormAddComponents(myForm, b1, b3, b2, b4, b5, NULL);
b_res = newtRunForm(myForm);
newtFormDestroy(myForm);
newtPopWindow();
if (b_res == b1) {
output = 9;
} else if (b_res == b2) {
output = 4;
} else if (b_res == b3) {
output = 1;
} else if (b_res == b4) {
output = 0;
} else if (b_res == b5) {
output = -1;
}
newtPopHelpLine();
return (output);
}
static int show_message(char *title, char *msg)
{
newtComponent form;
newtComponent label;
newtComponent ok;
struct newtExitStruct es;
newtCenteredWindow(60,7, title);
label = newtLabel(4,1,msg);
ok = newtButton(27, 3, "OK");
form = newtForm(NULL, NULL, 0);
newtFormAddComponents(form, label, ok, NULL);
newtFormRun(form, &es);
newtPopWindow();
newtFormDestroy(form);
return 0;
}
// =======================================================
int CInterfaceNewt::askText(char *szMessage, char *szTitle, char *szDestText, WORD size)
{
newtComponent editText;
newtComponent labelText;
newtComponent form;
newtComponent btnOk;
newtComponent btnCancel;
newtComponent temp;
*szDestText = 0;
while (!*szDestText)
{
newtCenteredWindow(65, 20, szTitle);
labelText = newtTextbox(1, 1, 60, 7, 0/*NEWT_TEXTBOX_SCROLL*/);
newtTextboxSetText(labelText, szMessage);
editText = newtEntry(1, 9, "", 55, NULL, NEWT_ENTRY_SCROLL);
btnOk = newtButton(15, 14, i18n("Ok"));
btnCancel = newtButton(40, 14, i18n("Cancel"));
form = newtForm(NULL, NULL, 0);
newtFormAddComponents(form, labelText, editText, btnOk, btnCancel, NULL);
temp = newtRunForm(form);
newtPopWindow();
if (temp == btnCancel)
{
newtFormDestroy(form);
RETURN_int(-1);
}
strncpy(szDestText, newtEntryGetValue(editText), size-1);
*(szDestText+size-1) = '\0';
if (*szDestText == 0)
msgBoxError(i18n("Text cannot be empty"));
newtFormDestroy(form);
}
return 0;
}
// =======================================================
void CInterfaceNewt::askDescription(char *szDescription, DWORD dwMaxLen)
{
newtComponent editDesc;
newtComponent labelText;
newtComponent form;
newtComponent btnOk;
memset(szDescription, 0, dwMaxLen);
newtCenteredWindow(65, 18, i18n("Partition description"));
labelText = newtLabel(1, 1, i18n("You can enter a description of the saved partition:"));
editDesc = newtEntry(1, 3, "", 60, NULL, NEWT_ENTRY_SCROLL);
btnOk = newtButton(27, 13, i18n("Ok"));
form = newtForm(NULL, NULL, 0);
newtFormAddComponents(form, labelText, editDesc, btnOk, NULL);
newtRunForm(form);
newtPopWindow();
strncpy(szDescription, newtEntryGetValue(editDesc), dwMaxLen);
newtFormDestroy(form);
}
static int newtChecklist(const char* title, const char* message,
unsigned int width, unsigned int height, unsigned int num_entries,
const char** entries, int* states) {
int ret;
const int list_height = 4;
char cbstates[num_entries];
for (unsigned int i = 0; i < num_entries; i++) {
cbstates[i] = states[i] ? '*' : ' ';
}
newtCenteredWindow(width, height, title);
newtComponent textbox = newtTextbox(1, 1, width - 2, height - 6 - list_height,
NEWT_FLAG_WRAP);
newtTextboxSetText(textbox, message);
int top = newtTextboxGetNumLines(textbox) + 2;
newtComponent form = newtForm(NULL, NULL, 0);
newtComponent sb = NULL;
if (list_height < num_entries) {
sb = newtVerticalScrollbar(
width - 4, top + 1, list_height,
NEWT_COLORSET_CHECKBOX, NEWT_COLORSET_ACTCHECKBOX);
newtFormAddComponent(form, sb);
}
newtComponent subform = newtForm(sb, NULL, 0);
newtFormSetBackground(subform, NEWT_COLORSET_CHECKBOX);
newtFormSetHeight(subform, list_height);
newtFormSetWidth(subform, width - 10);
for (unsigned int i = 0; i < num_entries; i++) {
newtComponent cb = newtCheckbox(4, top + i, entries[i], cbstates[i],
NULL, &cbstates[i]);
newtFormAddComponent(subform, cb);
}
newtFormAddComponents(form, textbox, subform, NULL);
newtComponent btn_okay = newtButton((width - 18) / 3, height - 4, _("OK"));
newtComponent btn_cancel = newtButton((width - 18) / 3 * 2 + 9, height - 4, _("Cancel"));
newtFormAddComponents(form, btn_okay, btn_cancel, NULL);
newtComponent answer = newtRunForm(form);
if ((answer == NULL) || (answer == btn_cancel)) {
ret = -1;
} else {
ret = 0;
for (unsigned int i = 0; i < num_entries; i++) {
states[i] = (cbstates[i] != ' ');
if (states[i])
ret++;
}
}
newtFormDestroy(form);
newtPopWindow();
return ret;
}
int listBox(const char * text, int height, int width, poptContext optCon,
int flags, char ** result) {
newtComponent form, okay, tb, answer, listBox;
newtComponent cancel = NULL;
const char * arg;
char * end;
int listHeight;
int numItems = 0;
int allocedItems = 5;
int i, top;
int rc = DLG_OKAY;
char buf[80], format[20];
int maxTagWidth = 0;
int maxTextWidth = 0;
int scrollFlag;
struct {
const char * text;
const char * tag;
} * itemInfo = malloc(allocedItems * sizeof(*itemInfo));
if (!(arg = poptGetArg(optCon))) return DLG_ERROR;
listHeight = strtoul(arg, &end, 10);
if (*end) return DLG_ERROR;
while ((arg = poptGetArg(optCon))) {
if (allocedItems == numItems) {
allocedItems += 5;
itemInfo = realloc(itemInfo, sizeof(*itemInfo) * allocedItems);
}
itemInfo[numItems].tag = arg;
if (!(arg = poptGetArg(optCon))) return DLG_ERROR;
if (!(flags & FLAG_NOITEM)) {
itemInfo[numItems].text = arg;
} else
itemInfo[numItems].text = "";
if (wstrlen(itemInfo[numItems].text,-1) > (unsigned int)maxTextWidth)
maxTextWidth = wstrlen(itemInfo[numItems].text,-1);
if (wstrlen(itemInfo[numItems].tag,-1) > (unsigned int)maxTagWidth)
maxTagWidth = wstrlen(itemInfo[numItems].tag,-1);
numItems++;
}
form = newtForm(NULL, NULL, 0);
tb = textbox(height - 4 - buttonHeight - listHeight, width - 2,
text, flags, &top);
if (listHeight >= numItems) {
scrollFlag = 0;
i = 0;
} else {
scrollFlag = NEWT_FLAG_SCROLL;
i = 2;
}
listBox = newtListbox(3 + ((width - 10 - maxTagWidth - maxTextWidth - i)
/ 2),
top + 1, listHeight,
NEWT_FLAG_RETURNEXIT | scrollFlag);
sprintf(format, "%%-%ds %%s", maxTagWidth);
for (i = 0; i < numItems; i++) {
sprintf(buf, format, itemInfo[i].tag, itemInfo[i].text);
newtListboxAddEntry(listBox, buf, (void *) i);
}
newtFormAddComponents(form, tb, listBox, NULL);
addButtons(height, width, form, &okay, &cancel, flags);
answer = newtRunForm(form);
if (answer == cancel)
rc = DLG_CANCEL;
i = (int) newtListboxGetCurrent(listBox);
*result = itemInfo[i].tag;
return rc;
}
static int login(char *hostname)
{
newtComponent form;
newtComponent cancel;
newtComponent login;
newtComponent username;
newtComponent password;
newtComponent label;
newtComponent ulabel;
newtComponent plabel;
const char *user;
const char *pass;
struct message *m;
struct newtExitStruct es;
char tmp[55];
struct hostent *hp;
int res = -1;
session.fd = socket(AF_INET, SOCK_STREAM, 0);
if (session.fd < 0) {
snprintf(tmp, sizeof(tmp), "socket() failed: %s\n", strerror(errno));
show_message("Socket failed", tmp);
return -1;
}
snprintf(tmp, sizeof(tmp), "Looking up %s\n", hostname);
show_doing("Connecting....", tmp);
hp = gethostbyname(hostname);
if (!hp) {
snprintf(tmp, sizeof(tmp), "No such address: %s\n", hostname);
show_message("Host lookup failed", tmp);
return -1;
}
hide_doing();
snprintf(tmp, sizeof(tmp), "Connecting to %s", hostname);
show_doing("Connecting...", tmp);
session.sin.sin_family = AF_INET;
session.sin.sin_port = htons(DEFAULT_MANAGER_PORT);
memcpy(&session.sin.sin_addr, hp->h_addr, sizeof(session.sin.sin_addr));
if (connect(session.fd,(struct sockaddr*)&session.sin, sizeof(session.sin))) {
snprintf(tmp, sizeof(tmp), "%s failed: %s\n", hostname, strerror(errno));
show_message("Connect Failed", tmp);
return -1;
}
hide_doing();
login = newtButton(5, 6, "Login");
cancel = newtButton(25, 6, "Cancel");
newtCenteredWindow(40, 10, "Asterisk Manager Login");
snprintf(tmp, sizeof(tmp), "Host: %s", hostname);
label = newtLabel(4,1, tmp);
ulabel = newtLabel(4,2,"Username:"******"Password:"******"", 20, _NEWT_CAST &user, 0);
password = newtEntry(14, 3, "", 20, _NEWT_CAST &pass, NEWT_FLAG_HIDDEN);
form = newtForm(NULL, NULL, 0);
newtFormAddComponents(form, username, password, login, cancel, label, ulabel, plabel,NULL);
newtFormRun(form, &es);
if (es.reason == NEWT_EXIT_COMPONENT) {
if (es.u.co == login) {
snprintf(tmp, sizeof(tmp), "Logging in '%s'...", user);
show_doing("Logging in", tmp);
/* Check to see if the remote host supports MD5 Authentication */
manager_action("Challenge", "AuthType: MD5\r\n");
m = wait_for_response(10000);
if (m && !strcasecmp(get_header(m, "Response"), "Success")) {
char *challenge = get_header(m, "Challenge");
int x;
int len = 0;
char md5key[256] = "";
struct MD5Context md5;
unsigned char digest[16];
MD5Init(&md5);
MD5Update(&md5, (unsigned char *)challenge, strlen(challenge));
MD5Update(&md5, (unsigned char *)pass, strlen(pass));
MD5Final(digest, &md5);
for (x=0; x<16; x++)
len += sprintf(md5key + len, "%2.2x", digest[x]);
manager_action("Login",
"AuthType: MD5\r\n"
"Username: %s\r\n"
"Key: %s\r\n",
user, md5key);
m = wait_for_response(10000);
hide_doing();
if (!strcasecmp(get_header(m, "Response"), "Success")) {
res = 0;
} else {
show_message("Login Failed", get_header(m, "Message"));
}
} else {
memset(m, 0, sizeof(m));
manager_action("Login",
"Username: %s\r\n"
"Secret: %s\r\n",
user, pass);
m = wait_for_response(10000);
hide_doing();
if (m) {
if (!strcasecmp(get_header(m, "Response"), "Success")) {
res = 0;
} else {
show_message("Login Failed", get_header(m, "Message"));
}
}
}
}
}
newtFormDestroy(form);
return res;
}
int handledhcp(void)
{
char *results[MAX_BOXES];
char enabledresult;
char startenabled;
struct newtExitStruct es;
newtComponent header;
newtComponent labels[MAX_BOXES];
newtComponent ok, cancel;
char message[1000];
char *labeltexts[MAX_BOXES] = {
_("Start address:"),
_("End address:"),
_("Primary DNS:"),
_("Secondary DNS:"),
_("Default lease (mins):"),
_("Max lease (mins):"),
_("Domain name suffix:")
};
char *varnames[MAX_BOXES] = {
"START_ADDR_GREEN",
"END_ADDR_GREEN",
"DNS1_GREEN",
"DNS2_GREEN",
"DEFAULT_LEASE_TIME_GREEN",
"MAX_LEASE_TIME_GREEN",
"DOMAIN_NAME_GREEN"
};
char defaults[MAX_BOXES][STRING_SIZE];
int result;
int c;
char temp[STRING_SIZE];
struct keyvalue *mainkv = initkeyvalues();
struct keyvalue *dhcpkv = initkeyvalues();
struct keyvalue *ethernetkv = initkeyvalues();
int error;
FILE *file;
char greenaddress[STRING_SIZE];
char greennetaddress[STRING_SIZE];
char greennetmask[STRING_SIZE];
memset(defaults, 0, sizeof(char) * STRING_SIZE * MAX_BOXES);
if (!(readkeyvalues(dhcpkv, CONFIG_ROOT "/dhcp/settings")))
{
freekeyvalues(dhcpkv);
freekeyvalues(ethernetkv);
errorbox(_("Unable to open settings file"));
return 0;
}
if (!(readkeyvalues(ethernetkv, CONFIG_ROOT "/ethernet/settings")))
{
freekeyvalues(dhcpkv);
freekeyvalues(ethernetkv);
errorbox(_("Unable to open settings file"));
return 0;
}
if (!(readkeyvalues(mainkv, CONFIG_ROOT "/main/settings")))
{
freekeyvalues(dhcpkv);
freekeyvalues(ethernetkv);
freekeyvalues(mainkv);
errorbox(_("Unable to open settings file"));
return 0;
}
/* Set default values. */
findkey(ethernetkv, "GREEN_ADDRESS", defaults[PRIMARY_DNS]);
findkey(mainkv, "DOMAINNAME", defaults[DOMAIN_NAME_SUFFIX]);
strcpy(defaults[DEFAULT_LEASE_TIME], "60");
strcpy(defaults[MAX_LEASE_TIME], "120");
newtCenteredWindow(55, 18, _("DHCP server configuration"));
dhcpform = newtForm(NULL, NULL, 0);
header = newtTextboxReflowed(1, 1,
_("Configure the DHCP server by entering the settings information."),
52, 0, 0, 0);
newtFormAddComponent(dhcpform, header);
strcpy(temp, ""); findkey(dhcpkv, "ENABLE_GREEN", temp);
if (strcmp(temp, "on") == 0)
startenabled = '*';
else
startenabled = ' ';
enabledcheckbox = newtCheckbox(2, TOP + 0, _("Enabled"), startenabled, " *", &enabledresult);
newtFormAddComponent(dhcpform, enabledcheckbox);
newtComponentAddCallback(enabledcheckbox, dhcpdialogcallbackdhcp, NULL);
for (c = 0; c < MAX_BOXES; c++)
{
labels[c] = newtTextbox(2, TOP + 2 + c, 33, 1, 0);
newtTextboxSetText(labels[c], labeltexts[c]);
newtFormAddComponent(dhcpform, labels[c]);
strcpy(temp, defaults[c]); findkey(dhcpkv, varnames[c], temp);
entries[c] = newtEntry(34, TOP + 2 + c, temp, 18, &results[c], 0);
newtFormAddComponent(dhcpform, entries[c]);
if (startenabled == ' ')
newtEntrySetFlags(entries[c], NEWT_FLAG_DISABLED, NEWT_FLAGS_SET);
}
ok = newtButton(10, c + 7, _("OK"));
cancel = newtButton(34, c + 7, _("Cancel"));
newtFormAddComponents(dhcpform, ok, cancel, NULL);
do {
error = 0;
newtFormRun(dhcpform, &es);
if (es.u.co == ok)
{
/* OK was pressed; verify the contents of each entry. */
if (enabledresult == '*')
{
strcpy(message, _("The following fields are invalid:\n\n"));
if (inet_addr(results[START_ADDRESS]) == INADDR_NONE)
{
strcat(message, _("Start address"));
strcat(message, "\n");
error = 1;
}
if (inet_addr(results[END_ADDRESS]) == INADDR_NONE)
{
strcat(message, _("End address"));
strcat(message, "\n");
error = 1;
}
if (strlen(results[SECONDARY_DNS]))
{
if (inet_addr(results[PRIMARY_DNS]) == INADDR_NONE)
{
strcat(message, _("Primary DNS"));
strcat(message, "\n");
error = 1;
}
}
if (strlen(results[SECONDARY_DNS]))
{
if (inet_addr(results[SECONDARY_DNS]) == INADDR_NONE)
{
strcat(message, _("Secondary DNS"));
strcat(message, "\n");
error = 1;
}
}
if (!(atol(results[DEFAULT_LEASE_TIME])))
{
strcat(message, _("Default lease time"));
strcat(message, "\n");
error = 1;
}
if (!(atol(results[MAX_LEASE_TIME])))
{
strcat(message, _("Max. lease time"));
strcat(message, "\n");
error = 1;
}
}
if (error)
errorbox(message);
else
{
for (c = 0; c < MAX_BOXES; c++)
replacekeyvalue(dhcpkv, varnames[c], results[c]);
if (enabledresult == '*')
{
replacekeyvalue(dhcpkv, "ENABLE_GREEN", "on");
fclose(fopen(CONFIG_ROOT "/dhcp/enable_green", "w"));
chown(CONFIG_ROOT "/dhcp/enable_green", 99, 99);
mysystem(NULL, "/usr/local/bin/dhcpctrl enable");
}
else
{
replacekeyvalue(dhcpkv, "ENABLE_GREEN", "off");
unlink(CONFIG_ROOT "/dhcp/enable_green");
mysystem(NULL, "/usr/local/bin/dhcpctrl disable");
}
replacekeyvalue(dhcpkv, "VALID", "yes");
writekeyvalues(dhcpkv, CONFIG_ROOT "/dhcp/settings");
findkey(ethernetkv, "GREEN_ADDRESS", greenaddress);
findkey(ethernetkv, "GREEN_NETADDRESS", greennetaddress);
findkey(ethernetkv, "GREEN_NETMASK", greennetmask);
file = fopen(CONFIG_ROOT "/dhcp/dhcpd.conf", "w");
fprintf(file, "ddns-update-style none;\n");
fprintf(file, "authoritative;\n");
fprintf(file, "subnet %s netmask %s\n", greennetaddress, greennetmask);
fprintf(file, "{\n");
fprintf(file, "\toption subnet-mask %s;\n", greennetmask);
fprintf(file, "\toption domain-name \"%s\";\n", results[DOMAIN_NAME_SUFFIX]);
fprintf(file, "\toption routers %s;\n", greenaddress);
if (strlen(results[PRIMARY_DNS]))
{
fprintf(file, "\toption domain-name-servers ");
fprintf(file, "%s", results[PRIMARY_DNS]);
if (strlen(results[SECONDARY_DNS]))
fprintf(file, ", %s", results[SECONDARY_DNS]);
fprintf(file, ";\n");
}
fprintf(file, "\trange %s %s;\n", results[START_ADDRESS], results[END_ADDRESS]);
fprintf(file, "\tdefault-lease-time %d;\n", (int) atol(results[DEFAULT_LEASE_TIME]) * 60);
fprintf(file, "\tmax-lease-time %d;\n", (int) atol(results[MAX_LEASE_TIME]) * 60);
fprintf(file, "}\n");
fclose(file);
chown(CONFIG_ROOT "/dhcp/dhcpd.conf", 99, 99);
if (automode == 0)
mysystem(NULL, "/usr/local/bin/dhcpctrl enable");
}
result = 1;
}
else
result = 0;
} while (error);
newtFormDestroy(dhcpform);
newtPopWindow();
freekeyvalues(dhcpkv);
freekeyvalues(ethernetkv);
freekeyvalues(mainkv);
return result;
}
static void
nmt_newt_dialog_g_log_handler (const char *log_domain,
GLogLevelFlags log_level,
const char *message,
gpointer user_data)
{
const char *level_name;
char *full_message;
int screen_width, screen_height;
newtComponent text, ok, form;
newtGrid grid;
g_assert (!(log_level & G_LOG_FLAG_RECURSION));
if (log_level & G_LOG_LEVEL_DEBUG)
return;
switch (log_level & G_LOG_LEVEL_MASK) {
case G_LOG_LEVEL_ERROR:
level_name = "ERROR";
break;
case G_LOG_LEVEL_CRITICAL:
level_name = "CRITICAL";
break;
case G_LOG_LEVEL_WARNING:
level_name = "WARNING";
break;
case G_LOG_LEVEL_MESSAGE:
level_name = "Message";
break;
default:
level_name = NULL;
}
full_message = g_strdup_printf ("%s%s%s%s%s",
log_domain ? log_domain : "",
log_domain && level_name ? " " : "",
level_name ? level_name : "",
log_domain || level_name ? ": " : "",
message);
/* newtWinMessage() wraps the window too narrowly by default, so
* we don't want to use that. But we intentionally avoid using any
* NmtNewt classes, to avoid possible error recursion.
*/
newtGetScreenSize (&screen_width, &screen_height);
text = newtTextboxReflowed (-1, -1, full_message, MAX (70, screen_width - 10), 0, 0, 0);
g_free (full_message);
ok = newtButton (-1, -1, "OK");
grid = newtCreateGrid (1, 2);
newtGridSetField (grid, 0, 0, NEWT_GRID_COMPONENT, text, 0, 0, 0, 0, 0, 0);
newtGridSetField (grid, 0, 1, NEWT_GRID_COMPONENT, ok, 0, 1, 0, 0,
NEWT_ANCHOR_RIGHT, 0);
newtGridWrappedWindow (grid, (char *) (level_name ? level_name : ""));
newtGridFree (grid, TRUE);
form = newtForm (NULL, NULL, 0);
newtFormAddComponents (form, text, ok, NULL);
newtRunForm (form);
newtFormDestroy (form);
newtPopWindow ();
}
static void show_spans(void)
{
newtComponent form;
newtComponent quit;
newtComponent label;
newtComponent sel;
struct newtExitStruct es;
quit = newtButton(50,14,"Quit");
sel = newtButton(10,14,"Select");
spans = newtListbox(5, 2, 10, NEWT_FLAG_SCROLL);
newtListboxSetWidth(spans, 65);
label = newtLabel(5,1,"Alarms Span");
newtCenteredWindow(72,18, "DAHDI Telephony Interfaces");
form = newtForm(NULL, NULL, 0);
newtFormSetTimer(form, 200);
newtFormAddComponents(form, spans, sel, quit, label, NULL);
newtComponentAddCallback(spans, sel_callback, NULL);
newtFormAddHotKey(form, NEWT_KEY_F1);
newtFormAddHotKey(form, NEWT_KEY_F10);
for(;;) {
/* Wait for user to select something */
do {
add_cards(spans);
newtFormRun(form, &es);
} while(es.reason == NEWT_EXIT_TIMER);
switch(es.reason) {
case NEWT_EXIT_COMPONENT:
if (es.u.co == quit) {
/* Quit if appropriate */
newtFormDestroy(form);
return;
} else if (es.u.co == sel) {
show_span(-1);
}
break;
case NEWT_EXIT_HOTKEY:
switch(es.u.key) {
case NEWT_KEY_F1:
show_span(-1);
break;
case NEWT_KEY_F10:
newtFormDestroy(form);
return;
}
break;
default:
break;
}
}
}
static void show_span(int span)
{
newtComponent form;
newtComponent back;
newtComponent loop;
newtComponent label;
newtComponent bitbox;
newtComponent inuse;
newtComponent levels;
newtComponent bpvcount;
newtComponent alarms;
newtComponent syncsrc;
newtComponent irqmisses;
char s1[] = " 1111111111222222222233";
char s2[] = "1234567890123456789012345678901";
int x;
int looped = 0;
struct newtExitStruct es;
void *ss;
char info2[256];
if (span < 0) {
/* Display info on a span */
ss = newtListboxGetCurrent(spans);
if (ss) {
span = (long)(ss);
}
}
snprintf(info2, sizeof(info2), "%-59s F10=Back", s[span].desc);
newtOpenWindow(10,2,60,20, s[span].desc);
newtPushHelpLine(info2);
back = newtButton(48,8,"Back");
loop = newtButton(48,14,"Loop");
form = newtForm(NULL, NULL, 0);
newtFormAddComponents(form, back, loop, NULL);
span_max_chan_pos = s[span].totalchans;
for (x=0;x<DAHDI_MAX_CHANNELS;x++) {
DAHDI_PARAMS zp;
int res;
memset(&zp, 0, sizeof(zp));
zp.channo = x;
res = ioctl(ctl, DAHDI_GET_PARAMS, &zp);
if (!res && zp.spanno == span && zp.chanpos > span_max_chan_pos )
span_max_chan_pos = zp.chanpos;
}
if (span_max_chan_pos > 32)
span_max_chan_pos = 32;
s1[span_max_chan_pos] = '\0';
s2[span_max_chan_pos] = '\0';
bitbox = newtTextbox(8,10,span_max_chan_pos,9,0);
newtFormAddComponent(form, bitbox);
label = newtLabel(8,8,s1);
newtFormAddComponent(form, label);
label = newtLabel(8,9,s2);
newtFormAddComponent(form, label);
newtFormAddHotKey(form, NEWT_KEY_F10);
newtFormSetTimer(form, 200);
label = newtLabel(4,10,"TxA");
newtFormAddComponent(form, label);
label = newtLabel(4,11,"TxB");
newtFormAddComponent(form, label);
label = newtLabel(4,12,"TxC");
newtFormAddComponent(form, label);
label = newtLabel(4,13,"TxD");
newtFormAddComponent(form, label);
label = newtLabel(4,15,"RxA");
newtFormAddComponent(form, label);
label = newtLabel(4,16,"RxB");
newtFormAddComponent(form, label);
label = newtLabel(4,17,"RxC");
newtFormAddComponent(form, label);
label = newtLabel(4,18,"RxD");
newtFormAddComponent(form, label);
label = newtLabel(4,7,"Total/Conf/Act: ");
newtFormAddComponent(form, label);
inuse = newtTextbox(24,7,12,1,0);
newtFormAddComponent(form, inuse);
label = newtLabel(4,6,"Tx/Rx Levels: ");
newtFormAddComponent(form, label);
levels = newtTextbox(24,6,30,1,0);
newtFormAddComponent(form, levels);
label = newtLabel(4,5,"Bipolar Viol: ");
newtFormAddComponent(form, label);
bpvcount = newtTextbox(24,5,30,1,0);
newtFormAddComponent(form, bpvcount);
label = newtLabel(4,4,"IRQ Misses: ");
newtFormAddComponent(form, label);
irqmisses = newtTextbox(24,4,30,1,0);
newtFormAddComponent(form, irqmisses);
label = newtLabel(4,3,"Sync Source: ");
newtFormAddComponent(form, label);
syncsrc = newtTextbox(24,3,30,1,0);
newtFormAddComponent(form, syncsrc);
label = newtLabel(4,2,"Current Alarms: ");
newtFormAddComponent(form, label);
alarms = newtTextbox(24,2,30,1,0);
newtFormAddComponent(form, alarms);
for(;;) {
/* Wait for user to select something */
do {
add_cards(NULL);
show_bits(span, bitbox, inuse, levels, bpvcount, alarms, syncsrc, irqmisses);
newtFormRun(form, &es);
} while(es.reason == NEWT_EXIT_TIMER);
switch(es.reason) {
case NEWT_EXIT_COMPONENT:
if (es.u.co == loop) {
looped = !looped;
do_loop(span, looped);
newtFormSetTimer(form, 200);
}
if (es.u.co == back) {
goto out;
}
break;
case NEWT_EXIT_HOTKEY:
switch(es.u.key) {
#if 0
case NEWT_KEY_F1:
show_span(-1);
break;
#endif
case NEWT_KEY_F10:
goto out;
}
break;
default:
break;
}
}
out:
newtFormDestroy(form);
newtPopWindow();
newtPopHelpLine();
span_max_chan_pos = 0;
}
int gauge(const char * text, int height, int width, poptContext optCon, int fd,
int flags) {
newtComponent form, scale, tb;
int top;
const char * arg;
char * end;
int val;
FILE * f = fdopen(fd, "r");
char buf[3000];
char buf3[50];
int i;
setlinebuf(f);
if (!(arg = poptGetArg(optCon))) return DLG_ERROR;
val = strtoul(arg, &end, 10);
if (*end) return DLG_ERROR;
tb = textbox(height - 3, width - 2, text, flags, &top);
form = newtForm(NULL, NULL, 0);
scale = newtScale(2, height - 2, width - 4, 100);
newtScaleSet(scale, val);
newtFormAddComponents(form, tb, scale, NULL);
newtDrawForm(form);
newtRefresh();
while (fgets(buf, sizeof(buf) - 1, f)) {
buf[strlen(buf) - 1] = '\0';
if (!strcmp(buf, "XXX")) {
fgets(buf3, sizeof(buf3) - 1, f);
buf3[strlen(buf3) - 1] = '\0';
arg = buf3;
i = 0;
while (fgets(buf + i, sizeof(buf) - 1 - i, f)) {
buf[strlen(buf) - 1] = '\0';
if (!strcmp(buf + i, "XXX")) {
*(buf + i) = '\0';
break;
}
i = strlen(buf);
}
newtTextboxSetText(tb, buf);
} else {
arg = buf;
}
val = strtoul(buf, &end, 10);
if (!*end) {
newtScaleSet(scale, val);
newtDrawForm(form);
newtRefresh();
}
}
return DLG_OKAY;
}
int checkList(const char * text, int height, int width, poptContext optCon,
int useRadio, int flags, char *** selections) {
newtComponent form, okay, tb, subform, answer;
newtComponent sb = NULL, cancel = NULL;
const char * arg;
char * end;
int listHeight;
int numBoxes = 0;
int allocedBoxes = 5;
int i;
int numSelected;
int rc = DLG_OKAY;
char buf[80], format[20];
int maxWidth = 0;
int top;
struct {
const char * text;
const char * tag;
newtComponent comp;
} * cbInfo = malloc(allocedBoxes * sizeof(*cbInfo));
char * cbStates = malloc(allocedBoxes * sizeof(cbStates));
if (!(arg = poptGetArg(optCon))) return DLG_ERROR;
listHeight = strtoul(arg, &end, 10);
if (*end) return DLG_ERROR;
while ((arg = poptGetArg(optCon))) {
if (allocedBoxes == numBoxes) {
allocedBoxes += 5;
cbInfo = realloc(cbInfo, sizeof(*cbInfo) * allocedBoxes);
cbStates = realloc(cbStates, sizeof(*cbStates) * allocedBoxes);
}
cbInfo[numBoxes].tag = arg;
if (!(arg = poptGetArg(optCon))) return DLG_ERROR;
if (!(flags & FLAG_NOITEM)) {
cbInfo[numBoxes].text = arg;
if (!(arg = poptGetArg(optCon))) return DLG_ERROR;
} else
cbInfo[numBoxes].text = "";
if (!strcmp(arg, "1") || !strcasecmp(arg, "on") ||
!strcasecmp(arg, "yes"))
cbStates[numBoxes] = '*';
else
cbStates[numBoxes] = ' ';
if (wstrlen(cbInfo[numBoxes].tag,-1) > (unsigned int)maxWidth)
maxWidth = wstrlen(cbInfo[numBoxes].tag,-1);
numBoxes++;
}
form = newtForm(NULL, NULL, 0);
tb = textbox(height - 3 - buttonHeight - listHeight, width - 2,
text, flags, &top);
if (listHeight < numBoxes) {
sb = newtVerticalScrollbar(width - 4,
top + 1,
listHeight, NEWT_COLORSET_CHECKBOX,
NEWT_COLORSET_ACTCHECKBOX);
newtFormAddComponent(form, sb);
}
subform = newtForm(sb, NULL, 0);
newtFormSetBackground(subform, NEWT_COLORSET_CHECKBOX);
sprintf(format, "%%-%ds %%s", maxWidth);
for (i = 0; i < numBoxes; i++) {
sprintf(buf, format, cbInfo[i].tag, cbInfo[i].text);
if (useRadio)
cbInfo[i].comp = newtRadiobutton(4, top + 1 + i, buf,
cbStates[i] != ' ',
i ? cbInfo[i - 1].comp : NULL);
else
cbInfo[i].comp = newtCheckbox(4, top + 1 + i, buf,
cbStates[i], NULL, cbStates + i);
newtFormAddComponent(subform, cbInfo[i].comp);
}
newtFormSetHeight(subform, listHeight);
newtFormSetWidth(subform, width - 10);
newtFormAddComponents(form, tb, subform, NULL);
addButtons(height, width, form, &okay, &cancel, flags);
answer = newtRunForm(form);
if (answer == cancel)
rc = DLG_CANCEL;
if (useRadio) {
answer = newtRadioGetCurrent(cbInfo[0].comp);
for (i = 0; i < numBoxes; i++)
if (cbInfo[i].comp == answer) {
*selections = malloc(sizeof(char *) * 2);
(*selections)[0] = cbInfo[i].tag;
(*selections)[1] = NULL;
break;
}
} else {
numSelected = 0;
for (i = 0; i < numBoxes; i++) {
if (cbStates[i] != ' ') numSelected++;
}
*selections = malloc(sizeof(char *) * (numSelected + 1));
numSelected = 0;
for (i = 0; i < numBoxes; i++) {
if (cbStates[i] != ' ')
(*selections)[numSelected++] = cbInfo[i].tag;
}
(*selections)[numSelected] = NULL;
}
return rc;
}