[thirdparty/newt.git] / newt.h

#ifndef H_NEWT
#define H_NEWT

#ifdef __cplusplus
extern "C" {
#endif

#include <stdarg.h>

#define NEWT_COLORSET_ROOT 		2
#define NEWT_COLORSET_BORDER 		3
#define NEWT_COLORSET_WINDOW		4
#define NEWT_COLORSET_SHADOW		5
#define NEWT_COLORSET_TITLE		6
#define NEWT_COLORSET_BUTTON		7
#define NEWT_COLORSET_ACTBUTTON		8
#define NEWT_COLORSET_CHECKBOX		9
#define NEWT_COLORSET_ACTCHECKBOX	10
#define NEWT_COLORSET_ENTRY		11
#define NEWT_COLORSET_LABEL		12
#define NEWT_COLORSET_LISTBOX		13
#define NEWT_COLORSET_ACTLISTBOX	14
#define NEWT_COLORSET_TEXTBOX		15
#define NEWT_COLORSET_ACTTEXTBOX	16
#define NEWT_COLORSET_HELPLINE		17
#define NEWT_COLORSET_ROOTTEXT		18
#define NEWT_COLORSET_EMPTYSCALE	19
#define NEWT_COLORSET_FULLSCALE		20
#define NEWT_COLORSET_DISENTRY		21
#define NEWT_COLORSET_COMPACTBUTTON	22
#define NEWT_COLORSET_ACTSELLISTBOX	23
#define NEWT_COLORSET_SELLISTBOX	24

#define NEWT_ARG_LAST			-100000
#define NEWT_ARG_APPEND			-1

struct newtColors {
    char * rootFg, * rootBg;
    char * borderFg, * borderBg;
    char * windowFg, * windowBg;
    char * shadowFg, * shadowBg;
    char * titleFg, * titleBg;
    char * buttonFg, * buttonBg;
    char * actButtonFg, * actButtonBg;
    char * checkboxFg, * checkboxBg;
    char * actCheckboxFg, * actCheckboxBg;
    char * entryFg, * entryBg;
    char * labelFg, * labelBg;
    char * listboxFg, * listboxBg;
    char * actListboxFg, * actListboxBg;
    char * textboxFg, * textboxBg;
    char * actTextboxFg, * actTextboxBg;
    char * helpLineFg, * helpLineBg;
    char * rootTextFg, * rootTextBg;
    char * emptyScale, * fullScale;
    char * disabledEntryFg, * disabledEntryBg;
    char * compactButtonFg, * compactButtonBg;
    char * actSelListboxFg, * actSelListboxBg;
    char * selListboxFg, * selListboxBg;
};

enum newtFlagsSense { NEWT_FLAGS_SET, NEWT_FLAGS_RESET, NEWT_FLAGS_TOGGLE };

#define NEWT_FLAG_RETURNEXIT 	(1 << 0)
#define NEWT_FLAG_HIDDEN 	(1 << 1)
#define NEWT_FLAG_SCROLL 	(1 << 2)
#define NEWT_FLAG_DISABLED 	(1 << 3)
/* OBSOLETE #define NEWT_FLAG_NOSCROLL 	(1 << 4)	for listboxes */
#define NEWT_FLAG_BORDER	(1 << 5)
#define NEWT_FLAG_WRAP		(1 << 6)
#define NEWT_FLAG_NOF12		(1 << 7)
#define NEWT_FLAG_MULTIPLE      (1 << 8)
#define NEWT_FLAG_SELECTED	(1 << 9)
#define NEWT_FLAG_CHECKBOX	(1 << 10)
#define NEWT_FLAG_PASSWORD      (1 << 11)  /* draw '*'  of chars in entrybox */
#define NEWT_FD_READ		(1 << 0)
#define NEWT_FD_WRITE		(1 << 1)

#define NEWT_CHECKBOXTREE_COLLAPSED	'\0'
#define NEWT_CHECKBOXTREE_EXPANDED	'\1'
#define NEWT_CHECKBOXTREE_UNSELECTED	' '
#define NEWT_CHECKBOXTREE_SELECTED	'*'

/* Backwards compatibility */
#define NEWT_LISTBOX_RETURNEXIT NEWT_FLAG_RETURNEXIT
#define NEWT_ENTRY_SCROLL	NEWT_FLAG_SCROLL
#define NEWT_ENTRY_HIDDEN	NEWT_FLAG_HIDDEN
#define NEWT_ENTRY_RETURNEXIT	NEWT_FLAG_RETURNEXIT
#define NEWT_ENTRY_DISABLED	NEWT_FLAG_DISABLED

#define NEWT_TEXTBOX_WRAP	NEWT_FLAG_WRAP
#define NEWT_TEXTBOX_SCROLL	NEWT_FLAG_SCROLL
#define NEWT_FORM_NOF12		NEWT_FLAG_NOF12

#define newtListboxAddEntry	newtListboxAppendEntry


typedef struct newtComponent_struct * newtComponent;

extern const struct newtColors newtDefaultColorPalette;

typedef void (*newtCallback)(newtComponent, void *);
typedef void (*newtSuspendCallback)(void * data);

int newtInit(void);
int newtFinished(void);
void newtCls(void);
void newtResizeScreen(int redraw);
void newtWaitForKey(void);
void newtClearKeyBuffer(void);
void newtDelay(int usecs);
/* top, left are *not* counting the border */
int newtOpenWindow(int left, int top, int width, int height, 
			  const char * title);
int newtCenteredWindow(int width, int height, const char * title);
void newtPopWindow(void);
void newtSetColors(struct newtColors colors);
void newtRefresh(void);
void newtSuspend(void);
void newtSetSuspendCallback(newtSuspendCallback cb, void * data);
void newtSetHelpCallback(newtCallback cb);
void newtResume(void);
void newtPushHelpLine(const char * text);
void newtRedrawHelpLine(void);
void newtPopHelpLine(void);
void newtDrawRootText(int col, int row, const char * text);
void newtBell(void);
void newtCursorOff(void);
void newtCursorOn(void);

/* Components */

newtComponent newtCompactButton(int left, int top, const char * text);
newtComponent newtButton(int left, int top, const char * text);
newtComponent newtCheckbox(int left, int top, const char * text, char defValue,
			   const char * seq, char * result);
char newtCheckboxGetValue(newtComponent co);
void newtCheckboxSetValue(newtComponent co, char value);
void newtCheckboxSetFlags(newtComponent co, int flags, enum newtFlagsSense sense);

    
newtComponent newtRadiobutton(int left, int top, const char * text, int isDefault,
			      newtComponent prevButton);
newtComponent newtRadioGetCurrent(newtComponent setMember);
newtComponent newtListitem(int left, int top, const char * text, int isDefault,
			      newtComponent prevItem, const void * data, int flags);
void newtListitemSet(newtComponent co, const char * text);
void * newtListitemGetData(newtComponent co);
void newtGetScreenSize(int * cols, int * rows);

newtComponent newtLabel(int left, int top, const char * text);
void newtLabelSetText(newtComponent co, const char * text);
newtComponent newtVerticalScrollbar(int left, int top, int height,
				    int normalColorset, int thumbColorset);
void newtScrollbarSet(newtComponent co, int where, int total);

newtComponent newtListbox(int left, int top, int height, int flags);
void * newtListboxGetCurrent(newtComponent co);
void newtListboxSetCurrent(newtComponent co, int num);
void newtListboxSetCurrentByKey(newtComponent co, void * key);
void newtListboxSetEntry(newtComponent co, int num, const char * text);
void newtListboxSetWidth(newtComponent co, int width);
void newtListboxSetData(newtComponent co, int num, void * data);
int newtListboxAppendEntry(newtComponent co, const char * text, 
			   const void * data);
/* Send the key to insert after, or NULL to insert at the top */
int newtListboxInsertEntry(newtComponent co, const char * text, const void * data, void * key);
int newtListboxDeleteEntry(newtComponent co, void * data);
void newtListboxClear(newtComponent co); /* removes all entries from listbox */
void newtListboxGetEntry(newtComponent co, int num, char **text, void **data);
/* Returns an array of data pointers from items, last element is NULL */
void **newtListboxGetSelection(newtComponent co, int *numitems);
void newtListboxClearSelection(newtComponent co);
void newtListboxSelectItem(newtComponent co, const void * key,
	enum newtFlagsSense sense);

newtComponent newtCheckboxTree(int left, int top, int height, int flags);
newtComponent newtCheckboxTreeMulti(int left, int top, int height, char *seq, int flags);
const void ** newtCheckboxTreeGetSelection(newtComponent co, int *numitems);
const void * newtCheckboxTreeGetCurrent(newtComponent co);
void newtCheckboxTreeSetCurrent(newtComponent co, void * item);
const void ** newtCheckboxTreeGetMultiSelection(newtComponent co, int *numitems, char seqnum);
/* last item is NEWT_ARG_LAST for all of these */
int newtCheckboxTreeAddItem(newtComponent co, 
			    const char * text, const void * data,
			    int flags, int index, ...);
int newtCheckboxTreeAddArray(newtComponent co, 
			     const char * text, const void * data,
			     int flags, int * indexes);
int * newtCheckboxTreeFindItem(newtComponent co, void * data);
void newtCheckboxTreeSetEntry(newtComponent co, const void * data,
			      const char * text);
char newtCheckboxTreeGetEntryValue(newtComponent co, const void * data);
void newtCheckboxTreeSetEntryValue(newtComponent co, const void * data,
				   char value);
    
newtComponent newtTextboxReflowed(int left, int top, char * text, int width,
				  int flexDown, int flexUp, int flags);
newtComponent newtTextbox(int left, int top, int width, int height, int flags);
void newtTextboxSetText(newtComponent co, const char * text);
void newtTextboxSetHeight(newtComponent co, int height);
int newtTextboxGetNumLines(newtComponent co);
char * newtReflowText(char * text, int width, int flexDown, int flexUp,
		      int * actualWidth, int * actualHeight);

struct newtExitStruct {
    enum { NEWT_EXIT_HOTKEY, NEWT_EXIT_COMPONENT, NEWT_EXIT_FDREADY,
	   NEWT_EXIT_TIMER } reason;
    union {
	int key;
	newtComponent co;
    } u;
} ;

newtComponent newtForm(newtComponent vertBar, void * helpTag, int flags);
void newtFormSetTimer(newtComponent form, int millisecs);
void newtFormWatchFd(newtComponent form, int fd, int fdFlags);
void newtFormSetSize(newtComponent co);
newtComponent newtFormGetCurrent(newtComponent co);
void newtFormSetBackground(newtComponent co, int color);
void newtFormSetCurrent(newtComponent co, newtComponent subco);
void newtFormAddComponent(newtComponent form, newtComponent co);
void newtFormAddComponents(newtComponent form, ...);
void newtFormSetHeight(newtComponent co, int height);
void newtFormSetWidth(newtComponent co, int width);
newtComponent newtRunForm(newtComponent form);		/* obsolete */
void newtFormRun(newtComponent co, struct newtExitStruct * es);
void newtDrawForm(newtComponent form);
void newtFormAddHotKey(newtComponent co, int key);

typedef int (*newtEntryFilter)(newtComponent entry, void * data, int ch,
			       int cursor);
newtComponent newtEntry(int left, int top, const char * initialValue, int width,
			char ** resultPtr, int flags);
void newtEntrySet(newtComponent co, const char * value, int cursorAtEnd);
void newtEntrySetFilter(newtComponent co, newtEntryFilter filter, void * data);
char * newtEntryGetValue(newtComponent co);
void newtEntrySetFlags(newtComponent co, int flags, enum newtFlagsSense sense);

newtComponent newtScale(int left, int top, int width, long long fullValue);
void newtScaleSet(newtComponent co, unsigned long long amount);

void newtComponentAddCallback(newtComponent co, newtCallback f, void * data);
void newtComponentTakesFocus(newtComponent co, int val);

/* this also destroys all of the components (including other forms) on the 
   form */
void newtFormDestroy(newtComponent form);	

/* Key codes */

#define NEWT_KEY_TAB			'\t'
#define NEWT_KEY_ENTER			'\r'
#define NEWT_KEY_SUSPEND		'\032'			/* ctrl - z*/
#define NEWT_KEY_RETURN			NEWT_KEY_ENTER

#define NEWT_KEY_EXTRA_BASE		0x8000
#define NEWT_KEY_UP			NEWT_KEY_EXTRA_BASE + 1
#define NEWT_KEY_DOWN			NEWT_KEY_EXTRA_BASE + 2
#define NEWT_KEY_LEFT			NEWT_KEY_EXTRA_BASE + 4
#define NEWT_KEY_RIGHT			NEWT_KEY_EXTRA_BASE + 5
#define NEWT_KEY_BKSPC			NEWT_KEY_EXTRA_BASE + 6
#define NEWT_KEY_DELETE			NEWT_KEY_EXTRA_BASE + 7
#define NEWT_KEY_HOME			NEWT_KEY_EXTRA_BASE + 8
#define NEWT_KEY_END			NEWT_KEY_EXTRA_BASE + 9
#define NEWT_KEY_UNTAB			NEWT_KEY_EXTRA_BASE + 10
#define NEWT_KEY_PGUP			NEWT_KEY_EXTRA_BASE + 11
#define NEWT_KEY_PGDN			NEWT_KEY_EXTRA_BASE + 12
#define NEWT_KEY_INSERT			NEWT_KEY_EXTRA_BASE + 13

#define NEWT_KEY_F1			NEWT_KEY_EXTRA_BASE + 101
#define NEWT_KEY_F2			NEWT_KEY_EXTRA_BASE + 102
#define NEWT_KEY_F3			NEWT_KEY_EXTRA_BASE + 103
#define NEWT_KEY_F4			NEWT_KEY_EXTRA_BASE + 104
#define NEWT_KEY_F5			NEWT_KEY_EXTRA_BASE + 105
#define NEWT_KEY_F6			NEWT_KEY_EXTRA_BASE + 106
#define NEWT_KEY_F7			NEWT_KEY_EXTRA_BASE + 107
#define NEWT_KEY_F8			NEWT_KEY_EXTRA_BASE + 108
#define NEWT_KEY_F9			NEWT_KEY_EXTRA_BASE + 109
#define NEWT_KEY_F10			NEWT_KEY_EXTRA_BASE + 110
#define NEWT_KEY_F11			NEWT_KEY_EXTRA_BASE + 111
#define NEWT_KEY_F12			NEWT_KEY_EXTRA_BASE + 112

/* not really a key, but newtGetKey returns it */
#define NEWT_KEY_RESIZE			NEWT_KEY_EXTRA_BASE + 113

#define NEWT_ANCHOR_LEFT		(1 << 0)
#define NEWT_ANCHOR_RIGHT		(1 << 1)
#define NEWT_ANCHOR_TOP			(1 << 2)
#define NEWT_ANCHOR_BOTTOM		(1 << 3)

#define NEWT_GRID_FLAG_GROWX		(1 << 0)
#define NEWT_GRID_FLAG_GROWY		(1 << 1)

typedef struct grid_s * newtGrid;
enum newtGridElement { NEWT_GRID_EMPTY = 0,
		       NEWT_GRID_COMPONENT, NEWT_GRID_SUBGRID };

newtGrid newtCreateGrid(int cols, int rows);
/* TYPE, what, TYPE, what, ..., NULL */
newtGrid newtGridVStacked(enum newtGridElement type, void * what, ...);
newtGrid newtGridVCloseStacked(enum newtGridElement type, void * what, ...);
newtGrid newtGridHStacked(enum newtGridElement type1, void * what1, ...);
newtGrid newtGridHCloseStacked(enum newtGridElement type1, void * what1, ...);
newtGrid newtGridBasicWindow(newtComponent text, newtGrid middle,
			     newtGrid buttons);
newtGrid newtGridSimpleWindow(newtComponent text, newtComponent middle,
			     newtGrid buttons);
void newtGridSetField(newtGrid grid, int col, int row, 
		      enum newtGridElement type, void * val, int padLeft,
		      int padTop, int padRight, int padBottom, int anchor,
		      int flags);
void newtGridPlace(newtGrid grid, int left, int top);
#define newtGridDestroy newtGridFree
void newtGridFree(newtGrid grid, int recurse);
void newtGridGetSize(newtGrid grid, int * width, int * height);
void newtGridWrappedWindow(newtGrid grid, char * title);
void newtGridWrappedWindowAt(newtGrid grid, char * title, int left, int top);
void newtGridAddComponentsToForm(newtGrid grid, newtComponent form, 
				 int recurse);

/* convienve */
newtGrid newtButtonBarv(char * button1, newtComponent * b1comp, va_list args);
newtGrid newtButtonBar(char * button1, newtComponent * b1comp, ...);

/* automatically centered and shrink wrapped */
void newtWinMessage(char * title, char * buttonText, char * text, ...);
void newtWinMessagev(char * title, char * buttonText, char * text, 
		     va_list argv);

/* having separate calls for these two seems silly, but having two separate
   variable length-arg lists seems like a bad idea as well */

/* Returns 0 if F12 was pressed, 1 for button1, 2 for button2 */
int newtWinChoice(char * title, char * button1, char * button2, 
		   char * text, ...);
/* Returns 0 if F12 was pressed, 1 for button1, 2 for button2, 
   3 for button3 */
int newtWinTernary(char * title, char * button1, char * button2, 
		   char * button3, char * message, ...);

/* Returns the button number pressed, 0 on F12 */
int newtWinMenu(char * title, char * text, int suggestedWidth, int flexDown, 
		int flexUp, int maxListHeight, char ** items, int * listItem,
		char * button1, ...);

struct newtWinEntry {
    char * text;
    char ** value;		/* may be initialized to set default */
    int flags;
};

/* Returns the button number pressed, 0 on F12. The final values are
   dynamically allocated, and need to be freed. */
int newtWinEntries(char * title, char * text, int suggestedWidth, int flexDown, 
		   int flexUp, int dataWidth, 
		   struct newtWinEntry * items, char * button1, ...);

#ifdef __cplusplus
} /* End of extern "C" { */
#endif

#endif /* H_NEWT */
Commit	Line	Data
6fb96a3f	1	#ifndef H_NEWT
	2	#define H_NEWT
	3
45c366b1	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
889babd9	8	#include <stdarg.h>
889babd9	9
0c82afe1	10	#define NEWT_COLORSET_ROOT 2
	11	#define NEWT_COLORSET_BORDER 3
	12	#define NEWT_COLORSET_WINDOW 4
	13	#define NEWT_COLORSET_SHADOW 5
	14	#define NEWT_COLORSET_TITLE 6
	15	#define NEWT_COLORSET_BUTTON 7
	16	#define NEWT_COLORSET_ACTBUTTON 8
	17	#define NEWT_COLORSET_CHECKBOX 9
	18	#define NEWT_COLORSET_ACTCHECKBOX 10
	19	#define NEWT_COLORSET_ENTRY 11
	20	#define NEWT_COLORSET_LABEL 12
	21	#define NEWT_COLORSET_LISTBOX 13
	22	#define NEWT_COLORSET_ACTLISTBOX 14
	23	#define NEWT_COLORSET_TEXTBOX 15
	24	#define NEWT_COLORSET_ACTTEXTBOX 16
	25	#define NEWT_COLORSET_HELPLINE 17
	26	#define NEWT_COLORSET_ROOTTEXT 18
a0981f23	27	#define NEWT_COLORSET_EMPTYSCALE 19
a0981f23	28	#define NEWT_COLORSET_FULLSCALE 20
38f35ccd	29	#define NEWT_COLORSET_DISENTRY 21
5a5750f4	30	#define NEWT_COLORSET_COMPACTBUTTON 22
46263d9e	31	#define NEWT_COLORSET_ACTSELLISTBOX 23
46263d9e	32	#define NEWT_COLORSET_SELLISTBOX 24
38f35ccd	33
1e0b187b	34	#define NEWT_ARG_LAST -100000
	35	#define NEWT_ARG_APPEND -1
	36
6fb96a3f	37	struct newtColors {
	38	char * rootFg, * rootBg;
	39	char * borderFg, * borderBg;
	40	char * windowFg, * windowBg;
	41	char * shadowFg, * shadowBg;
	42	char * titleFg, * titleBg;
	43	char * buttonFg, * buttonBg;
	44	char * actButtonFg, * actButtonBg;
	45	char * checkboxFg, * checkboxBg;
	46	char * actCheckboxFg, * actCheckboxBg;
	47	char * entryFg, * entryBg;
f49c3f68	48	char * labelFg, * labelBg;
ebf4ad8f	49	char * listboxFg, * listboxBg;
ebf4ad8f	50	char * actListboxFg, * actListboxBg;
31790a87	51	char * textboxFg, * textboxBg;
31790a87	52	char * actTextboxFg, * actTextboxBg;
0c82afe1	53	char * helpLineFg, * helpLineBg;
0c82afe1	54	char * rootTextFg, * rootTextBg;
a0981f23	55	char * emptyScale, * fullScale;
38f35ccd	56	char * disabledEntryFg, * disabledEntryBg;
5a5750f4	57	char * compactButtonFg, * compactButtonBg;
46263d9e	58	char * actSelListboxFg, * actSelListboxBg;
46263d9e	59	char * selListboxFg, * selListboxBg;
6fb96a3f	60	};
6fb96a3f	61
69bf2308	62	enum newtFlagsSense { NEWT_FLAGS_SET, NEWT_FLAGS_RESET, NEWT_FLAGS_TOGGLE };
c495207a	63
5a5750f4	64	#define NEWT_FLAG_RETURNEXIT (1 << 0)
	65	#define NEWT_FLAG_HIDDEN (1 << 1)
	66	#define NEWT_FLAG_SCROLL (1 << 2)
	67	#define NEWT_FLAG_DISABLED (1 << 3)
7e4664f8	68	/* OBSOLETE #define NEWT_FLAG_NOSCROLL (1 << 4) for listboxes */
7e4664f8	69	#define NEWT_FLAG_BORDER (1 << 5)
4a93351d	70	#define NEWT_FLAG_WRAP (1 << 6)
4a93351d	71	#define NEWT_FLAG_NOF12 (1 << 7)
2dbc072e	72	#define NEWT_FLAG_MULTIPLE (1 << 8)
69bf2308	73	#define NEWT_FLAG_SELECTED (1 << 9)
1e0b187b	74	#define NEWT_FLAG_CHECKBOX (1 << 10)
20fb366a	75	#define NEWT_FLAG_PASSWORD (1 << 11) /* draw '' of chars in entrybox /
7e4664f8	76	#define NEWT_FD_READ (1 << 0)
	77	#define NEWT_FD_WRITE (1 << 1)
	78
c895490d	79	#define NEWT_CHECKBOXTREE_COLLAPSED '\0'
	80	#define NEWT_CHECKBOXTREE_EXPANDED '\1'
	81	#define NEWT_CHECKBOXTREE_UNSELECTED ' '
	82	#define NEWT_CHECKBOXTREE_SELECTED '*'
	83
c495207a	84	/* Backwards compatibility */
	85	#define NEWT_LISTBOX_RETURNEXIT NEWT_FLAG_RETURNEXIT
	86	#define NEWT_ENTRY_SCROLL NEWT_FLAG_SCROLL
	87	#define NEWT_ENTRY_HIDDEN NEWT_FLAG_HIDDEN
	88	#define NEWT_ENTRY_RETURNEXIT NEWT_FLAG_RETURNEXIT
	89	#define NEWT_ENTRY_DISABLED NEWT_FLAG_DISABLED
	90
4a93351d	91	#define NEWT_TEXTBOX_WRAP NEWT_FLAG_WRAP
	92	#define NEWT_TEXTBOX_SCROLL NEWT_FLAG_SCROLL
	93	#define NEWT_FORM_NOF12 NEWT_FLAG_NOF12
	94
7e4664f8	95	#define newtListboxAddEntry newtListboxAppendEntry
7e4664f8	96
d02ffb49	97
45c366b1	98	typedef struct newtComponent_struct * newtComponent;
1a6c8e81	99
57c466b0	100	extern const struct newtColors newtDefaultColorPalette;
6fb96a3f	101
1a6c8e81	102	typedef void (newtCallback)(newtComponent, void );
06cf519e	103	typedef void (newtSuspendCallback)(void data);
1a6c8e81	104
6fb96a3f	105	int newtInit(void);
	106	int newtFinished(void);
	107	void newtCls(void);
ae1235d0	108	void newtResizeScreen(int redraw);
6fb96a3f	109	void newtWaitForKey(void);
	110	void newtClearKeyBuffer(void);
	111	void newtDelay(int usecs);
	112	/* top, left are not counting the border */
	113	int newtOpenWindow(int left, int top, int width, int height,
d4109c37	114	const char * title);
f16e164f	115	int newtCenteredWindow(int width, int height, const char * title);
6fb96a3f	116	void newtPopWindow(void);
	117	void newtSetColors(struct newtColors colors);
	118	void newtRefresh(void);
a0981f23	119	void newtSuspend(void);
06cf519e	120	void newtSetSuspendCallback(newtSuspendCallback cb, void * data);
72b71fa6	121	void newtSetHelpCallback(newtCallback cb);
a0981f23	122	void newtResume(void);
d4109c37	123	void newtPushHelpLine(const char * text);
c2955119	124	void newtRedrawHelpLine(void);
0c82afe1	125	void newtPopHelpLine(void);
7e4664f8	126	void newtDrawRootText(int col, int row, const char * text);
69bf2308	127	void newtBell(void);
23efd09b	128	void newtCursorOff(void);
23efd09b	129	void newtCursorOn(void);
6fb96a3f	130
	131	/* Components */
	132
d4109c37	133	newtComponent newtCompactButton(int left, int top, const char * text);
	134	newtComponent newtButton(int left, int top, const char * text);
	135	newtComponent newtCheckbox(int left, int top, const char * text, char defValue,
	136	const char * seq, char * result);
d02ffb49	137	char newtCheckboxGetValue(newtComponent co);
b6565704	138	void newtCheckboxSetValue(newtComponent co, char value);
60c6e639	139	void newtCheckboxSetFlags(newtComponent co, int flags, enum newtFlagsSense sense);
	140
	141
d4109c37	142	newtComponent newtRadiobutton(int left, int top, const char * text, int isDefault,
6fb96a3f	143	newtComponent prevButton);
1a6c8e81	144	newtComponent newtRadioGetCurrent(newtComponent setMember);
d4109c37	145	newtComponent newtListitem(int left, int top, const char * text, int isDefault,
	146	newtComponent prevItem, const void * data, int flags);
	147	void newtListitemSet(newtComponent co, const char * text);
da6ac8a1	148	void * newtListitemGetData(newtComponent co);
721584c3	149	void newtGetScreenSize(int * cols, int * rows);
ebf4ad8f	150
d4109c37	151	newtComponent newtLabel(int left, int top, const char * text);
d4109c37	152	void newtLabelSetText(newtComponent co, const char * text);
092a7b2d	153	newtComponent newtVerticalScrollbar(int left, int top, int height,
	154	int normalColorset, int thumbColorset);
	155	void newtScrollbarSet(newtComponent co, int where, int total);
ebf4ad8f	156
ebf4ad8f	157	newtComponent newtListbox(int left, int top, int height, int flags);
da6ac8a1	158	void * newtListboxGetCurrent(newtComponent co);
7ea3dccd	159	void newtListboxSetCurrent(newtComponent co, int num);
d5878365	160	void newtListboxSetCurrentByKey(newtComponent co, void * key);
d4109c37	161	void newtListboxSetEntry(newtComponent co, int num, const char * text);
babcb349	162	void newtListboxSetWidth(newtComponent co, int width);
0f890b31	163	void newtListboxSetData(newtComponent co, int num, void * data);
7e4664f8	164	int newtListboxAppendEntry(newtComponent co, const char * text,
7e4664f8	165	const void * data);
a507b3ec	166	/* Send the key to insert after, or NULL to insert at the top */
	167	int newtListboxInsertEntry(newtComponent co, const char * text, const void * data, void * key);
	168	int newtListboxDeleteEntry(newtComponent co, void * data);
49a541f2	169	void newtListboxClear(newtComponent co); /* removes all entries from listbox */
0f890b31	170	void newtListboxGetEntry(newtComponent co, int num, char text, void data);
4678a85f	171	/* Returns an array of data pointers from items, last element is NULL */
cb586ef6	172	void *newtListboxGetSelection(newtComponent co, int numitems);
46263d9e	173	void newtListboxClearSelection(newtComponent co);
7e4664f8	174	void newtListboxSelectItem(newtComponent co, const void * key,
69bf2308	175	enum newtFlagsSense sense);
1e0b187b	176
f06c5a99	177	newtComponent newtCheckboxTree(int left, int top, int height, int flags);
1fc80395	178	newtComponent newtCheckboxTreeMulti(int left, int top, int height, char *seq, int flags);
2b6641b1	179	const void ** newtCheckboxTreeGetSelection(newtComponent co, int *numitems);
2b6641b1	180	const void * newtCheckboxTreeGetCurrent(newtComponent co);
5160fc22	181	void newtCheckboxTreeSetCurrent(newtComponent co, void * item);
2b6641b1	182	const void ** newtCheckboxTreeGetMultiSelection(newtComponent co, int *numitems, char seqnum);
1e0b187b	183	/* last item is NEWT_ARG_LAST for all of these */
	184	int newtCheckboxTreeAddItem(newtComponent co,
	185	const char * text, const void * data,
	186	int flags, int index, ...);
	187	int newtCheckboxTreeAddArray(newtComponent co,
c895490d	188	const char * text, const void * data,
c895490d	189	int flags, int * indexes);
1e0b187b	190	int * newtCheckboxTreeFindItem(newtComponent co, void * data);
c895490d	191	void newtCheckboxTreeSetEntry(newtComponent co, const void * data,
	192	const char * text);
	193	char newtCheckboxTreeGetEntryValue(newtComponent co, const void * data);
	194	void newtCheckboxTreeSetEntryValue(newtComponent co, const void * data,
	195	char value);
46263d9e	196
abedc66c	197	newtComponent newtTextboxReflowed(int left, int top, char * text, int width,
abedc66c	198	int flexDown, int flexUp, int flags);
7e4664f8	199	newtComponent newtTextbox(int left, int top, int width, int height, int flags);
31790a87	200	void newtTextboxSetText(newtComponent co, const char * text);
5a5750f4	201	void newtTextboxSetHeight(newtComponent co, int height);
5a5750f4	202	int newtTextboxGetNumLines(newtComponent co);
889babd9	203	char * newtReflowText(char * text, int width, int flexDown, int flexUp,
889babd9	204	int * actualWidth, int * actualHeight);
31790a87	205
e96319d5	206	struct newtExitStruct {
e67a6cab	207	enum { NEWT_EXIT_HOTKEY, NEWT_EXIT_COMPONENT, NEWT_EXIT_FDREADY,
73390860	208	NEWT_EXIT_TIMER } reason;
e96319d5	209	union {
	210	int key;
	211	newtComponent co;
	212	} u;
	213	} ;
	214
72b71fa6	215	newtComponent newtForm(newtComponent vertBar, void * helpTag, int flags);
e67a6cab	216	void newtFormSetTimer(newtComponent form, int millisecs);
d02ffb49	217	void newtFormWatchFd(newtComponent form, int fd, int fdFlags);
d73cfca2	218	void newtFormSetSize(newtComponent co);
da6ac8a1	219	newtComponent newtFormGetCurrent(newtComponent co);
65feaf77	220	void newtFormSetBackground(newtComponent co, int color);
7ea3dccd	221	void newtFormSetCurrent(newtComponent co, newtComponent subco);
c4827b34	222	void newtFormAddComponent(newtComponent form, newtComponent co);
c4827b34	223	void newtFormAddComponents(newtComponent form, ...);
ebf4ad8f	224	void newtFormSetHeight(newtComponent co, int height);
ea947804	225	void newtFormSetWidth(newtComponent co, int width);
e96319d5	226	newtComponent newtRunForm(newtComponent form); /* obsolete */
e96319d5	227	void newtFormRun(newtComponent co, struct newtExitStruct * es);
8b68158d	228	void newtDrawForm(newtComponent form);
e96319d5	229	void newtFormAddHotKey(newtComponent co, int key);
c4827b34	230
d02ffb49	231	typedef int (newtEntryFilter)(newtComponent entry, void data, int ch,
d02ffb49	232	int cursor);
d4109c37	233	newtComponent newtEntry(int left, int top, const char * initialValue, int width,
6fb96a3f	234	char ** resultPtr, int flags);
d4109c37	235	void newtEntrySet(newtComponent co, const char * value, int cursorAtEnd);
d02ffb49	236	void newtEntrySetFilter(newtComponent co, newtEntryFilter filter, void * data);
d02ffb49	237	char * newtEntryGetValue(newtComponent co);
60c6e639	238	void newtEntrySetFlags(newtComponent co, int flags, enum newtFlagsSense sense);
a0981f23	239
a0981f23	240	newtComponent newtScale(int left, int top, int width, long long fullValue);
649a0152	241	void newtScaleSet(newtComponent co, unsigned long long amount);
a0981f23	242
e96319d5	243	void newtComponentAddCallback(newtComponent co, newtCallback f, void * data);
0123387a	244	void newtComponentTakesFocus(newtComponent co, int val);
6fb96a3f	245
c4827b34	246	/* this also destroys all of the components (including other forms) on the
	247	form */
	248	void newtFormDestroy(newtComponent form);
6fb96a3f	249
	250	/* Key codes */
	251
	252	#define NEWT_KEY_TAB '\t'
	253	#define NEWT_KEY_ENTER '\r'
b7c1b763	254	#define NEWT_KEY_SUSPEND '\032' /* ctrl - z*/
6fb96a3f	255	#define NEWT_KEY_RETURN NEWT_KEY_ENTER
	256
	257	#define NEWT_KEY_EXTRA_BASE 0x8000
	258	#define NEWT_KEY_UP NEWT_KEY_EXTRA_BASE + 1
	259	#define NEWT_KEY_DOWN NEWT_KEY_EXTRA_BASE + 2
	260	#define NEWT_KEY_LEFT NEWT_KEY_EXTRA_BASE + 4
	261	#define NEWT_KEY_RIGHT NEWT_KEY_EXTRA_BASE + 5
	262	#define NEWT_KEY_BKSPC NEWT_KEY_EXTRA_BASE + 6
	263	#define NEWT_KEY_DELETE NEWT_KEY_EXTRA_BASE + 7
	264	#define NEWT_KEY_HOME NEWT_KEY_EXTRA_BASE + 8
	265	#define NEWT_KEY_END NEWT_KEY_EXTRA_BASE + 9
ebf4ad8f	266	#define NEWT_KEY_UNTAB NEWT_KEY_EXTRA_BASE + 10
bf0f641d	267	#define NEWT_KEY_PGUP NEWT_KEY_EXTRA_BASE + 11
bf0f641d	268	#define NEWT_KEY_PGDN NEWT_KEY_EXTRA_BASE + 12
ebd91270	269	#define NEWT_KEY_INSERT NEWT_KEY_EXTRA_BASE + 13
6fb96a3f	270
e338bed6	271	#define NEWT_KEY_F1 NEWT_KEY_EXTRA_BASE + 101
e96319d5	272	#define NEWT_KEY_F2 NEWT_KEY_EXTRA_BASE + 102
	273	#define NEWT_KEY_F3 NEWT_KEY_EXTRA_BASE + 103
	274	#define NEWT_KEY_F4 NEWT_KEY_EXTRA_BASE + 104
	275	#define NEWT_KEY_F5 NEWT_KEY_EXTRA_BASE + 105
	276	#define NEWT_KEY_F6 NEWT_KEY_EXTRA_BASE + 106
	277	#define NEWT_KEY_F7 NEWT_KEY_EXTRA_BASE + 107
	278	#define NEWT_KEY_F8 NEWT_KEY_EXTRA_BASE + 108
	279	#define NEWT_KEY_F9 NEWT_KEY_EXTRA_BASE + 109
	280	#define NEWT_KEY_F10 NEWT_KEY_EXTRA_BASE + 110
	281	#define NEWT_KEY_F11 NEWT_KEY_EXTRA_BASE + 111
e338bed6	282	#define NEWT_KEY_F12 NEWT_KEY_EXTRA_BASE + 112
e338bed6	283
ae1235d0	284	/* not really a key, but newtGetKey returns it */
	285	#define NEWT_KEY_RESIZE NEWT_KEY_EXTRA_BASE + 113
	286
0123387a	287	#define NEWT_ANCHOR_LEFT (1 << 0)
	288	#define NEWT_ANCHOR_RIGHT (1 << 1)
	289	#define NEWT_ANCHOR_TOP (1 << 2)
	290	#define NEWT_ANCHOR_BOTTOM (1 << 3)
	291
	292	#define NEWT_GRID_FLAG_GROWX (1 << 0)
	293	#define NEWT_GRID_FLAG_GROWY (1 << 1)
	294
e6922740	295	typedef struct grid_s * newtGrid;
	296	enum newtGridElement { NEWT_GRID_EMPTY = 0,
	297	NEWT_GRID_COMPONENT, NEWT_GRID_SUBGRID };
	298
	299	newtGrid newtCreateGrid(int cols, int rows);
d73cfca2	300	/* TYPE, what, TYPE, what, ..., NULL */
d73cfca2	301	newtGrid newtGridVStacked(enum newtGridElement type, void * what, ...);
8f52cd47	302	newtGrid newtGridVCloseStacked(enum newtGridElement type, void * what, ...);
d73cfca2	303	newtGrid newtGridHStacked(enum newtGridElement type1, void * what1, ...);
8f52cd47	304	newtGrid newtGridHCloseStacked(enum newtGridElement type1, void * what1, ...);
	305	newtGrid newtGridBasicWindow(newtComponent text, newtGrid middle,
	306	newtGrid buttons);
	307	newtGrid newtGridSimpleWindow(newtComponent text, newtComponent middle,
	308	newtGrid buttons);
e6922740	309	void newtGridSetField(newtGrid grid, int col, int row,
0123387a	310	enum newtGridElement type, void * val, int padLeft,
	311	int padTop, int padRight, int padBottom, int anchor,
	312	int flags);
e6922740	313	void newtGridPlace(newtGrid grid, int left, int top);
a0dcd105	314	#define newtGridDestroy newtGridFree
e6922740	315	void newtGridFree(newtGrid grid, int recurse);
676cfb93	316	void newtGridGetSize(newtGrid grid, int * width, int * height);
f16e164f	317	void newtGridWrappedWindow(newtGrid grid, char * title);
d73cfca2	318	void newtGridWrappedWindowAt(newtGrid grid, char * title, int left, int top);
8de669b8	319	void newtGridAddComponentsToForm(newtGrid grid, newtComponent form,
8de669b8	320	int recurse);
e6922740	321
91932190	322	/* convienve */
d73cfca2	323	newtGrid newtButtonBarv(char * button1, newtComponent * b1comp, va_list args);
91932190	324	newtGrid newtButtonBar(char * button1, newtComponent * b1comp, ...);
91932190	325
889babd9	326	/* automatically centered and shrink wrapped */
	327	void newtWinMessage(char * title, char * buttonText, char * text, ...);
	328	void newtWinMessagev(char * title, char * buttonText, char * text,
	329	va_list argv);
	330
d73cfca2	331	/* having separate calls for these two seems silly, but having two separate
	332	variable length-arg lists seems like a bad idea as well */
	333
	334	/* Returns 0 if F12 was pressed, 1 for button1, 2 for button2 */
889babd9	335	int newtWinChoice(char * title, char * button1, char * button2,
889babd9	336	char * text, ...);
0989946a	337	/* Returns 0 if F12 was pressed, 1 for button1, 2 for button2,
	338	3 for button3 */
	339	int newtWinTernary(char * title, char * button1, char * button2,
	340	char * button3, char * message, ...);
	341
d73cfca2	342	/* Returns the button number pressed, 0 on F12 */
	343	int newtWinMenu(char * title, char * text, int suggestedWidth, int flexDown,
	344	int flexUp, int maxListHeight, char ** items, int * listItem,
	345	char * button1, ...);
	346
abedc66c	347	struct newtWinEntry {
	348	char * text;
	349	char ** value; /* may be initialized to set default */
	350	int flags;
	351	};
	352
	353	/* Returns the button number pressed, 0 on F12. The final values are
	354	dynamically allocated, and need to be freed. */
	355	int newtWinEntries(char * title, char * text, int suggestedWidth, int flexDown,
	356	int flexUp, int dataWidth,
	357	struct newtWinEntry * items, char * button1, ...);
889babd9	358
45c366b1	359	#ifdef __cplusplus
	360	} /* End of extern "C" { */
	361	#endif
	362
6fb96a3f	363	#endif /* H_NEWT */