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
}
static int ui_entry__read(const char *title, char *bf, size_t size, int width)
{
struct newtExitStruct es;
newtComponent form, entry;
const char *result;
int err = -1;
newtCenteredWindow(width, 1, title);
form = newtForm(NULL, NULL, 0);
if (form == NULL)
return -1;
entry = newtEntry(0, 0, "0x", width, &result, NEWT_FLAG_SCROLL);
if (entry == NULL)
goto out_free_form;
newtFormAddComponent(form, entry);
newtFormAddHotKey(form, NEWT_KEY_ENTER);
newtFormAddHotKey(form, NEWT_KEY_ESCAPE);
newtFormAddHotKey(form, NEWT_KEY_LEFT);
newtFormAddHotKey(form, CTRL('c'));
newtFormRun(form, &es);
if (result != NULL) {
strncpy(bf, result, size);
err = 0;
}
out_free_form:
newtPopWindow();
newtFormDestroy(form);
return err;
}
static void newt_form__set_exit_keys(newtComponent self)
{
newtFormAddHotKey(self, NEWT_KEY_LEFT);
newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
newtFormAddHotKey(self, 'Q');
newtFormAddHotKey(self, 'q');
newtFormAddHotKey(self, CTRL('c'));
}
int ui_browser__show(struct ui_browser *self, const char *title,
const char *helpline, ...)
{
va_list ap;
if (self->form != NULL) {
newtFormDestroy(self->form);
newtPopWindow();
}
ui_browser__refresh_dimensions(self);
newtCenteredWindow(self->width, self->height, title);
self->form = newt_form__new();
if (self->form == NULL)
return -1;
self->sb = newtVerticalScrollbar(self->width, 0, self->height,
HE_COLORSET_NORMAL,
HE_COLORSET_SELECTED);
if (self->sb == NULL)
return -1;
newtFormAddHotKey(self->form, NEWT_KEY_UP);
newtFormAddHotKey(self->form, NEWT_KEY_DOWN);
newtFormAddHotKey(self->form, NEWT_KEY_PGUP);
newtFormAddHotKey(self->form, NEWT_KEY_PGDN);
newtFormAddHotKey(self->form, NEWT_KEY_HOME);
newtFormAddHotKey(self->form, NEWT_KEY_END);
newtFormAddHotKey(self->form, ' ');
newtFormAddComponent(self->form, self->sb);
va_start(ap, helpline);
ui_helpline__vpush(helpline, ap);
va_end(ap);
return 0;
}
static void
nmt_newt_form_build (NmtNewtForm *form)
{
NmtNewtFormPrivate *priv = NMT_NEWT_FORM_GET_PRIVATE (form);
int screen_height, screen_width, form_height, form_width;
newtComponent *cos;
int i;
priv->dirty = FALSE;
nmt_newt_widget_realize (NMT_NEWT_WIDGET (form));
nmt_newt_widget_size_request (priv->content, &form_width, &form_height);
newtGetScreenSize (&screen_width, &screen_height);
if (!priv->fixed_width)
priv->width = MIN (form_width + 2 * priv->padding, screen_width - 2);
if (!priv->fixed_height)
priv->height = MIN (form_height + 2 * priv->padding, screen_height - 2);
if (!priv->fixed_x)
priv->x = (screen_width - form_width) / 2;
if (!priv->fixed_y)
priv->y = (screen_height - form_height) / 2;
nmt_newt_widget_size_allocate (priv->content,
priv->padding,
priv->padding,
priv->width - 2 * priv->padding,
priv->height - 2 * priv->padding);
if (priv->height - 2 * priv->padding < form_height) {
newtComponent scroll_bar =
newtVerticalScrollbar (priv->width - 1, 0, priv->height,
NEWT_COLORSET_WINDOW,
NEWT_COLORSET_ACTCHECKBOX);
priv->form = newtForm (scroll_bar, NULL, NEWT_FLAG_NOF12);
newtFormAddComponent (priv->form, scroll_bar);
newtFormSetHeight (priv->form, priv->height - 2);
} else
priv->form = newtForm (NULL, NULL, NEWT_FLAG_NOF12);
if (priv->escape_exits)
newtFormAddHotKey (priv->form, NEWT_KEY_ESCAPE);
cos = nmt_newt_widget_get_components (priv->content);
for (i = 0; cos[i]; i++)
newtFormAddComponent (priv->form, cos[i]);
g_free (cos);
if (priv->focus) {
newtComponent fco;
fco = nmt_newt_widget_get_focus_component (priv->focus);
if (fco)
newtFormSetCurrent (priv->form, fco);
}
#ifdef HAVE_NEWTFORMGETSCROLLPOSITION
if (priv->scroll_position)
newtFormSetScrollPosition (priv->form, priv->scroll_position);
#endif
newtOpenWindow (priv->x, priv->y, priv->width, priv->height, priv->title_lc);
}
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 CInterfaceNewt::guiInitMainWindow(char *szDevice, char *szImageFile, char *szNetworkIP, DWORD *dwServerPort, bool *bSsl)
{
newtComponent formMain, btnContinue, btnExit, btnAbout;
newtComponent labelPartition, labelImage, editPartition, editImage, btnImage;
newtComponent widgetTemp, labelAction, radioSave, radioRestore, radioMbr;
newtComponent checkNetwork, labelNetwork, labelPort, editNetwork, editPort, checkSsl;
newtExitStruct event;
char szTemp[1024];
int nAction;
int nRes;
showDebug(8, "guiInitMainWindow\n");
SNPRINTF(szTemp, "Partition Image %s", PACKAGE_VERSION);
newtCenteredWindow(67, 20, szTemp);
labelPartition = newtLabel(1, 0, i18n("* Partition to save/restore"));
editPartition = newtListbox(3, 1, 7, NEWT_FLAG_SCROLL);
labelImage = newtLabel(1, 9, i18n("* Image file to create/use"));
editImage = newtEntry(3, 10, szImageFile, 59, NULL, NEWT_FLAG_SCROLL);
btnImage = newtCompactButton(62, 10, "*");
labelAction = newtLabel(1, 12, i18n("Action to be done:"));
radioSave = newtRadiobutton(1, 13, i18n("Save partition into a new image file"), true, NULL);
radioRestore = newtRadiobutton(1, 14, i18n("Restore partition from an image file"), false, radioSave);
radioMbr = newtRadiobutton(1, 15, i18n("Restore an MBR from the image file"), false, radioRestore);
checkNetwork = newtCheckbox(1, 17, i18n("Connect to server"), (!!(*szNetworkIP) ? 'X' : ' '), " X", NULL);
#ifdef HAVE_SSL
checkSsl = newtCheckbox(5, 19, i18n("Encrypt data on the network with SSL"), (*bSsl ? 'X' : ' '), " X", NULL);
#else
#ifdef MUST_LOGIN
checkSsl = newtLabel(5, 19,i18n("SSL disabled at compile time"));
#else
checkSsl = newtLabel(5, 19,i18n("SSL&login disabled at compile time"));
#endif
#endif
labelNetwork = newtLabel(5, 18, i18n("IP/name of the server:"));
editNetwork = newtEntry(28, 18, szNetworkIP, 25, NULL, 0);
labelPort = newtLabel(54, 18, i18n("Port:"));
SNPRINTF(szTemp, "%u", *dwServerPort);
editPort = newtEntry(60, 18, szTemp, 6, NULL, 0);
btnContinue = newtCompactButton(50, 12, i18n("Next (F5)"));
btnAbout = newtCompactButton(50, 14, i18n("About"));
btnExit = newtCompactButton(50, 16, i18n("Exit (F6)"));
nRes = fillPartitionList(editPartition);
if (nRes == -1)
RETURN_int(-1);
formMain = newtForm(NULL, NULL, 0);
newtFormAddComponents(formMain, labelPartition, labelImage, editPartition, editImage,
btnImage, labelAction, radioSave, radioRestore, radioMbr, checkNetwork,
labelNetwork, editNetwork, labelPort, editPort, checkSsl,
btnContinue, btnAbout, btnExit, NULL);
newtFormAddHotKey(formMain, KEY_EXIT); // Exit
newtFormAddHotKey(formMain, KEY_OKAY); // Okay
begin:
/*widgetTemp = */newtFormRun(formMain, &event);
widgetTemp = newtFormGetCurrent(formMain);
if (((event.reason == event.NEWT_EXIT_HOTKEY) && (event.u.key == KEY_EXIT)) || ((event.reason == event.NEWT_EXIT_COMPONENT) && (widgetTemp == btnExit)))
//if(widgetTemp == btnExit)
return OPERATION_EXIT;
if ((event.reason == event.NEWT_EXIT_COMPONENT) && (widgetTemp == btnAbout))
{
showAboutDialog();
goto begin;
}
if ((event.reason == event.NEWT_EXIT_COMPONENT) && (widgetTemp == btnImage))
{
char *fs_;
fs_=filesel(newtEntryGetValue(editImage));
if(fs_) {
newtEntrySet(editImage, fs_, 1);
// free(fs_);
}
goto begin;
}
if (strcmp(newtEntryGetValue(editImage), "") == 0) // if "image" field empty
{
msgBoxError(i18n("The \"Image\" field is empty. Cannot continue"));
goto begin;
}
if (newtCheckboxGetValue(checkNetwork) == 'X')
{
if (!(*newtEntryGetValue(editNetwork)))
{
msgBoxError(i18n("The \"Server IP/Name\" field is empty. Cannot continue"));
goto begin;
}
if (!atoi((char*)newtEntryGetValue(editPort)))
{
msgBoxError(i18n("The \"Server Port\" field is not a valid integer. Cannot continue"));
goto begin;
}
}
// get device
strcpy(szDevice, (char*)newtListboxGetCurrent(editPartition));
// image file
strcpy(szImageFile, newtEntryGetValue(editImage));
// network
if (newtCheckboxGetValue(checkNetwork) == 'X') // If network is activated
{
strcpy(szNetworkIP, (char*)newtEntryGetValue(editNetwork));
*dwServerPort = atoi((char*)newtEntryGetValue(editPort));
#ifdef HAVE_SSL
*bSsl = (newtCheckboxGetValue(checkSsl) == 'X');
#endif
}
else // no network
{
*szNetworkIP = 0;
*dwServerPort = OPTIONS_DEFAULT_SERVERPORT;
}
nAction = 0;
if (newtRadioGetCurrent(radioRestore) == radioSave)
{
nAction = OPERATION_SAVE;
}
else if (newtRadioGetCurrent(radioRestore) == radioRestore)
{
nAction = OPERATION_RESTORE;
}
else if (newtRadioGetCurrent(radioRestore) == radioMbr)
{
nAction = OPERATION_RESTMBR;
}
newtFormDestroy(formMain);
newtPopWindow();
return nAction;
}
static int getManualModuleArgs(struct moduleInfo * mod, char *** moduleArgs) {
newtGrid grid, buttons;
newtComponent text, f, ok, back, entry;
struct newtExitStruct es;
int done = 0, i;
char * buf;
char *argsEntry = "";
if (*moduleArgs) {
for (i = 0; (*moduleArgs)[i]; i++)
argsEntry = strcat(argsEntry, (*moduleArgs)[i]);
}
f = newtForm(NULL, NULL, 0);
if (asprintf(&buf,
_("Please enter any parameters which you wish to pass "
"to the %s module separated by spaces. If you don't "
"know what parameters to supply, skip this screen "
"by pressing the \"OK\" button."), mod->moduleName) == -1) {
logMessage(CRITICAL, "%s: %d: %m", __func__, __LINE__);
abort();
}
text = newtTextboxReflowed(-1, -1, buf, 60, 0, 10, 0);
entry = newtEntry(-1, -1, argsEntry, 50, (const char **) &argsEntry,
NEWT_ENTRY_SCROLL);
newtFormAddHotKey(f, NEWT_KEY_F12);
buttons = newtButtonBar(_("OK"), &ok, _("Back"), &back, NULL);
grid = newtCreateGrid(1, 3);
newtGridSetField(grid, 0, 0, NEWT_GRID_COMPONENT, text,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 1, NEWT_GRID_COMPONENT, entry,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 2, NEWT_GRID_SUBGRID, buttons,
0, 0, 0, 0, 0, NEWT_GRID_FLAG_GROWX);
newtGridWrappedWindow(grid, _("Enter Module Parameters"));
newtGridAddComponentsToForm(grid, f, 1);
do {
newtFormRun(f, &es);
if (es.reason == NEWT_EXIT_COMPONENT && es.u.co == back) {
done = -1;
} else {
done = 1;
}
} while (done == 0);
free(buf);
newtGridFree(grid, 1);
if (done == -1) {
newtFormDestroy(f);
newtPopWindow();
return LOADER_BACK;
}
logMessage(INFO, "specified args of %s for %s", argsEntry, mod->moduleName);
if (strlen(argsEntry) > 0) {
int numAlloced = 5;
char * start;
char * end;
i = 0;
*moduleArgs = malloc((numAlloced + 1) * sizeof(*moduleArgs));
start = argsEntry;
while (start && *start) {
end = start;
while (!isspace(*end) && *end) end++;
*end = '\0';
(*moduleArgs)[i++] = strdup(start);
start = end + 1;
*end = ' ';
start = strchr(end, ' ');
if (start) start++;
if (i >= numAlloced) {
numAlloced += 5;
*moduleArgs = realloc(*moduleArgs,
sizeof(*moduleArgs) * (numAlloced + 1));
}
}
(*moduleArgs)[i] = NULL;
}
newtFormDestroy(f);
newtPopWindow();
return LOADER_OK;
}
/* setup hard drive based install from a partition with a filesystem and
* ISO images on that filesystem
*/
char * mountHardDrive(struct installMethod * method,
char * location, struct loaderData_s * loaderData) {
int rc;
int i;
newtComponent listbox, label, dirEntry, form, okay, back, text;
struct newtExitStruct es;
newtGrid entryGrid, grid, buttons;
int done = 0;
char * dir = strdup("");
char * tmpDir;
char * url = NULL;
char * buf, *substr;
int numPartitions;
char **partition_list;
char *selpart;
char *kspartition = NULL, *ksdirectory = NULL;
/* handle kickstart/stage2= data first if available */
if (loaderData->method == METHOD_HD && loaderData->stage2Data) {
kspartition = ((struct hdInstallData *)loaderData->stage2Data)->partition;
ksdirectory = ((struct hdInstallData *)loaderData->stage2Data)->directory;
logMessage(INFO, "partition is %s, dir is %s", kspartition, ksdirectory);
/* if exist, duplicate */
if (kspartition)
kspartition = strdup(kspartition);
if (ksdirectory) {
ksdirectory = strdup(ksdirectory);
} else {
ksdirectory = strdup("/images/install.img");
}
if (!kspartition || !ksdirectory) {
logMessage(ERROR, "missing partition or directory specification");
loaderData->method = -1;
if (loaderData->inferredStage2)
loaderData->invalidRepoParam = 1;
} else {
/* if we start with /dev, strip it (#121486) */
char *kspart = kspartition;
if (!strncmp(kspart, "/dev/", 5))
kspart = kspart + 5;
url = setupIsoImages(kspart, ksdirectory, location);
if (!url) {
logMessage(ERROR, "unable to find %s installation images on hd",
getProductName());
loaderData->method = -1;
if (loaderData->inferredStage2)
loaderData->invalidRepoParam = 1;
} else {
free(kspartition);
free(ksdirectory);
return url;
}
}
} else {
kspartition = NULL;
ksdirectory = NULL;
}
/* if we're here its either because this is interactive, or the */
/* hd kickstart directive was faulty and we have to prompt for */
/* location of harddrive image */
partition_list = NULL;
while (!done) {
/* if we're doing another pass free this up first */
if (partition_list)
freePartitionsList(partition_list);
partition_list = getPartitionsList(NULL);
numPartitions = lenPartitionsList(partition_list);
/* no partitions found, try to load a device driver disk for storage */
if (!numPartitions) {
rc = newtWinChoice(_("Hard Drives"), _("Yes"), _("Back"),
_("You don't seem to have any hard drives on "
"your system! Would you like to configure "
"additional devices?"));
if (rc == 2) {
loaderData->stage2Data = NULL;
return NULL;
}
rc = loadDriverFromMedia(DEVICE_DISK, loaderData, 0, 0);
continue;
}
/* now find out which partition has the stage2 image */
checked_asprintf(&buf, _("What partition and directory on that "
"partition holds the installation image "
"for %s? If you don't see the disk drive "
"you're using listed here, press F2 to "
"configure additional devices."),
getProductName());
text = newtTextboxReflowed(-1, -1, buf, 62, 5, 5, 0);
free(buf);
listbox = newtListbox(-1, -1, numPartitions > 5 ? 5 : numPartitions,
NEWT_FLAG_RETURNEXIT |
(numPartitions > 5 ? NEWT_FLAG_SCROLL : 0));
for (i = 0; i < numPartitions; i++)
newtListboxAppendEntry(listbox,partition_list[i],partition_list[i]);
/* if we had ks data around use it to prime entry, then get rid of it*/
if (kspartition) {
newtListboxSetCurrentByKey(listbox, kspartition);
free(kspartition);
kspartition = NULL;
}
label = newtLabel(-1, -1, _("Directory holding image:"));
dirEntry = newtEntry(28, 11, dir, 28, (const char **) &tmpDir,
NEWT_ENTRY_SCROLL);
/* if we had ks data around use it to prime entry, then get rid of it*/
if (ksdirectory) {
newtEntrySet(dirEntry, ksdirectory, 1);
free(ksdirectory);
ksdirectory = NULL;
}
entryGrid = newtGridHStacked(NEWT_GRID_COMPONENT, label,
NEWT_GRID_COMPONENT, dirEntry,
NEWT_GRID_EMPTY);
buttons = newtButtonBar(_("OK"), &okay, _("Back"), &back, NULL);
grid = newtCreateGrid(1, 4);
newtGridSetField(grid, 0, 0, NEWT_GRID_COMPONENT, text,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 1, NEWT_GRID_COMPONENT, listbox,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 2, NEWT_GRID_SUBGRID, entryGrid,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 3, NEWT_GRID_SUBGRID, buttons,
0, 0, 0, 0, 0, NEWT_GRID_FLAG_GROWX);
newtGridWrappedWindow(grid, _("Select Partition"));
form = newtForm(NULL, NULL, 0);
newtFormAddHotKey(form, NEWT_KEY_F2);
newtFormAddHotKey(form, NEWT_KEY_F12);
newtGridAddComponentsToForm(grid, form, 1);
newtGridFree(grid, 1);
newtFormRun(form, &es);
selpart = newtListboxGetCurrent(listbox);
free(dir);
if (tmpDir && *tmpDir) {
/* Protect from form free. */
dir = strdup(tmpDir);
} else {
dir = strdup("");
}
newtFormDestroy(form);
newtPopWindow();
if (es.reason == NEWT_EXIT_COMPONENT && es.u.co == back) {
loaderData->stage2Data = NULL;
return NULL;
} else if (es.reason == NEWT_EXIT_HOTKEY && es.u.key == NEWT_KEY_F2) {
rc = loadDriverFromMedia(DEVICE_DISK, loaderData, 0, 0);
continue;
}
logMessage(INFO, "partition %s selected", selpart);
/* If the user-provided URL points at a repo instead of a stage2
* image, fix that up now.
*/
substr = strstr(dir, ".img");
if (!substr || (substr && *(substr+4) != '\0')) {
checked_asprintf(&dir, "%s/images/install.img", dir);
}
loaderData->invalidRepoParam = 1;
url = setupIsoImages(selpart, dir, location);
if (!url) {
newtWinMessage(_("Error"), _("OK"),
_("Device %s does not appear to contain "
"an installation image."), selpart, getProductName());
continue;
}
done = 1;
}
free(dir);
return url;
}
void play_wav_file(char *filename)
{
char *inwavbuf;
short *current;
short *audioend;
short *audio;
WAVE_HEADER *wav_info;
int wavfd;
int dspfd;
struct stat input_fstat;
size_t interval;
newtComponent vu_1sec;
newtComponent vu_total;
newtComponent wav_length;
newtComponent label_length;
newtComponent mainwaveform;
newtComponent label_1sec;
newtComponent label_total;
newtComponent rf_result;
char labelstr_1sec[10] = "0";
char labelstr_total[10] = "0";
char labelstr_length[10] = "";
short one_sec_max, total_max;
wavfd = open(filename,O_RDONLY,0600);
if (wavfd == -1)
{
printf("Error: open() %s\n",strerror(errno));
exit(1);
}
if (fstat(wavfd,&input_fstat) != 0)
{
printf("Error: fstat() %s\n",strerror(errno));
return;
}
if (input_fstat.st_size < sizeof(WAVE_HEADER))
{
printf("File is not large enough to hold a .wav file header even!\n");
return;
}
inwavbuf = mmap(NULL,input_fstat.st_size,PROT_READ,MAP_SHARED,wavfd,0);
if (inwavbuf == MAP_FAILED)
{
printf("Error: mmap() %s\n",strerror(errno));
exit(1);
}
audio = (short *)validate_wav_header(inwavbuf,0);
current = audio;
if (current == NULL)
{
printf("This program didn't like the wav file\n");
exit(1);
}
wav_info = (WAVE_HEADER *)inwavbuf;
audioend = (short *)((char *)audio + wav_info->nDataBytes);
dspfd = open_dsp(wav_info);
newtCls();
newtDrawRootText(0, 0, filename);
mainwaveform = newtForm(NULL, NULL, NEWT_FLAG_NOF12);
vu_1sec = newtScale(9,5,68,(long long)(SHRT_MAX));
label_1sec = newtLabel(1,5,labelstr_1sec);
wav_length = newtScale(9,3,68,audioend - audio);
label_length = newtLabel(1,3,labelstr_length);
vu_total = newtScale(9,8,68,(long long)(SHRT_MAX));
label_total = newtLabel(1,8,labelstr_total);
newtFormAddComponent(mainwaveform,vu_1sec);
newtFormAddComponent(mainwaveform,vu_total);
newtFormAddComponent(mainwaveform,label_1sec);
newtFormAddComponent(mainwaveform,label_total);
one_sec_max = 0;
total_max = 0;
newtFormWatchFd(mainwaveform,dspfd,NEWT_FD_WRITE);
newtFormAddHotKey(mainwaveform,NEWT_KEY_ENTER);
newtPushHelpLine("Hit Enter to end playing");
newtCenteredWindow(78,10,"now playing .wav file");
newtRefresh();
/* presently every second */
interval = (size_t )((double )wav_info->nSamplesPerSec * interval_s * 2);
while ((current) < audioend)
{
short *endcurrent = current + interval;
if (endcurrent > audioend)
{
endcurrent = audioend;
}
one_sec_max = get_peak_value(current,endcurrent);
newtScaleSet(vu_1sec,one_sec_max);
sprintf(labelstr_1sec,"%1.6f",((float )one_sec_max/ (float )SHRT_MAX));
newtLabelSetText(label_1sec,labelstr_1sec);
newtScaleSet(wav_length,current - audio);
sprintf(labelstr_length,"%4.2f",
((double )(current - audio) / 88200));
newtLabelSetText(label_length,labelstr_length);
if (one_sec_max > total_max)
{
total_max = one_sec_max;
sprintf(labelstr_total,"%1.6f",((float )total_max/ (float )SHRT_MAX));
newtLabelSetText(label_total,labelstr_total);
newtScaleSet(vu_total,total_max);
}
rf_result = newtRunForm(mainwaveform);
if (play_buffer(dspfd,current,endcurrent) == -1)
{
current = audioend;
}
current = endcurrent;
if (rf_result == NULL)
current = audioend;
newtRefresh();
}
newtFormDestroy(mainwaveform);
munmap(inwavbuf,input_fstat.st_size);
close(wavfd);
close(dspfd);
return;
}
