mirror-games/glest-source
1
0
Fork 0
mirror of https://github.com/glest/glest-source.git synced 2025-02-24 19:52:25 +01:00
Code Issues Projects Releases Wiki Activity
glest-source/mk/linux/mojosetup/gui_ncurses.c
Mark Vejvoda b69a6fe6ce Added Linux installer to mega-glest
2010-04-25 03:01:17 +00:00

1488 lines
44 KiB
C
Raw Blame History

/**
* MojoSetup; a portable, flexible installation application.
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
#if !SUPPORT_GUI_NCURSES
#error Something is wrong in the build system.
#endif
#define BUILDING_EXTERNAL_PLUGIN 1
#include "gui.h"
MOJOGUI_PLUGIN(ncurses)
#if !GUI_STATIC_LINK_NCURSES
CREATE_MOJOGUI_ENTRY_POINT(ncurses)
#endif
#include <unistd.h>
#include <ctype.h>
// CMake searches for a whole bunch of different possible curses includes
#if defined(HAVE_NCURSESW_NCURSES_H)
#include <ncursesw/ncurses.h>
#elif defined(HAVE_NCURSESW_CURSES_H)
#include <ncursesw/curses.h>
#elif defined(HAVE_NCURSESW_H)
#include <ncursesw.h>
#else
#error ncurses gui enabled, but no known header file found
#endif
#include <locale.h>
// This was built to look roughly like dialog(1), but it's not nearly as
// robust. Also, I didn't use any of dialog's code, as it is GPL/LGPL,
// depending on what version you start with. There _is_ a libdialog, but
// it's never something installed on any systems, and I can't link it
// statically due to the license.
//
// ncurses is almost always installed as a shared library, though, so we'll
// just talk to it directly. Fortunately we don't need much of what dialog(1)
// offers, so rolling our own isn't too painful (well, compared to massive
// head trauma, I guess).
//
// Pradeep Padala's ncurses HOWTO was very helpful in teaching me curses
// quickly: http://tldp.org/HOWTO/NCURSES-Programming-HOWTO/index.html
// !!! FIXME: this should all be UTF-8 and Unicode clean with ncursesw, but
// !!! FIXME: it relies on the terminal accepting UTF-8 output (we don't
// !!! FIXME: attempt to convert) and assumes all characters fit in one
// !!! FIXME: column, which they don't necessarily for some Asian languages,
// !!! FIXME: etc. I'm not sure how to properly figure out column width, if
// !!! FIXME: it's possible at all, but for that, you should probably
// !!! FIXME: go to a proper GUI plugin like GTK+ anyhow.
typedef enum
{
MOJOCOLOR_BACKGROUND=1,
MOJOCOLOR_BORDERTOP,
MOJOCOLOR_BORDERBOTTOM,
MOJOCOLOR_BORDERTITLE,
MOJOCOLOR_TEXT,
MOJOCOLOR_TEXTENTRY,
MOJOCOLOR_BUTTONHOVER,
MOJOCOLOR_BUTTONNORMAL,
MOJOCOLOR_BUTTONBORDER,
MOJOCOLOR_TODO,
MOJOCOLOR_DONE,
} MojoColor;
typedef struct
{
WINDOW *mainwin;
WINDOW *textwin;
WINDOW **buttons;
char *title;
char *text;
char **textlines;
char **buttontext;
int buttoncount;
int textlinecount;
int hoverover;
int textpos;
boolean hidecursor;
boolean ndelay;
int cursval;
} MojoBox;
static char *lastProgressType = NULL;
static char *lastComponent = NULL;
static boolean lastCanCancel = false;
static uint32 percentTicks = 0;
static char *title = NULL;
static MojoBox *progressBox = NULL;
static void drawButton(MojoBox *mojobox, int button)
{
const boolean hover = (mojobox->hoverover == button);
int borderattr = 0;
WINDOW *win = mojobox->buttons[button];
const char *str = mojobox->buttontext[button];
int w, h;
getmaxyx(win, h, w);
if (!hover)
wbkgdset(win, COLOR_PAIR(MOJOCOLOR_BUTTONNORMAL));
else
{
borderattr = COLOR_PAIR(MOJOCOLOR_BUTTONBORDER) | A_BOLD;
wbkgdset(win, COLOR_PAIR(MOJOCOLOR_BUTTONHOVER));
} // else
werase(win);
wmove(win, 0, 0);
waddch(win, borderattr | '<');
wmove(win, 0, w-1);
waddch(win, borderattr | '>');
wmove(win, 0, 2);
if (!hover)
waddstr(win, str);
else
{
wattron(win, COLOR_PAIR(MOJOCOLOR_BUTTONHOVER) | A_BOLD);
waddstr(win, str);
wattroff(win, COLOR_PAIR(MOJOCOLOR_BUTTONHOVER) | A_BOLD);
} // else
} // drawButton
static void drawText(MojoBox *mojobox)
{
int i;
const int tcount = mojobox->textlinecount;
int pos = mojobox->textpos;
int w, h;
WINDOW *win = mojobox->textwin;
getmaxyx(win, h, w);
werase(mojobox->textwin);
for (i = 0; (pos < tcount) && (i < h); i++, pos++)
mvwaddstr(win, i, 0, mojobox->textlines[pos]);
if (tcount > h)
{
const int pct = (int) ((((double) pos) / ((double) tcount)) * 100.0);
win = mojobox->mainwin;
wattron(win, COLOR_PAIR(MOJOCOLOR_BORDERTITLE) | A_BOLD);
mvwprintw(win, h+1, w-5, "(%3d%%)", pct);
wattroff(win, COLOR_PAIR(MOJOCOLOR_BORDERTITLE) | A_BOLD);
} // if
} // drawText
static void drawBackground(WINDOW *win)
{
wclear(win);
if (title != NULL)
{
int w, h;
getmaxyx(win, h, w);
wattron(win, COLOR_PAIR(MOJOCOLOR_BACKGROUND) | A_BOLD);
mvwaddstr(win, 0, 0, title);
mvwhline(win, 1, 1, ACS_HLINE, w-2);
wattroff(win, COLOR_PAIR(MOJOCOLOR_BACKGROUND) | A_BOLD);
} // if
} // drawBackground
static void confirmTerminalSize(void)
{
int scrw = 0;
int scrh = 0;
char *msg = NULL;
int len = 0;
int x = 0;
int y = 0;
while (1) // loop until the window meets a minimum dimension requirement.
{
getmaxyx(stdscr, scrh, scrw);
scrh--; // -1 to save the title at the top of the screen...
if (scrw < 30) // too thin
msg = xstrdup(_("[Make the window wider!]"));
else if (scrh < 10) // too short
msg = xstrdup(_("[Make the window taller!]"));
else
break; // we're good, get out.
len = utf8len(msg);
y = scrh / 2;
x = ((scrw - len) / 2);
if (y < 0) y = 0;
if (x < 0) x = 0;
wclear(stdscr);
wmove(stdscr, y, x);
wrefresh(stdscr);
wmove(stdscr, y, x);
wattron(stdscr, COLOR_PAIR(MOJOCOLOR_BACKGROUND) | A_BOLD);
waddstr(stdscr, msg);
wattroff(stdscr, COLOR_PAIR(MOJOCOLOR_BACKGROUND) | A_BOLD);
nodelay(stdscr, 0);
wrefresh(stdscr);
free(msg);
while (wgetch(stdscr) != KEY_RESIZE) { /* no-op. */ }
} // while
} // confirmTerminalSize
static MojoBox *makeBox(const char *title, const char *text,
char **buttons, int bcount,
boolean ndelay, boolean hidecursor)
{
MojoBox *retval = NULL;
WINDOW *win = NULL;
int scrw, scrh;
int len = 0;
int buttonsw = 0;
int x = 0;
int y = 0;
int h = 0;
int w = 0;
int texth = 0;
int i;
confirmTerminalSize(); // blocks until window is large enough to continue.
getmaxyx(stdscr, scrh, scrw);
scrh--; // -1 to save the title at the top of the screen...
retval = (MojoBox *) xmalloc(sizeof (MojoBox));
retval->hidecursor = hidecursor;
retval->ndelay = ndelay;
retval->cursval = ((hidecursor) ? curs_set(0) : ERR);
retval->title = xstrdup(title);
retval->text = xstrdup(text);
retval->buttoncount = bcount;
retval->buttons = (WINDOW **) xmalloc(sizeof (WINDOW*) * bcount);
retval->buttontext = (char **) xmalloc(sizeof (char*) * bcount);
for (i = 0; i < bcount; i++)
retval->buttontext[i] = xstrdup(buttons[i]);
retval->textlines = splitText(retval->text, scrw-4,
&retval->textlinecount, &w);
len = utf8len(title);
if (len > scrw-4)
{
len = scrw-4;
strcpy(&retval->title[len-3], "..."); // !!! FIXME: not Unicode safe!
} // if
if (len > w)
w = len;
if (bcount > 0)
{
for (i = 0; i < bcount; i++)
buttonsw += utf8len(buttons[i]) + 5; // '<', ' ', ' ', '>', ' '
if (buttonsw > w)
w = buttonsw;
// !!! FIXME: what if these overflow the screen?
} // if
w += 4;
h = retval->textlinecount + 2;
if (bcount > 0)
h += 2;
if (h > scrh-2)
h = scrh-2;
x = (scrw - w) / 2;
y = ((scrh - h) / 2) + 1;
// can't have negative coordinates, so in case we survived the call to
// confirmTerminalSize() but still need more, just draw as much as
// possible from the top/left to fill the window.
if (x < 0) x = 0;
if (y < 0) y = 0;
win = retval->mainwin = newwin(h, w, y, x);
keypad(win, TRUE);
nodelay(win, ndelay);
wbkgdset(win, COLOR_PAIR(MOJOCOLOR_TEXT));
wclear(win);
waddch(win, ACS_ULCORNER | A_BOLD | COLOR_PAIR(MOJOCOLOR_BORDERTOP));
whline(win, ACS_HLINE | A_BOLD | COLOR_PAIR(MOJOCOLOR_BORDERTOP), w-2);
wmove(win, 0, w-1);
waddch(win, ACS_URCORNER | COLOR_PAIR(MOJOCOLOR_BORDERBOTTOM));
wmove(win, 1, 0);
wvline(win, ACS_VLINE | A_BOLD | COLOR_PAIR(MOJOCOLOR_BORDERTOP), h-2);
wmove(win, 1, w-1);
wvline(win, ACS_VLINE | COLOR_PAIR(MOJOCOLOR_BORDERBOTTOM), h-2);
wmove(win, h-1, 0);
waddch(win, ACS_LLCORNER | A_BOLD | COLOR_PAIR(MOJOCOLOR_BORDERTOP));
whline(win, ACS_HLINE | COLOR_PAIR(MOJOCOLOR_BORDERBOTTOM), w-2);
wmove(win, h-1, w-1);
waddch(win, ACS_LRCORNER | COLOR_PAIR(MOJOCOLOR_BORDERBOTTOM));
len = utf8len(retval->title);
wmove(win, 0, ((w-len)/2)-1);
wattron(win, COLOR_PAIR(MOJOCOLOR_BORDERTITLE) | A_BOLD);
waddch(win, ' ');
waddstr(win, retval->title);
wmove(win, 0, ((w-len)/2)+len);
waddch(win, ' ');
wattroff(win, COLOR_PAIR(MOJOCOLOR_BORDERTITLE) | A_BOLD);
if (bcount > 0)
{
const int buttony = (y + h) - 2;
int buttonx = (x + w) - ((w - buttonsw) / 2);
wmove(win, h-3, 1);
whline(win, ACS_HLINE | A_BOLD | COLOR_PAIR(MOJOCOLOR_BORDERTOP), w-2);
for (i = 0; i < bcount; i++)
{
len = utf8len(buttons[i]) + 4;
buttonx -= len+1;
win = retval->buttons[i] = newwin(1, len, buttony, buttonx);
keypad(win, TRUE);
nodelay(win, ndelay);
} // for
} // if
texth = h-2;
if (bcount > 0)
texth -= 2;
win = retval->textwin = newwin(texth, w-4, y+1, x+2);
keypad(win, TRUE);
nodelay(win, ndelay);
wbkgdset(win, COLOR_PAIR(MOJOCOLOR_TEXT));
drawText(retval);
drawBackground(stdscr);
wnoutrefresh(stdscr);
wnoutrefresh(retval->mainwin);
wnoutrefresh(retval->textwin);
for (i = 0; i < bcount; i++)
{
drawButton(retval, i);
wnoutrefresh(retval->buttons[i]);
} // for
doupdate(); // push it all to the screen.
return retval;
} // makeBox
static void freeBox(MojoBox *mojobox, boolean clearscreen)
{
if (mojobox != NULL)
{
int i;
const int bcount = mojobox->buttoncount;
const int tcount = mojobox->textlinecount;
if (mojobox->cursval != ERR)
curs_set(mojobox->cursval);
for (i = 0; i < bcount; i++)
{
free(mojobox->buttontext[i]);
delwin(mojobox->buttons[i]);
} // for
free(mojobox->buttontext);
free(mojobox->buttons);
delwin(mojobox->textwin);
delwin(mojobox->mainwin);
free(mojobox->title);
free(mojobox->text);
for (i = 0; i < tcount; i++)
free(mojobox->textlines[i]);
free(mojobox->textlines);
free(mojobox);
if (clearscreen)
{
wclear(stdscr);
wrefresh(stdscr);
} // if
} // if
} // freeBox
static int upkeepBox(MojoBox **_mojobox, int ch)
{
static boolean justResized = false;
MEVENT mevt;
int i;
int w, h;
MojoBox *mojobox = *_mojobox;
if (mojobox == NULL)
return -2;
if (justResized) // !!! FIXME: this is a kludge.
{
justResized = false;
if (ch == ERR)
return -1;
} // if
switch (ch)
{
case ERR:
return -2;
case '\r':
case '\n':
case KEY_ENTER:
case ' ':
return (mojobox->buttoncount <= 0) ? -1 : mojobox->hoverover;
case '\e':
return mojobox->buttoncount-1;
case KEY_UP:
if (mojobox->textpos > 0)
{
mojobox->textpos--;
drawText(mojobox);
wrefresh(mojobox->textwin);
} // if
return -1;
case KEY_DOWN:
getmaxyx(mojobox->textwin, h, w);
if (mojobox->textpos < (mojobox->textlinecount-h))
{
mojobox->textpos++;
drawText(mojobox);
wrefresh(mojobox->textwin);
} // if
return -1;
case KEY_PPAGE:
if (mojobox->textpos > 0)
{
getmaxyx(mojobox->textwin, h, w);
mojobox->textpos -= h;
if (mojobox->textpos < 0)
mojobox->textpos = 0;
drawText(mojobox);
wrefresh(mojobox->textwin);
} // if
return -1;
case KEY_NPAGE:
getmaxyx(mojobox->textwin, h, w);
if (mojobox->textpos < (mojobox->textlinecount-h))
{
mojobox->textpos += h;
if (mojobox->textpos > (mojobox->textlinecount-h))
mojobox->textpos = (mojobox->textlinecount-h);
drawText(mojobox);
wrefresh(mojobox->textwin);
} // if
return -1;
case KEY_LEFT:
if (mojobox->buttoncount > 1)
{
if (mojobox->hoverover < (mojobox->buttoncount-1))
{
mojobox->hoverover++;
drawButton(mojobox, mojobox->hoverover-1);
drawButton(mojobox, mojobox->hoverover);
wrefresh(mojobox->buttons[mojobox->hoverover-1]);
wrefresh(mojobox->buttons[mojobox->hoverover]);
} // if
} // if
return -1;
case KEY_RIGHT:
if (mojobox->buttoncount > 1)
{
if (mojobox->hoverover > 0)
{
mojobox->hoverover--;
drawButton(mojobox, mojobox->hoverover+1);
drawButton(mojobox, mojobox->hoverover);
wrefresh(mojobox->buttons[mojobox->hoverover+1]);
wrefresh(mojobox->buttons[mojobox->hoverover]);
} // if
} // if
return -1;
case 12: // ctrl-L...redraw everything on the screen.
redrawwin(stdscr);
wnoutrefresh(stdscr);
redrawwin(mojobox->mainwin);
wnoutrefresh(mojobox->mainwin);
redrawwin(mojobox->textwin);
wnoutrefresh(mojobox->textwin);
for (i = 0; i < mojobox->buttoncount; i++)
{
redrawwin(mojobox->buttons[i]);
wnoutrefresh(mojobox->buttons[i]);
} // for
doupdate(); // push it all to the screen.
return -1;
case KEY_RESIZE:
mojobox = makeBox(mojobox->title, mojobox->text,
mojobox->buttontext, mojobox->buttoncount,
mojobox->ndelay, mojobox->hidecursor);
mojobox->cursval = (*_mojobox)->cursval; // keep this sane.
mojobox->hoverover = (*_mojobox)->hoverover;
freeBox(*_mojobox, false);
if (mojobox->hidecursor)
curs_set(0); // make sure this stays sane.
*_mojobox = mojobox;
justResized = true; // !!! FIXME: kludge.
return -1;
case KEY_MOUSE:
if ((getmouse(&mevt) == OK) && (mevt.bstate & BUTTON1_CLICKED))
{
int i;
for (i = 0; i < mojobox->buttoncount; i++)
{
int x1, y1, x2, y2;
getbegyx(mojobox->buttons[i], y1, x1);
getmaxyx(mojobox->buttons[i], y2, x2);
x2 += x1;
y2 += y1;
if ( (mevt.x >= x1) && (mevt.x < x2) &&
(mevt.y >= y1) && (mevt.y < y2) )
return i;
} // for
} // if
return -1;
} // switch
return -1;
} // upkeepBox
static uint8 MojoGui_ncurses_priority(boolean istty)
{
if (!istty)
return MOJOGUI_PRIORITY_NEVER_TRY; // need a terminal for this!
else if (getenv("DISPLAY") != NULL)
return MOJOGUI_PRIORITY_TRY_LAST; // let graphical stuff go first.
return MOJOGUI_PRIORITY_TRY_NORMAL;
} // MojoGui_ncurses_priority
static boolean MojoGui_ncurses_init(void)
{
setlocale(LC_CTYPE, ""); // !!! FIXME: we assume you have a UTF-8 terminal.
if (initscr() == NULL)
{
logInfo("ncurses: initscr() failed, use another UI.");
return false;
} // if
cbreak();
keypad(stdscr, TRUE);
noecho();
start_color();
mousemask(BUTTON1_CLICKED, NULL);
init_pair(MOJOCOLOR_BACKGROUND, COLOR_CYAN, COLOR_BLUE);
init_pair(MOJOCOLOR_BORDERTOP, COLOR_WHITE, COLOR_WHITE);
init_pair(MOJOCOLOR_BORDERBOTTOM, COLOR_BLACK, COLOR_WHITE);
init_pair(MOJOCOLOR_BORDERTITLE, COLOR_YELLOW, COLOR_WHITE);
init_pair(MOJOCOLOR_TEXT, COLOR_BLACK, COLOR_WHITE);
init_pair(MOJOCOLOR_TEXTENTRY, COLOR_WHITE, COLOR_BLUE);
init_pair(MOJOCOLOR_BUTTONHOVER, COLOR_YELLOW, COLOR_BLUE);
init_pair(MOJOCOLOR_BUTTONNORMAL, COLOR_BLACK, COLOR_WHITE);
init_pair(MOJOCOLOR_BUTTONBORDER, COLOR_WHITE, COLOR_BLUE);
init_pair(MOJOCOLOR_DONE, COLOR_YELLOW, COLOR_RED);
init_pair(MOJOCOLOR_TODO, COLOR_CYAN, COLOR_BLUE);
wbkgdset(stdscr, COLOR_PAIR(MOJOCOLOR_BACKGROUND));
wclear(stdscr);
wrefresh(stdscr);
percentTicks = 0;
return true; // always succeeds.
} // MojoGui_ncurses_init
static void MojoGui_ncurses_deinit(void)
{
freeBox(progressBox, false);
progressBox = NULL;
endwin();
delwin(stdscr); // not sure if this is safe, but valgrind said it leaks.
stdscr = NULL;
free(title);
title = NULL;
free(lastComponent);
lastComponent = NULL;
free(lastProgressType);
lastProgressType = NULL;
} // MojoGui_ncurses_deinit
static void MojoGui_ncurses_msgbox(const char *title, const char *text)
{
char *localized_ok = xstrdup(_("OK"));
MojoBox *mojobox = makeBox(title, text, &localized_ok, 1, false, true);
while (upkeepBox(&mojobox, wgetch(mojobox->mainwin)) == -1) {}
freeBox(mojobox, true);
free(localized_ok);
} // MojoGui_ncurses_msgbox
static boolean MojoGui_ncurses_promptyn(const char *title, const char *text,
boolean defval)
{
char *localized_yes = xstrdup(_("Yes"));
char *localized_no = xstrdup(_("No"));
char *buttons[] = { localized_yes, localized_no };
MojoBox *mojobox = makeBox(title, text, buttons, 2, false, true);
int rc = 0;
// set the default to "no" instead of "yes"?
if (defval == false)
{
mojobox->hoverover = 1;
drawButton(mojobox, 0);
drawButton(mojobox, 1);
wrefresh(mojobox->buttons[0]);
wrefresh(mojobox->buttons[1]);
} // if
while ((rc = upkeepBox(&mojobox, wgetch(mojobox->mainwin))) == -1) {}
freeBox(mojobox, true);
free(localized_yes);
free(localized_no);
return (rc == 0);
} // MojoGui_ncurses_promptyn
static MojoGuiYNAN MojoGui_ncurses_promptynan(const char *title,
const char *text,
boolean defval)
{
char *loc_yes = xstrdup(_("Yes"));
char *loc_no = xstrdup(_("No"));
char *loc_always = xstrdup(_("Always"));
char *loc_never = xstrdup(_("Never"));
char *buttons[] = { loc_yes, loc_always, loc_never, loc_no };
MojoBox *mojobox = makeBox(title, text, buttons, 4, false, true);
int rc = 0;
// set the default to "no" instead of "yes"?
if (defval == false)
{
mojobox->hoverover = 3;
drawButton(mojobox, 0);
drawButton(mojobox, 3);
wrefresh(mojobox->buttons[0]);
wrefresh(mojobox->buttons[3]);
} // if
while ((rc = upkeepBox(&mojobox, wgetch(mojobox->mainwin))) == -1) {}
freeBox(mojobox, true);
free(loc_yes);
free(loc_no);
free(loc_always);
free(loc_never);
switch (rc)
{
case 0: return MOJOGUI_YES;
case 1: return MOJOGUI_ALWAYS;
case 2: return MOJOGUI_NEVER;
case 3: return MOJOGUI_NO;
} // switch
assert(false && "BUG: unhandled case in switch statement!");
return MOJOGUI_NO;
} // MojoGui_ncurses_promptynan
static boolean MojoGui_ncurses_start(const char *_title,
const MojoGuiSplash *splash)
{
free(title);
title = xstrdup(_title);
drawBackground(stdscr);
wrefresh(stdscr);
return true;
} // MojoGui_ncurses_start
static void MojoGui_ncurses_stop(void)
{
free(title);
title = NULL;
drawBackground(stdscr);
wrefresh(stdscr);
} // MojoGui_ncurses_stop
static int MojoGui_ncurses_readme(const char *name, const uint8 *data,
size_t datalen, boolean can_back,
boolean can_fwd)
{
MojoBox *mojobox = NULL;
char *buttons[3] = { NULL, NULL, NULL };
int bcount = 0;
int backbutton = -99;
int fwdbutton = -99;
int rc = 0;
int i = 0;
if (can_fwd)
{
fwdbutton = bcount++;
buttons[fwdbutton] = xstrdup(_("Next"));
} // if
if (can_back)
{
backbutton = bcount++;
buttons[backbutton] = xstrdup(_("Back"));
} // if
buttons[bcount++] = xstrdup(_("Cancel"));
mojobox = makeBox(name, (char *) data, buttons, bcount, false, true);
while ((rc = upkeepBox(&mojobox, wgetch(mojobox->mainwin))) == -1) {}
freeBox(mojobox, true);
for (i = 0; i < bcount; i++)
free(buttons[i]);
if (rc == backbutton)
return -1;
else if (rc == fwdbutton)
return 1;
return 0; // error? Cancel?
} // MojoGui_ncurses_readme
static int toggle_option(MojoGuiSetupOptions *parent,
MojoGuiSetupOptions *opts, int *line, int target)
{
int rc = -1;
if ((opts != NULL) && (target > *line))
{
const char *desc = opts->description;
boolean blanked = false;
blanked = ( (opts->is_group_parent) && ((!desc) || (!(*desc))) );
if ((!blanked) && (++(*line) == target))
{
const boolean toggled = ((opts->value) ? false : true);
if (opts->is_group_parent)
return 0;
// "radio buttons" in a group?
if ((parent) && (parent->is_group_parent))
{
if (toggled) // drop unless we weren't the current toggle.
{
// set all siblings to false...
MojoGuiSetupOptions *i = parent->child;
while (i != NULL)
{
i->value = false;
i = i->next_sibling;
} // while
opts->value = true; // reset us to be true.
} // if
} // if
else // individual "check box" was chosen.
{
opts->value = toggled;
} // else
return 1; // we found it, bail.
} // if
if (opts->value) // if option is toggled on, descend to children.
rc = toggle_option(opts, opts->child, line, target);
if (rc == -1)
rc = toggle_option(parent, opts->next_sibling, line, target);
} // if
return rc;
} // toggle_option
// This code is pretty scary.
static void build_options(MojoGuiSetupOptions *opts, int *line, int level,
int maxw, char **lines)
{
if (opts != NULL)
{
const char *desc = opts->description;
char *spacebuf = (char *) xmalloc(maxw + 1);
char *buf = (char *) xmalloc(maxw + 1);
int len = 0;
int spacing = level * 2;
if ((desc != NULL) && (*desc == '\0'))
desc = NULL;
if (spacing > (maxw-5))
spacing = 0; // oh well.
if (spacing > 0)
memset(spacebuf, ' ', spacing); // null-term'd by xmalloc().
if (opts->is_group_parent)
{
if (desc != NULL)
len = snprintf(buf, maxw-2, "%s%s", spacebuf, desc);
} // if
else
{
(*line)++;
len = snprintf(buf, maxw-2, "%s[%c] %s", spacebuf,
opts->value ? 'X' : ' ', desc);
} // else
free(spacebuf);
if (len >= maxw-1)
strcpy(buf+(maxw-4), "..."); // !!! FIXME: Unicode issues!
if (len > 0)
{
const size_t newlen = strlen(*lines) + strlen(buf) + 2;
*lines = (char*) xrealloc(*lines, newlen);
strcat(*lines, buf);
strcat(*lines, "\n"); // I'm sorry, Joel Spolsky!
} // if
if ((opts->value) || (opts->is_group_parent))
{
int newlev = level + 1;
if ((opts->is_group_parent) && (desc == NULL))
newlev--;
build_options(opts->child, line, newlev, maxw, lines);
} // if
build_options(opts->next_sibling, line, level, maxw, lines);
} // if
} // build_options
static int optionBox(const char *title, MojoGuiSetupOptions *opts,
boolean can_back, boolean can_fwd)
{
MojoBox *mojobox = NULL;
char *buttons[4] = { NULL, NULL, NULL, NULL };
boolean ignoreerr = false;
int lasthoverover = 0;
int lasttextpos = 0;
int bcount = 0;
int backbutton = -99;
int fwdbutton = -99;
int togglebutton = -99;
int cancelbutton = -99;
int selected = 0;
int ch = 0;
int rc = -1;
int i = 0;
if (can_fwd)
{
fwdbutton = bcount++;
buttons[fwdbutton] = xstrdup(_("Next"));
} // if
if (can_back)
{
backbutton = bcount++;
buttons[backbutton] = xstrdup(_("Back"));
} // if
lasthoverover = togglebutton = bcount++;
buttons[togglebutton] = xstrdup(_("Toggle"));
cancelbutton = bcount++;
buttons[cancelbutton] = xstrdup(_("Cancel"));
do
{
if (mojobox == NULL)
{
int y = 0;
int line = 0;
int maxw, maxh;
getmaxyx(stdscr, maxh, maxw);
char *text = xstrdup("");
build_options(opts, &line, 0, maxw-6, &text);
mojobox = makeBox(title, text, buttons, bcount, false, true);
free(text);
getmaxyx(mojobox->textwin, maxh, maxw);
if (lasthoverover != mojobox->hoverover)
{
const int orighover = mojobox->hoverover;
mojobox->hoverover = lasthoverover;
drawButton(mojobox, orighover);
drawButton(mojobox, lasthoverover);
wrefresh(mojobox->buttons[orighover]);
wrefresh(mojobox->buttons[lasthoverover]);
} // if
if (lasttextpos != mojobox->textpos)
{
mojobox->textpos = lasttextpos;
drawText(mojobox);
} // if
if (selected >= (mojobox->textlinecount - 1))
selected = mojobox->textlinecount - 1;
if (selected >= mojobox->textpos+maxh)
selected = (mojobox->textpos+maxh) - 1;
y = selected - lasttextpos;
wattron(mojobox->textwin, COLOR_PAIR(MOJOCOLOR_BUTTONHOVER) | A_BOLD);
mvwhline(mojobox->textwin, y, 0, ' ', maxw);
mvwaddstr(mojobox->textwin, y, 0, mojobox->textlines[selected]);
wattroff(mojobox->textwin, COLOR_PAIR(MOJOCOLOR_BUTTONHOVER) | A_BOLD);
wrefresh(mojobox->textwin);
} // if
lasttextpos = mojobox->textpos;
lasthoverover = mojobox->hoverover;
ch = wgetch(mojobox->mainwin);
if (ignoreerr) // kludge.
{
ignoreerr = false;
if (ch == ERR)
continue;
} // if
if (ch == KEY_RESIZE)
{
freeBox(mojobox, false); // catch and rebuild without upkeepBox,
mojobox = NULL; // so we can rebuild the text ourself.
ignoreerr = true; // kludge.
} // if
else if (ch == KEY_UP)
{
if (selected > 0)
{
WINDOW *win = mojobox->textwin;
int maxw, maxh;
int y = --selected - mojobox->textpos;
getmaxyx(win, maxh, maxw);
if (selected < mojobox->textpos)
{
upkeepBox(&mojobox, ch); // upkeepBox does scrolling
y++;
} // if
else
{
wattron(win, COLOR_PAIR(MOJOCOLOR_TEXT));
mvwhline(win, y+1, 0, ' ', maxw);
mvwaddstr(win, y+1, 0, mojobox->textlines[selected+1]);
wattroff(win, COLOR_PAIR(MOJOCOLOR_TEXT));
} // else
wattron(win, COLOR_PAIR(MOJOCOLOR_BUTTONHOVER) | A_BOLD);
mvwhline(win, y, 0, ' ', maxw);
mvwaddstr(win, y, 0, mojobox->textlines[selected]);
wattroff(win, COLOR_PAIR(MOJOCOLOR_BUTTONHOVER) | A_BOLD);
wrefresh(win);
} // if
} // else if
else if (ch == KEY_DOWN)
{
if (selected < (mojobox->textlinecount-1))
{
WINDOW *win = mojobox->textwin;
int maxw, maxh;
int y = ++selected - mojobox->textpos;
getmaxyx(win, maxh, maxw);
if (selected >= mojobox->textpos+maxh)
{
upkeepBox(&mojobox, ch); // upkeepBox does scrolling
y--;
} // if
else
{
wattron(win, COLOR_PAIR(MOJOCOLOR_TEXT));
mvwhline(win, y-1, 0, ' ', maxw);
mvwaddstr(win, y-1, 0, mojobox->textlines[selected-1]);
wattroff(win, COLOR_PAIR(MOJOCOLOR_TEXT));
} // else
wattron(win, COLOR_PAIR(MOJOCOLOR_BUTTONHOVER) | A_BOLD);
mvwhline(win, y, 0, ' ', maxw);
mvwaddstr(win, y, 0, mojobox->textlines[selected]);
wattroff(win, COLOR_PAIR(MOJOCOLOR_BUTTONHOVER) | A_BOLD);
wrefresh(win);
} // if
} // else if
else if ((ch == KEY_NPAGE) || (ch == KEY_NPAGE))
{
// !!! FIXME: maybe handle this when I'm not so lazy.
// !!! FIXME: For now, this if statement is to block
// !!! FIXME: upkeepBox() from scrolling and screwing up state.
} // else if
else // let upkeepBox handle other input (button selection, etc).
{
rc = upkeepBox(&mojobox, ch);
if (rc == togglebutton)
{
int line = 0;
rc = -1; // reset so we don't stop processing input.
if (toggle_option(NULL, opts, &line, selected+1) == 1)
{
freeBox(mojobox, false); // rebuild to reflect new options...
mojobox = NULL;
} // if
} // if
} // else
} while (rc == -1);
freeBox(mojobox, true);
for (i = 0; i < bcount; i++)
free(buttons[i]);
if (rc == backbutton)
return -1;
else if (rc == fwdbutton)
return 1;
return 0; // error? Cancel?
} // optionBox
static int MojoGui_ncurses_options(MojoGuiSetupOptions *opts,
boolean can_back, boolean can_fwd)
{
char *title = xstrdup(_("Options"));
int rc = optionBox(title, opts, can_back, can_fwd);
free(title);
return rc;
} // MojoGui_ncurses_options
static char *inputBox(const char *prompt, int *command, boolean can_back,
const char *defval)
{
char *text = NULL;
int w, h;
int i;
int ch;
int rc = -1;
MojoBox *mojobox = NULL;
size_t retvalalloc = 64;
size_t retvallen = 0;
char *retval = NULL;
char *buttons[3] = { NULL, NULL, NULL };
int drawpos = 0;
int drawlen = 0;
int bcount = 0;
int backbutton = -1;
int cancelbutton = -1;
if (defval == NULL)
retval = (char *) xmalloc(retvalalloc);
else
{
const size_t defvallen = strlen(defval);
if ((defvallen * 2) > retvalalloc)
retvalalloc = defvallen * 2;
retval = (char *) xmalloc(retvalalloc);
retvallen = defvallen;
strcpy(retval, defval);
} // else
buttons[bcount++] = xstrdup(_("OK"));
if (can_back)
{
backbutton = bcount++;
buttons[backbutton] = xstrdup(_("Back"));
} // if
cancelbutton = bcount++;
buttons[cancelbutton] = xstrdup(_("Cancel"));
getmaxyx(stdscr, h, w);
w -= 10;
text = (char *) xmalloc(w+4);
text[0] = '\n';
memset(text+1, ' ', w);
text[w+1] = '\n';
text[w+2] = ' ';
text[w+3] = '\0';
mojobox = makeBox(prompt, text, buttons, bcount, false, false);
free(text);
text = NULL;
do
{
getmaxyx(mojobox->textwin, h, w);
w -= 2;
if (drawpos >= retvallen)
drawpos = 0;
while ((drawlen = (retvallen - drawpos)) >= w)
drawpos += 5;
wattron(mojobox->textwin, COLOR_PAIR(MOJOCOLOR_TEXTENTRY) | A_BOLD);
mvwhline(mojobox->textwin, 1, 1, ' ', w); // blank line...
mvwaddstr(mojobox->textwin, 1, 1, retval + drawpos);
wattroff(mojobox->textwin, COLOR_PAIR(MOJOCOLOR_TEXTENTRY) | A_BOLD);
wrefresh(mojobox->textwin);
ch = wgetch(mojobox->mainwin);
if ( (ch > 0) && (ch < KEY_MIN) && (isprint(ch)) ) // regular key.
{
if (retvalalloc <= retvallen)
{
retvalalloc *= 2;
retval = xrealloc(retval, retvalalloc);
} // if
retval[retvallen++] = (char) ch;
retval[retvallen] = '\0';
} // if
else if (ch == KEY_BACKSPACE)
{
if (retvallen > 0)
retval[--retvallen] = '\0';
} // else if
else if (ch == KEY_RESIZE)
{
wrefresh(stdscr);
getmaxyx(stdscr, h, w);
w -= 10;
text = (char *) xrealloc(mojobox->text, w+4);
text[0] = '\n';
memset(text+1, ' ', w);
text[w+1] = '\n';
text[w+2] = ' ';
text[w+3] = '\0';
mojobox->text = text;
text = NULL;
upkeepBox(&mojobox, KEY_RESIZE); // let real resize happen...
} // else if
else
{
rc = upkeepBox(&mojobox, ch);
} // else
} while (rc == -1);
freeBox(mojobox, true);
for (i = 0; i < bcount; i++)
free(buttons[i]);
if (rc == backbutton)
*command = -1;
else if (rc == cancelbutton)
*command = 0;
else
*command = 1;
if (*command <= 0)
{
free(retval);
retval = NULL;
} // if
return retval;
} // inputBox
static char *MojoGui_ncurses_destination(const char **recommends, int recnum,
int *command, boolean can_back,
boolean can_fwd)
{
char *retval = NULL;
while (true)
{
const char *localized = NULL;
char *title = NULL;
char *choosetxt = NULL;
int rc = 0;
if (recnum > 0) // recommendations available.
{
int chosen = -1;
MojoGuiSetupOptions opts;
MojoGuiSetupOptions *prev = &opts;
MojoGuiSetupOptions *next = NULL;
MojoGuiSetupOptions *opt = NULL;
memset(&opts, '\0', sizeof (MojoGuiSetupOptions));
int i;
for (i = 0; i < recnum; i++)
{
opt = (MojoGuiSetupOptions *) xmalloc(sizeof (*opt));
opt->description = recommends[i];
opt->size = -1;
prev->next_sibling = opt;
prev = opt;
} // for
choosetxt = xstrdup(_("(I want to specify a path.)"));
opt = (MojoGuiSetupOptions *) xmalloc(sizeof (*opt));
opt->description = choosetxt;
opt->size = -1;
prev->next_sibling = opt;
prev = opt;
opts.child = opts.next_sibling; // fix this field.
opts.next_sibling = NULL;
opts.value = opts.child->value = true; // make first default.
opts.is_group_parent = true;
opts.size = -1;
title = xstrdup(_("Destination"));
rc = optionBox(title, &opts, can_back, can_fwd);
free(title);
for (i = 0, next = opts.child; next != NULL; i++)
{
if (next->value)
chosen = i;
prev = next;
next = prev->next_sibling;
free(prev);
} // for
free(choosetxt);
*command = rc;
if (rc <= 0) // back or cancel.
return NULL;
else if ((chosen >= 0) && (chosen < recnum)) // a specific entry
return xstrdup(recommends[chosen]);
} // if
// either no recommendations or user wants to enter own path...
localized = _("Enter path where files will be installed.");
title = xstrdup(localized);
retval = inputBox(title, &rc, (can_back) || (recnum > 0), NULL);
free(title);
// user cancelled or entered text, or hit back and we aren't falling
// back to the option list...return.
if ( (rc >= 0) || ((rc == -1) && (recnum == 0)) )
{
*command = rc;
return retval;
} // if
// falling back to the option list again...loop.
} // while
// Shouldn't ever hit this, but just in case...
*command = 0;
return NULL;
} // MojoGui_ncurses_destination
static int MojoGui_ncurses_productkey(const char *desc, const char *fmt,
char *buf, const int buflen,
boolean can_back, boolean can_fwd)
{
// !!! FIXME: need text option for (desc).
// !!! FIXME: need max text entry of (buflen)
// !!! FIXME: need to disable "next" button if code is invalid.
char *prompt = xstrdup(_("Please enter your product key"));
boolean getout = false;
int retval = 0;
while (!getout)
{
char *text = inputBox(prompt, &retval, can_back, buf);
if (retval != 1)
getout = true;
else
{
snprintf(buf, buflen, "%s", text);
if (isValidProductKey(fmt, text))
getout = true;
else
{
// !!! FIXME: just improve inputBox.
// We can't check the input character-by-character, so reuse
// the failed-verification localized string.
char *failtitle = xstrdup(_("Invalid product key"));
char *failstr = xstrdup(_("That key appears to be invalid. Please try again."));
MojoGui_ncurses_msgbox(failtitle, failstr);
free(failstr);
free(failtitle);
} // else
} // else
free(text);
} // while
free(prompt);
return retval;
} // MojoGui_ncurses_productkey
static boolean MojoGui_ncurses_insertmedia(const char *medianame)
{
char *fmt = xstrdup(_("Please insert '%0'"));
char *text = format(fmt, medianame);
char *localized_ok = xstrdup(_("OK"));
char *localized_cancel = xstrdup(_("Cancel"));
char *buttons[] = { localized_ok, localized_cancel };
MojoBox *mojobox = NULL;
int rc = 0;
mojobox = makeBox(_("Media change"), text, buttons, 2, false, true);
while ((rc = upkeepBox(&mojobox, wgetch(mojobox->mainwin))) == -1) {}
freeBox(mojobox, true);
free(localized_cancel);
free(localized_ok);
free(text);
free(fmt);
return (rc == 0);
} // MojoGui_ncurses_insertmedia
static void MojoGui_ncurses_progressitem(void)
{
// no-op in this UI target.
} // MojoGui_ncurses_progressitem
static boolean MojoGui_ncurses_progress(const char *type, const char *component,
int percent, const char *item,
boolean can_cancel)
{
const uint32 now = ticks();
boolean rebuild = (progressBox == NULL);
int ch = 0;
int rc = -1;
if ( (lastComponent == NULL) ||
(strcmp(lastComponent, component) != 0) ||
(lastProgressType == NULL) ||
(strcmp(lastProgressType, type) != 0) ||
(lastCanCancel != can_cancel) )
{
free(lastProgressType);
free(lastComponent);
lastProgressType = xstrdup(type);
lastComponent = xstrdup(component);
lastCanCancel = can_cancel;
rebuild = true;
} // if
if (rebuild)
{
int w, h;
char *text = NULL;
char *localized_cancel = (can_cancel) ? xstrdup(_("Cancel")) : NULL;
char *buttons[] = { localized_cancel };
const int buttoncount = (can_cancel) ? 1 : 0;
char *spacebuf = NULL;
getmaxyx(stdscr, h, w);
w -= 10;
text = (char *) xmalloc((w * 3) + 16);
if (snprintf(text, w, "%s", component) > (w-4))
strcpy((text+w)-4, "..."); // !!! FIXME: Unicode problem.
strcat(text, "\n\n");
spacebuf = (char *) xmalloc(w+1);
memset(spacebuf, ' ', w); // xmalloc provides null termination.
strcat(text, spacebuf);
free(spacebuf);
strcat(text, "\n\n ");
freeBox(progressBox, false);
progressBox = makeBox(type, text, buttons, buttoncount, true, true);
free(text);
free(localized_cancel);
} // if
// limit update spam... will only write every one second, tops.
if ((rebuild) || (percentTicks <= now))
{
static boolean unknownToggle = false;
char *buf = NULL;
WINDOW *win = progressBox->textwin;
int w, h;
getmaxyx(win, h, w);
w -= 2;
buf = (char *) xmalloc(w+1);
if (percent < 0)
{
const boolean origToggle = unknownToggle;
int i;
wmove(win, h-3, 1);
for (i = 0; i < w; i++)
{
if (unknownToggle)
waddch(win, ' ' | COLOR_PAIR(MOJOCOLOR_TODO));
else
waddch(win, ' ' | COLOR_PAIR(MOJOCOLOR_DONE));
unknownToggle = !unknownToggle;
} // for
unknownToggle = !origToggle; // animate by reversing next time.
} // if
else
{
int cells = (int) ( ((double) w) * (((double) percent) / 100.0) );
snprintf(buf, w+1, "%d%%", percent);
mvwaddstr(win, h-3, ((w+2) - utf8len(buf)) / 2, buf);
mvwchgat(win, h-3, 1, cells, A_BOLD, MOJOCOLOR_DONE, NULL);
mvwchgat(win, h-3, 1+cells, w-cells, A_BOLD, MOJOCOLOR_TODO, NULL);
} // else
wtouchln(win, h-3, 1, 1); // force reattributed cells to update.
if (snprintf(buf, w+1, "%s", item) > (w-4))
strcpy((buf+w)-4, "..."); // !!! FIXME: Unicode problem.
mvwhline(win, h-2, 1, ' ', w);
mvwaddstr(win, h-2, ((w+2) - utf8len(buf)) / 2, buf);
free(buf);
wrefresh(win);
percentTicks = now + 1000;
} // if
// !!! FIXME: check for input here for cancel button, resize, etc...
ch = wgetch(progressBox->mainwin);
if (ch == KEY_RESIZE)
{
freeBox(progressBox, false);
progressBox = NULL;
} // if
else if (ch == ERR) // can't distinguish between an error and a timeout!
{
// do nothing...
} // else if
else
{
rc = upkeepBox(&progressBox, ch);
} // else
return (rc == -1);
} // MojoGui_ncurses_progress
static void MojoGui_ncurses_final(const char *msg)
{
char *title = xstrdup(_("Finish"));
MojoGui_ncurses_msgbox(title, msg);
free(title);
} // MojoGui_ncurses_final
// end of gui_ncurses.c ...
Reference in New Issue View Git Blame Copy Permalink