path: root/ufed-curses-checklist.c

#include "ufed-curses.h"

#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>

#include "ufed-curses-help.h"

/* internal members */
static int     descriptionleft = 0;
static sFlag** faytsave        = NULL;
static size_t  maxDescWidth    = 0;
static char*   lineBuf         = NULL;
static sFlag*  flags           = NULL;

/* internal prototypes */
static int  findFlagStart(sFlag* flag, int* index, sWrap** wrap, int* line, bool* isFirstWrap);
static void free_flags(void);


/* static functions */
static char *getline(FILE *fp)
{
	static size_t size = LINE_MAX;

	if (NULL == lineBuf) {
		lineBuf = malloc(size);
		if (NULL == lineBuf)
			ERROR_EXIT(-1, "Can not allocate %lu bytes for line buffer\n", sizeof(char) * size);
	}

	if(fgets(lineBuf, size, fp) == NULL)
		return NULL;
	else {

		/* See to configuration bytes if not read already */
		if (!configDone) {
			/* Byte 1: Whether read-only-mode is set or not */
			if ( '0' != lineBuf[0] )
				ro_mode = true;

			configDone = true;

			/* Remove the leading bytes transporting configuration values */
			char *oldLine = lineBuf;
			lineBuf = malloc(size);
			if (NULL == lineBuf)
				ERROR_EXIT(-1, "Can not allocate %lu bytes for line buffer\n", sizeof(char) * size);
			memcpy(lineBuf, oldLine + 1, size - 1);
			free(oldLine);
		} /* End of having to read configuration bytes */

		char *p = strchr(lineBuf, '\n');
		if(p != NULL) {
			*p = '\0';
			return lineBuf;
		}
	}
	for(;;) {
		char *newLine = realloc(lineBuf, size + size / 2);
		if(newLine == NULL)
			ERROR_EXIT(-1, "Can not reallocate %lu bytes for line buffer\n",
				(size_t)(sizeof(char) * size * 1.5));
		lineBuf = newLine;
		newLine = NULL;
		if(fgets(lineBuf + size, size / 2, fp) == NULL)
			return NULL;
		else {
			char *p = strchr(lineBuf + size, '\n');
			if(p != NULL) {
				*p = '\0';
				return lineBuf;
			}
		}
		size += size/2;
	}
	return NULL; // never reached.
}

static void read_flags(void)
{
	FILE*  input     = fdopen(3, "r");
	int    lineNum   = 0;
	char*  line      = NULL;
	int    ndescr    = 0;
	char   endChar   = 0;
	size_t fullWidth = 0;
	struct {
		int start, end;
	} name, desc, desc_alt, pkg, state;

	if(input == NULL)
		ERROR_EXIT(-1, "fdopen failed with error %d\n", errno);
	atexit(&free_flags);

	for(line = getline(input); line ; line = getline(input)) {
		name.start  = name.end  = -1;
		state.start = state.end = -1;

		if (sscanf(line, "%n%*s%n [%n%*[ +-]%n] %d",
				&name.start,  &name.end,
				&state.start, &state.end,
				&ndescr) != 1)
			ERROR_EXIT(-1, "Flag read failed on line %d:\n\"%s\"\n", lineNum + 1, line);

		// Check stats
		if ((state.end - state.start) != 2)
			ERROR_EXIT(-1, "Illegal flag stats on line %d:\n\"%s\"\n", lineNum + 1, line);

		// Create a new flag
		line[name.end]  = '\0';
		line[state.end] = '\0';
		sFlag* newFlag = addFlag(&flags, &line[name.start], lineNum, ndescr, &line[state.start]);

		/* The minimum width of the left side display is:
		 * Space + Selection + Space + name + Space + Mask brackets/Force plus.
		 * = 1 + 3 + 1 + strlen(name) + 1 + 2
		 * = strlen(name) + 8
		 */
		if( (name.end - name.start + 8) > minwidth)
			minwidth = name.end - name.start + 8;

		/* read description(s) and determine flag status */
		for (int i = 0; i < ndescr; ++i) {
			desc.start     = desc.end     = -1;
			desc_alt.start = desc_alt.end = -1;
			pkg.start      = pkg.end      = -1;
			state.start    = state.end    = -1;

			line = getline(input);
			if (!line) break;

			if ( (sscanf(line, "\t%n%*[^\t]%n\t%n%*[^\t]%n\t (%n%*[^)]%n) [%n%*[ +-]%n%c",
					&desc.start,  &desc.end,
					&desc_alt.start,  &desc_alt.end,
					&pkg.start,   &pkg.end,
					&state.start, &state.end,
					&endChar) != 1)
			  || (']' != endChar) )
				ERROR_EXIT(-1, "Description read failed on line %d\n\"%s\"\n", lineNum + 1, line);

			// Check stats
			if ((state.end - state.start) != 7)
				ERROR_EXIT(-1, "Illegal description stats on line %d:\n\"%s\"\n", lineNum + 1, line);

			// Add description line to flag:
			line[desc.end]     = '\0';
			line[desc_alt.end] = '\0';
			line[state.end]    = '\0';
			if ( (pkg.end - pkg.start) > 1) {
				line[pkg.end]   = '\0';
				fullWidth = addFlagDesc(newFlag, &line[pkg.start], &line[desc.start],
										&line[desc_alt.start], &line[state.start]);
			} else
				fullWidth = addFlagDesc(newFlag, NULL, &line[desc.start],
										&line[desc_alt.start], &line[state.start]);

			// Note new max length if this line is longest:
			if (fullWidth > maxDescWidth)
				maxDescWidth = fullWidth;

			// Advance lineNum
			++lineNum;
		} // loop through description lines

		// Update flag states and add data to the list stats
		genFlagStats(newFlag);
		addLineStats(newFlag, &listStats);
	} // loop while input given

	fclose(input);

	if(flags == NULL)
		ERROR_EXIT(-1, "Unable to start: %s\n", "No Input!");

	// Save the last line, it is needed in several places
	bottomline = lineNum;
}

static void free_flags(void)
{
	sFlag* flag = flags->prev;

	// Clear all flags
	while (flags) {
		if (flag)
			destroyFlag(&flags, &flag);
		else
			destroyFlag(&flags, &flags);
		flag = flags ? flags->prev ? flags->prev : flags : NULL;
	}

	// Clear line buffer
	if (lineBuf)
		free(lineBuf);
}


static int drawflag(sFlag* flag, bool highlight)
{
	// Return early if there is nothing to display:
	if (!isFlagLegal(flag))
		return 0;

	// Get the starting description/wrapped line of the flag
	int    idx       = 0;    // The description index to start with
	int    line      = flag->currline;
	int    usedY     = 0;    // Counts how many lines this flag really needs to display
	sWrap* wrapPart  = NULL; // Wrap part to begin with/draw
	bool   wrapFirst = true; // The first part, pkg or desc

	if ((line < 0)
	  && (0 == (usedY = findFlagStart(flag, &idx, &wrapPart, &line, &wrapFirst))) )
		return 0;


	char   buf[wWidth(List)+1];
	char   desc[maxDescWidth];



	memset(buf, 0, sizeof(char) * (wWidth(List)+1));

	// print descriptions according to filters
	if(idx < flag->ndesc) {
		WINDOW* wLst      = win(List);
		int     lHeight   = wHeight(List);
		bool    hasHead   = false;
		size_t  pos       = descriptionleft;
		size_t  length    = wWidth(List) - (minwidth + 8);
		bool    newDesc   = true; // Set to false when advanceing wrapped descriptions
		char *p, special, *leftend;

		while ( (idx < flag->ndesc) && (line < lHeight) ) {
			// Continue if any of the filters apply:
			if (newDesc && !isDescLegal(flag, idx))
				continue;

			if (hasHead) {
				// Add spaces under the flag display
				leftend = newDesc ? buf + minwidth : buf + minwidth + 8;
				for(p = buf; p != leftend; ++p)
					*p = ' ';
			}

			// Preparations when a new description line is started
			if (newDesc) {
				// Set special character if needed:
				if (isDescForced(flag, idx))
					special = 'f';
				else if (isDescMasked(flag, idx))
					special = 'm';
				else
					special = ' ';

				// If this is the very first line, the flag data must be written
				if (!hasHead) {
					/* print the selection, name and state of the flag */
					sprintf(buf, " %c%c%c %s%s%s%-*s ",
						/* State of selection */
						flag->stateConf == ' ' ? '(' : '[',
						' ', // Filled in later
						flag->stateConf == ' ' ? ')' : ']',
						/* name */
						flag->globalForced ? "(" : flag->globalMasked ? "(-" : "",
						flag->name,
						(flag->globalForced || flag->globalMasked) ? ")" : "",
						/* distance */
						(int)(minwidth
							- (flag->globalForced ? 3 : flag->globalMasked ? 2 : 5)
							- strlen(flag->name)), " ");
				} // End of generating left side mask display

				// At this point buf is filled up to minwidth

				/* Display flag state
				 * The order in which the states are to be displayed is:
				 * 1. [D]efaults (make.defaults, IUSE, package.mask, package.force)
				 *    Note: Filled in later
				 * 2. [P]rofile package.use files
				 * 3. [C]onfiguration (make.conf, users package.use)
				 * 4. global/local
				 * 5. installed/not installed
				 */
				sprintf(buf + minwidth, "  %c%c %c%c ",
					flag->desc[idx].statePackage,
					' ' == flag->desc[idx].statePkgUse ?
						flag->stateConf : flag->desc[idx].statePkgUse,
					flag->desc[idx].isGlobal ? ' ' : 'L',
					flag->desc[idx].isInstalled ? 'i' : ' ');
			} // End of preparing a new description line

			// At this point buf is guaranteed to be filled up to minwidth + 8

			memset(desc, 0, maxDescWidth * sizeof(char));

			// Wrapped and not wrapped lines are unified here
			// to simplify the usage of different ordering and
			// stripped versus original descriptions
			if (flag->desc[idx].pkg) {
				if (e_order == eOrder_left)
					sprintf(desc, "(%s) %s", flag->desc[idx].pkg, e_desc == eDesc_ori
							? flag->desc[idx].desc
							: flag->desc[idx].desc_alt);
				else
					sprintf(desc, "%s (%s)", e_desc == eDesc_ori
							? flag->desc[idx].desc
							: flag->desc[idx].desc_alt,
							  flag->desc[idx].pkg);
			} else
				sprintf(desc, "%s", flag->desc[idx].desc);

			/* Now display the description line according to either
			 * its horizontal position or the wrapPart.
			 *
			 * With wrapped lines there are a total of three possible
			 * situations here.
			 * a) The line is not wrapped. In this case pos is simply
			 *    descriptionleft and length is number of characters that
			 *    can be displayed. (both are already set to this)
			 * b) A new wrapped description starts. In this case wrapPart
			 *    must be set, pos and length is taken from there.
			 * c) A wrapped description is displayed, pos and length are
			 *    taken from there.
			 * As a) is already set, only b) and c) must be handled.
			 */
			if (eWrap_wrap == e_wrap) {
				if (NULL == wrapPart) {
					wrapPart  = flag->desc[idx].wrap;
					wrapFirst = true;
				} else if (wrapFirst
						&& (flag->desc[idx].wrap != wrapPart)
						&& !wrapPart->pos)
					wrapFirst = false;
				pos    = wrapPart->pos;
				length = wrapPart->len;
				// If this was switched, add the first length
				if (!wrapFirst && !pos)
					pos += eOrder_left == e_order
							? strlen(flag->desc[idx].pkg)
							: eDesc_ori == e_desc
							  ? strlen(flag->desc[idx].desc)
							  : strlen(flag->desc[idx].desc_alt)
						 + 1;
				wrapPart = wrapPart->next;
			}

			// aaaaand go:
			sprintf(buf + minwidth + (newDesc ? 8 : 10), "%-*.*s", (int)length, (int)length,
				strlen(desc) > pos
					? &desc[pos]
					: "");

			/* Set correct color set according to highlighting and status*/
			if(highlight)
				wattrset(wLst, COLOR_PAIR(3) | A_BOLD | A_REVERSE);
			else
				wattrset(wLst, COLOR_PAIR(3));

			// Put the line on the screen
			mvwaddstr(wLst, line, 0, buf);
			mvwaddch(wLst, line, minwidth,     ACS_VLINE); // Before state
			mvwaddch(wLst, line, minwidth + 4, ACS_VLINE); // Between state and scope
			mvwaddch(wLst, line, minwidth + 7, ACS_VLINE); // After scope

			// Add (default) selection if this is the header line
			if (!hasHead) {
				hasHead = true;
				if (flag->globalForced) {
					if(highlight)
						wattrset(wLst, COLOR_PAIR(5) | A_REVERSE);
					else
						wattrset(wLst, COLOR_PAIR(5) | A_BOLD);
					mvwaddch(wLst, line, 2, '+');
				} else if (flag->globalMasked) {
					if(highlight)
						wattrset(wLst, COLOR_PAIR(4) | A_REVERSE);
					else
						wattrset(wLst, COLOR_PAIR(4) | A_BOLD);
					mvwaddch(wLst, line, 2, '-');
				} else if (' ' == flag->stateConf)
					mvwaddch(wLst, line, 2, flag->stateDefault);
				else
					mvwaddch(wLst, line, 2, flag->stateConf);
			}

			// Add [D]efault column content
			if ('f' == special) {
				if(highlight)
					wattrset(wLst, COLOR_PAIR(5) | A_REVERSE);
				else
					wattrset(wLst, COLOR_PAIR(5) | A_BOLD);
				mvwaddch(wLst, line, minwidth + 1, special);
			} else if ('m' == special) {
				if(highlight)
					wattrset(wLst, COLOR_PAIR(4) | A_REVERSE);
				else
					wattrset(wLst, COLOR_PAIR(4) | A_BOLD);
				mvwaddch(wLst, line, minwidth + 1, special);
			} else {
				if (' ' == flag->desc[idx].stateDefault)
					mvwaddch(wLst, line, minwidth + 1, flag->stateDefault);
				else
					mvwaddch(wLst, line, minwidth + 1, flag->desc[idx].stateDefault);
			}

			++line;
			++usedY;
			if (NULL == wrapPart)
				++idx;
		} // End of looping descriptions while there are lines left
	} else {
		memset(buf+minwidth, ' ', wWidth(List)-minwidth);
		buf[wWidth(List)] = '\0';
		waddstr(win(List), buf);
	}

	if(highlight)
		wmove(win(List), max(flag->currline, 0), 2);
	wnoutrefresh(win(List));

	return usedY;
}

static int callback(sFlag** curr, int key)
{
	WINDOW* wInp = win(Input);
	WINDOW* wLst = win(List);
	size_t  fLen = 0;

	if ( fayt[0]
	  && (key != KEY_BACKSPACE)
	  && (key != KEY_DC)
	  && (key != 0177)
	  && ( (key == ' ') || (key != (unsigned char)key) || !isprint(key)) ) {
		fayt[0] = '\0';
		drawStatus(true);
		wrefresh(wInp);
	} else
		wmove(wInp, 0, strlen(fayt));

	// Reset possible side scrolling of the current flags description first
	if(descriptionleft && (key != KEY_LEFT) && (key != KEY_RIGHT) ) {
		descriptionleft = 0;
		drawflag(*curr, TRUE);
	}

	switch(key) {
		case KEY_DC:
		case 0177:
		case KEY_BACKSPACE:
			fLen = strlen(fayt);
			if(0 == fLen)
				break;
			fayt[--fLen] = '\0';
			drawflag(*curr, FALSE);
			*curr = faytsave[fLen];
			if (!scrollcurrent())
				drawflag(*curr, TRUE);
			wattrset(wInp, COLOR_PAIR(5) | A_BOLD);
			mvwaddstr(wInp, 0, 0, fayt);
			whline(wInp, ' ', 2);
			if(fLen == 0)
				wmove(wLst, (*curr)->currline, 2);
			wnoutrefresh(wLst);
			wrefresh(wInp);
			break;
		case '\n':
		case KEY_ENTER:
			if (ro_mode) {
				if (yesno("Exit? (Y/N) "))
					return 0;
			} else if (yesno("Save and exit? (Y/N) "))
				return 0;
			break;
		case '\033':
			if (ro_mode) {
				if (yesno("Exit? (Y/N) "))
					return 0;
			} else if (yesno("Cancel? (Y/N) "))
				return 1;
			break;
		case ' ':
			// Masked flags can be turned off, nothing else
			if ( (*curr)->globalMasked || (*curr)->globalForced ) {
				if (' ' != (*curr)->stateConf)
					(*curr)->stateConf = ' ';
			} else {
				switch ((*curr)->stateConf) {
					case '+':
						(*curr)->stateConf = '-';
						break;
					case '-':
						(*curr)->stateConf = ' ';
						break;
					default:
						(*curr)->stateConf = '+';
						break;
				}
			}
			if (*curr != flags) {
				drawflag(*curr, TRUE);
				wmove(wLst, (*curr)->currline, 2);
				wrefresh(wLst);
			} else
				drawFlags();
			break;
		case KEY_LEFT:
			if(descriptionleft > 0)
				descriptionleft -= min(descriptionleft, (wWidth(List) - minwidth) * 2 / 3);
			drawflag(*curr, TRUE);
			wmove(wLst, (*curr)->currline, 2);
			wrefresh(wLst);
			break;
		case KEY_RIGHT:
			descriptionleft += (wWidth(List) - minwidth) * 2 / 3;
			drawflag(*curr, TRUE);
			wmove(wLst, (*curr)->currline, 2);
			wrefresh(wLst);
			break;

		case KEY_F(5):
			if (eScope_local  == e_scope)
				e_scope = eScope_all;
			else
				++e_scope;

			if ( !isFlagLegal(*curr)
			  && !setNextItem(0, true)
			  && !setPrevItem(0, true) )
				resetDisplay(true);
			else
				draw(true);
			break;

		case KEY_F(6):
			if (eState_notinstalled == e_state)
				e_state = eState_all;
			else
				++e_state;


			if ( !isFlagLegal(*curr)
			  && !setNextItem(0, true)
			  && !setPrevItem(0, true) )
				resetDisplay(true);
			else
				draw(true);
			break;

		case KEY_F(7):
			if      (eMask_both   == e_mask)
				e_mask = eMask_unmasked;
			else
				++e_mask;

			if ( !isFlagLegal(*curr)
			  && !setNextItem(0, true)
			  && !setPrevItem(0, true) )
				resetDisplay(true);
			else
				draw(true);

			break;

		case KEY_F(9):
			if (eOrder_left == e_order)
				e_order = eOrder_right;
			else
				e_order = eOrder_left;

			draw(true);
			break;

		case KEY_F(10):
			if (eDesc_ori == e_desc)
				e_desc = eDesc_alt;
			else
				e_desc = eDesc_ori;

			draw(true);
			break;

#ifdef NCURSES_MOUSE_VERSION
		case KEY_MOUSE:
			// Masked flags can be turned off, nothing else
			if ( (*curr)->globalMasked || (*curr)->globalForced ) {
				if (' ' != (*curr)->stateConf)
					(*curr)->stateConf = ' ';
			} else {
				switch ((*curr)->stateConf) {
					case '+':
						(*curr)->stateConf = '-';
						break;
					case '-':
						(*curr)->stateConf = ' ';
						break;
					default:
						(*curr)->stateConf = '+';
						break;
				}
			}
			if (*curr != flags) {
				drawflag(*curr, TRUE);
				wmove(wLst, (*curr)->currline, 2);
				wrefresh(wLst);
			} else {
				drawFlags();
				wmove(wInp, 0, strlen(fayt));
			}
			break;
#endif
		case '?':
			help();
			break;
		default:
			if( (key == (unsigned char) key) && isprint(key)) {
				sFlag* flag = *curr;
				fLen = strlen(fayt);
				if(fLen && strncasecmp(flag->name, fayt, fLen))
					--fLen;
				fayt[fLen]     = (char) key;
				faytsave[fLen] = *curr;
				fayt[++fLen]   = '\0';

				wmove(wInp, 0, fLen);

				/* if the current flag already matches the input string,
				 * then update the input area only.
				 */
				if(!strncasecmp(flag->name, fayt, fLen)) {
					wattrset(wInp, COLOR_PAIR(5) | A_BOLD);
					mvwaddstr(wInp, 0, 0, fayt);
					wrefresh(wInp);
				}
				/* if the current flag does not match, search one that does. */
				else {
					do flag = flag->next;
					while( (flag != *curr)
					    && ( ( strncasecmp(flag->name, fayt, fLen)
					    	|| !isFlagLegal(flag)) ) );

					/* if there was no match (or the match is filtered),
					 * update the input area to show that there is no match
					 */
					if (flag == *curr) {
						wattrset(wInp, COLOR_PAIR(4) | A_BOLD | A_REVERSE);
						mvwaddstr(wInp, 0, 0, fayt);
						wmove(wInp, 0, fLen - 1);
						wrefresh(wInp);
					} else {
						drawflag(*curr, FALSE);
						*curr = flag;
						if (!scrollcurrent())
							drawflag(*curr, TRUE);
						wattrset(wInp, COLOR_PAIR(5) | A_BOLD);
						mvwaddstr(wInp, 0, 0, fayt);
						wmove(wInp, 0, fLen);
						wrefresh(wInp);
					}
				}
			}
			break;
	}

	return -1;
}

/** @brief find the first description/wrapped part drawn on line 0.
  *
  * Determine with which description to start.
  * Overly long description lists might not fit on one screen,
  * and therefore must be scrolled instead of the flags
  * themselves.
  * If descriptions are wrapped, any description must be held
  * until wrapPart is either NULL, or a part on the screen is
  * reached.
**/
static int findFlagStart(sFlag* flag, int* index, sWrap** wrap, int* line, bool* isFirstWrap)
{
	int    usedLines  = 0;
	int    flagHeight = getFlagHeight(flag); // Will recalculate wrap parts if needed
	sWrap* wrapPart = NULL;

	if ( (*line < 0) && (-(*line) < flagHeight) ){

		while (*line < 0) {
			if (isDescLegal(flag, *index)) {
				if (eWrap_normal == e_wrap) {
					++(*line);
					++usedLines;
					++(*index);
				} else {
					/* With wrapped descriptions there are two possible
					 * situations:
					 * a) The list of wrapped lines is shorter than the
					 *    lines to be skipped to get this description on
					 *    the screen. In this case the full description
					 *    can be fast forwareded.
					 * b) The number of lines above the screen is less
					 *    than the number of wrapped parts. In this case
					 *    the first on screen part must be found.
					 */
					int wrapCount = flag->desc[*index].wrapCount;
					wrapPart      = flag->desc[*index].wrap;
					*isFirstWrap  = true;
					if (wrapPart && wrapCount && (-(*line) < wrapCount)) {
						// Situation b) This description enters screen
						while (wrapPart && (*line < 0)) {
							++(*line);
							++usedLines;
							wrapPart = wrapPart->next;
							if (wrapPart && !wrapPart->pos)
								*isFirstWrap = false;
							// Note: The wrap parts are already calculated
							//       to resemble the current order.
						}
					} else {
						// Situation a) Fast forward
						*line     += wrapCount;
						usedLines += wrapCount;
						++(*index);
					}
				} // End of handling wrapped lines
			} // End of having a legal flag
		} // end of moving to line 0

		// Write back wrapPart:
		*wrap = wrapPart;
	}

	return usedLines;
}


int main(void)
{
	int result = EXIT_SUCCESS;
	const char subtitle_ro[] = "USE flags can be browsed, but changes will NOT be saved!";
	const char subtitle_rw[] = "Select desired USE flags from the list below:";

	read_flags();
	fayt     = (char*)  calloc(minwidth, sizeof(*fayt));
	faytsave = (sFlag**)calloc(minwidth, sizeof(*faytsave));
	if(fayt==NULL || faytsave==NULL)
		ERROR_EXIT(-1, "Unable to allocate %lu bytes for search buffer.\n",
			(minwidth * sizeof(*fayt)) + (minwidth * sizeof(*faytsave)));
	fayt[0] = '\0';

	initcurses();

	/* Some notes on the keys:
	 * - The key '\0' (or simply 0) stops the processing of the
	 * array. This means, templates or future keys can be added
	 * beforehand behind a key=0 line - they will never be
	 * displayed.
	 * - key < 0 will show the key name only. This is useful for
	 * adding spaces or titles.
	 * - The texts are dynamic. As a smaller display shows only
	 * a limited amount of characters, texts should be crafted to
	 * start with their core information.
	 * Bad : "Show only global" => "Show only g" => "Show o"
	 * Good: "Global flags"     => "Global flag" => "Global"
	 */
	sKey keys[] = {
		/* Row 0 left - General keys */
		MAKE_KEY('?',    "?:",     "Help",   "",     "", NULL,           0),
		MAKE_KEY('\n',   "Enter:", "Save",   "Exit", "", (int*)&ro_mode, 0),
		MAKE_KEY('\033', "Esc:",   "Cancel", "Exit", "", (int*)&ro_mode, 0),

		/* Row 0 right - Display style (description) */
		MAKE_KEY(-1, "  ", "", "", "", NULL, 0),
		MAKE_KEY(KEY_F( 9), "F9:",  "Pkg right",  "Pkg left",    "", (int*)&e_order, 0),
		MAKE_KEY(KEY_F(10), "F10:", "Strip desc", "Full desc",   "", (int*)&e_desc,  0),
		MAKE_KEY(KEY_F(11), "F11:", "Wrap desc",  "Unwrap desc", "", (int*)&e_wrap,  0),

		/* Row 1 - Filter settings */
		MAKE_KEY(-1, "Filter: ", "", "", "", NULL, 1),
		MAKE_KEY(KEY_F( 5), "F5:", "Global only", "Local only",    "Both Scopes",   (int*)&e_scope, 1),
		MAKE_KEY(KEY_F( 6), "F6:", "Inst pkgs",   "Not inst pkgs", "All pkgs",      (int*)&e_state, 1),
		MAKE_KEY(KEY_F( 7), "F7:", "Masked only", "Both states",   "Unmasked only", (int*)&e_mask,  1),
		MAKE_KEY(0, "", "", "", "", NULL, 0), /* processing stops here (row _MUST_ be 0 here!) */

		/* future keys, that are planned */
		MAKE_KEY(KEY_F( 8), "F8:",  "Unknown flags", "Known flags", "all", NULL, 1)
	};

	result = maineventloop(ro_mode ? subtitle_ro : subtitle_rw,
				&callback, &drawflag, flags, keys, true);

	cursesdone();

	if(0 == result) {
		FILE *output = fdopen(4, "w");
		sFlag *flag = flags;
		do {
			switch(flag->stateConf)
			{
			case '+':
				fprintf(output, "%s\n", flag->name);
				break;
			case '-':
				fprintf(output, "-%s\n", flag->name);
				break;
			}
			flag = flag->next;
		} while(flag != flags);
		fclose(output);
	}

	if (fayt)     free(fayt);
	if (faytsave) free(faytsave);

	return result;
}