// =======================================================
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 ui__popup_menu(int argc, char * const argv[])
{
struct newtExitStruct es;
int i, rc = -1, max_len = 5;
newtComponent listbox, form = newt_form__new();
if (form == NULL)
return -1;
listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
if (listbox == NULL)
goto out_destroy_form;
newtFormAddComponent(form, listbox);
for (i = 0; i < argc; ++i) {
int len = strlen(argv[i]);
if (len > max_len)
max_len = len;
if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
goto out_destroy_form;
}
newtCenteredWindow(max_len, argc, NULL);
newtFormRun(form, &es);
rc = newtListboxGetCurrent(listbox) - NULL;
if (es.reason == NEWT_EXIT_HOTKEY)
rc = -1;
newtPopWindow();
out_destroy_form:
newtFormDestroy(form);
return rc;
}
static newtComponent
nmt_newt_listbox_build_component (NmtNewtComponent *component,
gboolean sensitive)
{
NmtNewtListboxPrivate *priv = NMT_NEWT_LISTBOX_GET_PRIVATE (component);
newtComponent co;
int i, active;
if (priv->active == -1)
update_active_internal (NMT_NEWT_LISTBOX (component), 0);
active = priv->active;
co = newtListbox (-1, -1, priv->height, convert_flags (priv->flags));
newtComponentAddCallback (co, selection_changed_callback, component);
for (i = 0; i < priv->entries->len; i++) {
newtListboxAppendEntry (co, priv->entries->pdata[i], GUINT_TO_POINTER (i));
if (active == -1 && priv->keys->pdata[i] == priv->active_key)
active = i;
}
if (active != -1)
newtListboxSetCurrent (co, active);
return co;
}
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;
}
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;
}
}
}
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;
}
/**
* Pop up a list containing the filenames in @p source_file and the severity if they have changed since the
* last backup. There can be no more than @p ARBITRARY_MAXIMUM files in @p source_file.
* @param source_file The file containing a list of changed files.
*/
void popup_changelist_from_file(char *source_file) {
char *reason = NULL;
newtComponent myForm;
newtComponent bClose;
newtComponent bSelect;
newtComponent b_res;
newtComponent fileListbox;
newtComponent headerMsg;
/*@ ???? ************************************************************ */
void *curr_choice;
void *keylist[ARBITRARY_MAXIMUM];
/*@ int ************************************************************* */
int i = 0;
int currline = 0;
int finished = FALSE;
long lng = 0;
/*@ buffers ********************************************************* */
char *tmp;
char *differ_sz;
struct s_filelist *filelist;
assert_string_is_neither_NULL_nor_zerolength(source_file);
if (g_text_mode) {
log_msg(2, "Text mode. Therefore, no popup list.");
return;
}
log_msg(2, "Examining file %s", source_file);
lng = count_lines_in_file(source_file);
if (lng < 1) {
log_msg(2, "No lines in file. Therefore, no popup list.");
return;
} else if (lng >= ARBITRARY_MAXIMUM) {
log_msg(2, "Too many files differ for me to list.");
return;
}
filelist = (struct s_filelist *) malloc(sizeof(struct s_filelist));
fileListbox =
newtListbox(2, 2, 12, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
newtListboxClear(fileListbox);
if (load_filelist_into_array(filelist, source_file)) {
log_msg(2, "Can't open %s; therefore, cannot popup list",
source_file);
return;
}
log_msg(2, "%d files loaded into filelist array",
filelist->entries);
for (i = 0; i < filelist->entries; i++) {
keylist[i] = (void *) i;
newtListboxAppendEntry(fileListbox,
filelist_entry_to_string(&
(filelist->
el[i])),
keylist[i]);
}
asprintf(&differ_sz,
_(" %d files differ. Hit 'Select' to pick a file. Hit 'Close' to quit the list."),
i);
newtPushHelpLine(differ_sz);
paranoid_free(differ_sz);
bClose = newtCompactButton(10, 15, _(" Close "));
bSelect = newtCompactButton(30, 15, _(" Select "));
asprintf(&tmp, "%-10s %-20s", _("Priority"),
_("Filename"));
headerMsg = newtLabel(2, 1, tmp);
paranoid_free(tmp);
newtOpenWindow(5, 4, 70, 16, _("Non-matching files"));
myForm = newtForm(NULL, NULL, 0);
newtFormAddComponents(myForm, headerMsg, fileListbox, bClose,
bSelect, NULL);
while (!finished) {
b_res = newtRunForm(myForm);
if (b_res == bClose) {
finished = TRUE;
} else {
curr_choice = newtListboxGetCurrent(fileListbox);
for (i = 0;
i < filelist->entries && keylist[i] != curr_choice;
i++);
if (i == filelist->entries && filelist->entries > 0) {
log_to_screen(_("I don't know what that button does!"));
} else {
currline = i;
if (filelist->entries > 0) {
severity_of_difference(filelist->el[currline].
filename, reason);
asprintf(&tmp, "%s --- %s",
filelist->el[currline].filename, reason);
popup_and_OK(tmp);
paranoid_free(tmp);
paranoid_free(reason);
}
}
}
}
newtFormDestroy(myForm);
newtPopWindow();
newtPopHelpLine();
}
/* Browse through a directory structure looking for a file.
* Returns the full path to the file.
*
* Parameters:
* title: Title for newt dialog window
* dirname: Directory to use for root of browsing. NOTE: you cannot go
* up above this root.
* filterfunc: An (optional) function to filter out files based on whatever
* criteria you want. Returns 1 if it passes, 0 if not.
* Function should take arguments of the directory name and
* the dirent for the file.
*/
char * newt_select_file(char * title, char * text, char * dirname,
int (*filterfunc)(char *, struct dirent *)) {
char ** files;
char * fn = NULL;
int i, done = 0;
char * topdir = dirname;
char * dir = malloc(PATH_MAX);
char * path = NULL;
newtGrid grid, buttons;
newtComponent f, tb, listbox, ok, cancel;
struct stat sb;
struct newtExitStruct es;
dir = realpath(dirname, dir);
do {
files = get_file_list(dir, filterfunc);
f = newtForm(NULL, NULL, 0);
grid = newtCreateGrid(1, 4);
tb = newtTextboxReflowed(-1, -1, text, 60, 0, 10, 0);
listbox = newtListbox(12, 65, 10,
NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
newtListboxSetWidth(listbox, 55);
buttons = newtButtonBar(_("OK"), &ok, _("Cancel"), &cancel, NULL);
newtGridSetField(grid, 0, 0, NEWT_GRID_COMPONENT, tb,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 1, NEWT_GRID_COMPONENT, listbox,
0, 0, 0, 1, 0, 0);
newtGridSetField(grid, 0, 3, NEWT_GRID_SUBGRID, buttons,
0, 0, 0, 0, 0, NEWT_GRID_FLAG_GROWX);
/* if this isn't our topdir, we want to let them go up a dir */
if (strcmp(topdir, dir))
newtListboxAppendEntry(listbox, "../", "..");
for (i = 0; (files[i] != NULL); i++) {
if ((files[i] == NULL) || (strlen(files[i]) == 0)) continue;
path = malloc(strlen(files[i]) + strlen(dir) + 2);
sprintf(path, "%s/%s", dir, files[i]);
stat(path, &sb);
free(path);
if (S_ISDIR(sb.st_mode)) {
char *dir = malloc(strlen(files[i]) + 2);
sprintf(dir, "%s/", files[i]);
newtListboxAppendEntry(listbox, dir, files[i]);
} else {
newtListboxAppendEntry(listbox, files[i], files[i]);
}
}
newtGridWrappedWindow(grid, title);
newtGridAddComponentsToForm(grid, f, 1);
newtFormRun(f, &es);
if (es.reason == NEWT_EXIT_COMPONENT && es.u.co == cancel) {
fn = NULL;
done = -1;
} else {
fn = (char *) newtListboxGetCurrent(listbox);
path = malloc(strlen(fn) + strlen(dir) + 2);
sprintf(path, "%s/%s", dir, fn);
stat(path, &sb);
if (!S_ISDIR(sb.st_mode)) {
fn = path;
done = 1;
} else {
dir = realpath(path, dir);
free(path);
}
}
newtGridFree(grid, 1);
newtFormDestroy(f);
newtPopWindow();
} while (done == 0);
return fn;
}
// return a malloc()ed path
char *filesel(char *dr)
{
newtComponent lb, b1, b2, b3, l1, l2, f;
const char *enr2, *enr3;
char *curv;
char curvv[PATH_MAX]; // stupid, but who cares...
int i, cnt;
fde *sel, *sela;
char cwd[PATH_MAX], cwdcd[PATH_MAX], *ret=NULL;
struct newtExitStruct es;
struct stat st;
newtCenteredWindow(65, 15, i18n("Select path"));
f = newtForm(NULL, NULL, 0);
b1 = newtCompactButton(59, 14, i18n("Ok"));
b3 = newtCompactButton(45, 14, i18n("Cancel"));
l2 = newtEntry(1, 14, "", 25, &enr3, NEWT_FLAG_SCROLL);
b2 = newtCompactButton(26, 14, i18n("Create dir"));
lb = newtListbox(1, 2, 12, /*NEWT_FLAG_MULTIPLE |*/ /*NEWT_FLAG_BORDER | */
NEWT_FLAG_RETURNEXIT |
NEWT_FLAG_SCROLL | NEWT_FLAG_SHOWCURSOR);
if(dr && strlen(dr) > 0)
{
// let it show the file or dir at any case
l1 = newtEntry(1, 0, dr, 60, &enr2, NEWT_FLAG_SCROLL | NEWT_FLAG_DISABLED);
stat(dr,&st);
if(S_ISDIR(st.st_mode))
{
dir_here(lb,dr);
strcpy(cwd,dr);
} else
{
dir_here(lb,dirname(dr));
strcpy(cwd,dirname(dr));
}
}
else
{
// if NULL, show the current dir
l1 = newtEntry(1, 0, get_current_dir_name(), 60, &enr2, NEWT_FLAG_SCROLL | NEWT_FLAG_DISABLED);
dir_here(lb,get_current_dir_name());
strcpy(cwd,get_current_dir_name());
}
newtListboxSetWidth(lb,63);
newtFormAddComponents(f, lb,l1, l2, b2, b1, b3, NULL);
newtRefresh();
newtFormSetTimer(f, 200);
do
{
newtFormRun(f, &es);
if (es.reason == es.NEWT_EXIT_COMPONENT && es.u.co == lb)
{
sel=(fde*)newtListboxGetCurrent(lb);
if (sel && S_ISDIR(sel->st.st_mode))
{
cnt=newtListboxItemCount(lb);
// delete items there:
for(i=0; i < cnt; i++)
{
newtListboxGetEntry(lb, i, &curv, (void**)&sela);
if(sela != sel)
{
free(sela->name);
free(sela);
}
else
{
strcpy(curvv, curv);
}
}
newtListboxClear(lb);
dir_here(lb,sel->name);
if(strcmp(curvv,"..") == 0) set_lb_cursor(lb,cwdcd);
strcpy(cwd,sel->name);
strcpy(cwdcd,sel->name);
newtEntrySet(l1, sel->name, 1);
if(sel)
{
free(sel->name);
free(sel);
}
}
if(sel && S_ISREG(sel->st.st_mode)) // is a directory
{
newtEntrySet(l1, sel->name, 1);
}
}
else if (es.reason == es.NEWT_EXIT_COMPONENT && es.u.co == b2)
{
if(strlen(enr3) > 0)
{
strcpy(cwdcd,cwd);
strcat(cwdcd,"/");
strcat(cwdcd,enr3);
if(mkdir(cwdcd,0755) == 0)
{
newtListboxClear(lb);
dir_here(lb,cwd);
set_lb_cursor(lb,cwdcd);
newtEntrySet(l2, "", 1);
}
}
}
else if (es.reason == es.NEWT_EXIT_COMPONENT && es.u.co == b1)
{
ret=strdup(enr2);
}
}
while (es.reason != es.NEWT_EXIT_COMPONENT || es.u.co == lb || es.u.co == b2);
newtFormDestroy(f);
newtPopWindow();
return ret;
}
// =======================================================
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;
}
/* 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;
}
int main(void) {
newtComponent b1, b2, r1, r2, r3, e2, e3, l1, l2, l3, scale;
newtComponent lb, t, rsf, answer, timeLabel;
newtComponent cs[10];
newtComponent f, chklist, e1;
struct callbackInfo cbis[3];
char results[10];
char * enr2, * enr3, * scaleVal;
void ** selectedList;
int i, numsel;
char buf[20];
const char * spinner = "-\\|/\\|/";
const char * spinState;
struct newtExitStruct es;
newtInit();
newtCls();
newtSetSuspendCallback(suspend, NULL);
newtSetHelpCallback(helpCallback);
newtDrawRootText(0, 0, "Newt test program");
newtPushHelpLine(NULL);
newtDrawRootText(-50, 0, "More root text");
newtOpenWindow(2, 2, 30, 10, "first window");
newtOpenWindow(10, 5, 65, 16, "window 2");
f = newtForm(NULL, "This is some help text", 0);
chklist = newtForm(NULL, NULL, 0);
b1 = newtButton(3, 1, "Exit");
b2 = newtButton(18, 1, "Update");
r1 = newtRadiobutton(20, 10, "Choice 1", 0, NULL);
r2 = newtRadiobutton(20, 11, "Chc 2", 1, r1);
r3 = newtRadiobutton(20, 12, "Choice 3", 0, r2);
rsf = newtForm(NULL, NULL, 0);
newtFormAddComponents(rsf, r1, r2, r3, NULL);
newtFormSetBackground(rsf, NEWT_COLORSET_CHECKBOX);
for (i = 0; i < 10; i++) {
sprintf(buf, "Check %d", i);
cs[i] = newtCheckbox(3, 10 + i, buf, ' ', NULL, &results[i]);
newtFormAddComponent(chklist, cs[i]);
}
l1 = newtLabel(3, 6, "Scale:");
l2 = newtLabel(3, 7, "Scrolls:");
l3 = newtLabel(3, 8, "Hidden:");
e1 = newtEntry(12, 6, "", 20, &scaleVal, 0);
e2 = newtEntry(12, 7, "Default", 20, &enr2, NEWT_FLAG_SCROLL);
/* e3 = newtEntry(12, 8, NULL, 20, &enr3, NEWT_FLAG_HIDDEN); */
e3 = newtEntry(12, 8, NULL, 20, &enr3, NEWT_FLAG_PASSWORD);
cbis[0].state = &results[0];
cbis[0].en = e1;
newtComponentAddCallback(cs[0], disableCallback, &cbis[0]);
scale = newtScale(3, 14, 32, 100);
newtFormSetHeight(chklist, 3);
newtFormAddComponents(f, b1, b2, l1, l2, l3, e1, e2, e3, chklist, NULL);
newtFormAddComponents(f, rsf, scale, NULL);
lb = newtListbox(45, 1, 6, NEWT_FLAG_MULTIPLE | NEWT_FLAG_BORDER |
NEWT_FLAG_SCROLL | NEWT_FLAG_SHOWCURSOR);
newtListboxAppendEntry(lb, "First", (void *) 1);
newtListboxAppendEntry(lb, "Second", (void *) 2);
newtListboxAppendEntry(lb, "Third", (void *) 3);
newtListboxAppendEntry(lb, "Fourth", (void *) 4);
newtListboxAppendEntry(lb, "Sixth", (void *) 6);
newtListboxAppendEntry(lb, "Seventh", (void *) 7);
newtListboxAppendEntry(lb, "Eighth", (void *) 8);
newtListboxAppendEntry(lb, "Ninth", (void *) 9);
newtListboxAppendEntry(lb, "Tenth", (void *) 10);
newtListboxInsertEntry(lb, "Fifth", (void *) 5, (void *) 4);
newtListboxInsertEntry(lb, "Eleventh", (void *) 11, (void *) 10);
newtListboxDeleteEntry(lb, (void *) 11);
spinState = spinner;
timeLabel = newtLabel(45, 8, "Spinner: -");
t = newtTextbox(45, 10, 17, 5, NEWT_FLAG_WRAP);
newtTextboxSetText(t, "This is some text does it look okay?\nThis should be alone.\nThis shouldn't be printed");
newtFormAddComponents(f, lb, timeLabel, t, NULL);
newtRefresh();
newtFormSetTimer(f, 200);
do {
newtFormRun(f, &es);
if (es.reason == NEWT_EXIT_COMPONENT && es.u.co == b2) {
newtScaleSet(scale, atoi(scaleVal));
newtRefresh();
answer = NULL;
} else if (es.reason == NEWT_EXIT_TIMER) {
spinState++;
if (!*spinState) spinState = spinner;
sprintf(buf, "Spinner: %c", *spinState);
newtLabelSetText(timeLabel, buf);
}
} while (es.reason != NEWT_EXIT_COMPONENT || es.u.co == b2);
scaleVal = strdup(scaleVal);
enr2 = strdup(enr2);
enr3 = strdup(enr3);
selectedList = newtListboxGetSelection(lb, &numsel);
newtFormDestroy(f);
newtPopWindow();
newtPopWindow();
newtFinished();
printf("got string 1: %s\n", scaleVal);
printf("got string 2: %s\n", enr2);
printf("got string 3: %s\n", enr3);
if(selectedList) {
printf("\nSelected listbox items:\n");
for(i = 0; i < numsel; i++)
puts(selectedList[i]);
}
return 0;
}
