/************************************************************************ 
 * This file is part of PDCurses. PDCurses is public domain software;	*
 * you may use it for any purpose. This software is provided AS IS with	*
 * NO WARRANTY whatsoever.						*
 *									*
 * If you use PDCurses in an application, an acknowledgement would be	*
 * appreciated, but is not mandatory. If you make corrections or	*
 * enhancements to PDCurses, please forward them to the current		*
 * maintainer for the benefit of other users.				*
 *									*
 * See the file maintain.er for details of the current maintainer.	*
 ************************************************************************/

#include <curspriv.h>

RCSID("$Id: slk.c,v 1.57 2007/06/22 10:01:10 wmcbrine Exp $")

/*man-start**************************************************************

  Name:								slk

  Synopsis:
	int slk_init(int fmt);
	int slk_set(int labnum, const char *label, int justify);
	int slk_refresh(void);
	int slk_noutrefresh(void);
	char *slk_label(int labnum);
	int slk_clear(void);
	int slk_restore(void);
	int slk_touch(void);
	int slk_attron(const chtype attrs);
	int slk_attr_on(const attr_t attrs, void *opts);
	int slk_attrset(const chtype attrs);
	int slk_attr_set(const attr_t attrs, short color_pair, void *opts);
	int slk_attroff(const chtype attrs);
	int slk_attr_off(const attr_t attrs, void *opts);
	int slk_color(short color_pair);

	int slk_wset(int labnum, const wchar_t *label, int justify);

	int PDC_mouse_in_slk(int y, int x);
	void PDC_slk_free(void);
	void PDC_slk_initialize(void);

	wchar_t *slk_wlabel(int labnum)

  Description:
	These functions manipulate a window that contain Soft Label Keys 
	(SLK). To use the SLK functions, a call to slk_init() must be 
	made BEFORE initscr() or newterm(). slk_init() removes 1 or 2 
	lines from the useable screen, depending on the format selected.

	The line(s) removed from the screen are used as a separate 
	window, in which SLKs are displayed.

	slk_init() requires a single parameter which describes the 
	format of the SLKs as follows:
 
 		0	3-2-3 format
 		1	4-4 format
 		2	4-4-4 format (ncurses extension)
 		3	4-4-4 format with index line (ncurses extension)
			2 lines used
 		55	5-5 format (pdcurses format)

	The functions slk_refresh(), slk_noutrefresh() and slk_touch() 
	are analagous to refresh(), noutrefresh() and touch() functions.

  Return Value:
	All functions return OK on success and ERR on error.

  Portability				     X/Open    BSD    SYS V
	slk_init				Y	-	Y
	slk_set					Y	-	Y
	slk_refresh				Y	-	Y
	slk_noutrefresh				Y	-	Y
	slk_label				Y	-	Y
	slk_clear				Y	-	Y
	slk_restore				Y	-	Y
	slk_touch				Y	-	Y
	slk_attron				Y	-	Y
	slk_attrset				Y	-	Y
	slk_attroff				Y	-	Y
	slk_attr_on				Y
	slk_attr_set				Y
	slk_attr_off				Y
	slk_wset				Y
	PDC_mouse_in_slk			-	-	-
	PDC_slk_free				-	-	-
	PDC_slk_initialize			-	-	-
	slk_wlabel				-	-	-

**man-end****************************************************************/

#include <stdlib.h>

enum { LABEL_NORMAL = 8, LABEL_EXTENDED = 10, LABEL_NCURSES_EXTENDED = 12 };

static int label_length = 0;
static int labels = 0;
static int label_fmt = 0;
static int label_line = 0;
static bool hidden = FALSE;

static struct SLK {
	chtype	label[32];
	int	len;
	int	format;
	int	start_col;
} *slk = (struct SLK *)NULL;

/* slk_init() is the slk initialization routine.
   This must be called before initscr().

   label_fmt = 0, 1 or 55.
       0 = 3-2-3 format
       1 = 4 - 4 format
       2 = 4-4-4 format	(ncurses extension for PC 12 function keys)
       3 = 4-4-4 format	(ncurses extension for PC 12 function keys -
	with index line)
      55 = 5 - 5 format	(extended for PC, 10 function keys) */

int slk_init(int fmt)
{
	PDC_LOG(("slk_init() - called\n"));

	if (SP)
		return ERR;

	switch (fmt) 
	{
	case 0:  /* 3 - 2 - 3 */
		labels = LABEL_NORMAL;
		break;

	case 1:   /* 4 - 4 */
		labels = LABEL_NORMAL;
		break;

	case 2:   /* 4 4 4 */
		labels = LABEL_NCURSES_EXTENDED;
		break;

	case 3:   /* 4 4 4  with index */
		labels = LABEL_NCURSES_EXTENDED;
		break;

	case 55:  /* 5 - 5 */
		labels = LABEL_EXTENDED;
		break;

	default:
		return ERR;
	}

	label_fmt = fmt;

	slk = calloc(labels, sizeof(struct SLK));

	if (!slk)
		labels = 0;

	return slk ? OK : ERR;
}

/* draw a single button */

static void _drawone(int num)
{
	int i, col, slen;

	if (hidden)
		return;

	slen = slk[num].len;

	switch (slk[num].format)
	{
	case 0:  /* LEFT */
		col = 0;
		break;

	case 1:  /* CENTER */
		col = (label_length - slen) / 2;

		if (col + slen > label_length)
			--col;
		break;

	default:  /* RIGHT */
		col = label_length - slen;
	}

	wmove(SP->slk_winptr, label_line, slk[num].start_col);

	for (i = 0; i < label_length; ++i)
		waddch(SP->slk_winptr, (i >= col && i < (col + slen)) ?
			slk[num].label[i - col] : ' ');
}

/* redraw each button */

static void _redraw(void)
{
	int i;

	for (i = 0; i < labels; ++i)
		_drawone(i);
}

/* slk_set() Used to set a slk label to a string.

   labnum  = 1 - 8 (or 10) (number of the label)
   label   = string (8 or 7 bytes total), or NULL
   justify = 0 : left, 1 : center, 2 : right  */

int slk_set(int labnum, const char *label, int justify)
{
#ifdef PDC_WIDE
	wchar_t wlabel[32];

	PDC_mbstowcs(wlabel, label, 31);
	return slk_wset(labnum, wlabel, justify);
#else
	PDC_LOG(("slk_set() - called\n"));

	if (labnum < 1 || labnum > labels || justify < 0 || justify > 2)
		return ERR;

	labnum--;

	if (!label || !(*label)) 
	{
		/* Clear the label */

		*slk[labnum].label = 0;
		slk[labnum].format = 0;
		slk[labnum].len = 0;
	}
	else
	{
		int i, j = 0;

		/* Skip leading spaces */

		while (label[j] == ' ')
			j++;

		/* Copy it */

		for (i = 0; i < label_length; i++)
		{
			chtype ch = label[i + j];

			slk[labnum].label[i] = ch;

			if (!ch)
				break;
		}

		/* Drop trailing spaces */

		while ((i + j) && (label[i + j - 1] == ' '))
			i--;

		slk[labnum].label[i] = 0;
		slk[labnum].format = justify;
		slk[labnum].len = i;
	}

	_drawone(labnum);

	return OK;
#endif
}

int slk_refresh(void)
{
	PDC_LOG(("slk_refresh() - called\n"));

	return (slk_noutrefresh() == ERR) ? ERR : doupdate();
}

int slk_noutrefresh(void)
{
	PDC_LOG(("slk_noutrefresh() - called\n"));

	return wnoutrefresh(SP->slk_winptr);
}

char *slk_label(int labnum)
{
	static char temp[33];
#ifdef PDC_WIDE
	wchar_t *wtemp = slk_wlabel(labnum);

	PDC_wcstombs(temp, wtemp, 32);
	temp[32] = '\0';
#else
	chtype *p;
	int i;

	PDC_LOG(("slk_label() - called\n"));

	if (labnum < 1 || labnum > labels)
		return (char *)0;

	for (i = 0, p = slk[labnum - 1].label; *p; i++)
		temp[i] = *p++;

	temp[i] = '\0';
#endif
	return temp;
}

int slk_clear(void)
{
	PDC_LOG(("slk_clear() - called\n"));

	hidden = TRUE;
	werase(SP->slk_winptr);
	return wrefresh(SP->slk_winptr);
}

int slk_restore(void)
{
	PDC_LOG(("slk_restore() - called\n"));

	hidden = FALSE;
	_redraw();
	return wrefresh(SP->slk_winptr);
}

int slk_touch(void)
{
	PDC_LOG(("slk_touch() - called\n"));

	return touchwin(SP->slk_winptr);
}

int slk_attron(const chtype attrs)
{
	int rc;

	PDC_LOG(("slk_attron() - called\n"));

	rc = wattron(SP->slk_winptr, attrs);
	_redraw();

	return rc;
}

int slk_attr_on(const attr_t attrs, void *opts)
{
	PDC_LOG(("slk_attr_on() - called\n"));

	return slk_attron(attrs);
}

int slk_attroff(const chtype attrs)
{
	int rc;

	PDC_LOG(("slk_attroff() - called\n"));

	rc = wattroff(SP->slk_winptr, attrs);
	_redraw();

	return rc;
}

int slk_attr_off(const attr_t attrs, void *opts)
{
	PDC_LOG(("slk_attr_off() - called\n"));

	return slk_attroff(attrs);
}

int slk_attrset(const chtype attrs)
{
	int rc;

	PDC_LOG(("slk_attrset() - called\n"));

	rc = wattrset(SP->slk_winptr, attrs);
	_redraw();

	return rc;
}

int slk_color(short color_pair)
{
	int rc;

	PDC_LOG(("slk_color() - called\n"));

	rc = wcolor_set(SP->slk_winptr, color_pair, NULL);
	_redraw();

	return rc;
}

int slk_attr_set(const attr_t attrs, short color_pair, void *opts)
{
	PDC_LOG(("slk_attr_set() - called\n"));

	return slk_attrset(attrs | COLOR_PAIR(color_pair));
}

static void _slk_calc(void)
{
	int i, center, col = 0;
	label_length = COLS / labels;

	if (label_length > 31)
		label_length = 31;

	switch (label_fmt)
	{
	case 0:     /* 3 - 2 - 3 F-Key layout */

		--label_length;

		slk[0].start_col = col;
		slk[1].start_col = (col += label_length);
		slk[2].start_col = (col += label_length);

		center = COLS / 2;

		slk[3].start_col = center - label_length + 1;
		slk[4].start_col = center + 1;

		col = COLS - (label_length * 3) + 1;

		slk[5].start_col = col;
		slk[6].start_col = (col += label_length);
		slk[7].start_col = (col += label_length);
		break;

	case 1:     /* 4 - 4 F-Key layout */

		for (i = 0; i < 8; i++)
		{
			slk[i].start_col = col;
			col += label_length;

			if (i == 3)
				col = COLS - (label_length * 4) + 1; 
		}

		break;

	case 2:     /* 4 4 4 F-Key layout */
	case 3:     /* 4 4 4 F-Key layout with index */

		for (i = 0; i < 4; i++)
		{
			slk[i].start_col = col;
			col += label_length;
		}

		center = COLS/2;

		slk[4].start_col = center - (label_length * 2) + 1;
		slk[5].start_col = center - label_length - 1;
		slk[6].start_col = center + 1;
		slk[7].start_col = center + label_length + 1;

		col = COLS - (label_length * 4) + 1;

		for (i = 8; i < 12; i++)
		{
			slk[i].start_col = col;
			col += label_length;
		}

		break;

	default:    /* 5 - 5 F-Key layout */

		for (i = 0; i < 10; i++)
		{
			slk[i].start_col = col;
			col += label_length;

			if (i == 4)
				col = COLS - (label_length * 5) + 1;
		}
	}

	--label_length;

	/* make sure labels are all in window */

	_redraw();
}

void PDC_slk_initialize(void)
{
	if (slk)
	{
		if (label_fmt == 3)
		{
			SP->slklines = 2;
			label_line = 1;
		}
		else
			SP->slklines = 1;

		if (!SP->slk_winptr)
		{
			if ((SP->slk_winptr = newwin(SP->slklines, COLS, 
			     LINES - SP->slklines, 0)) == (WINDOW *)0)
				return;

			wattrset(SP->slk_winptr, A_REVERSE);
		}

		_slk_calc();

		/* if we have an index line, display it now */

		if (label_fmt == 3)
		{
			chtype save_attr;
			int i;

			save_attr = SP->slk_winptr->_attrs;
			wattrset(SP->slk_winptr, A_NORMAL);
			wmove(SP->slk_winptr, 0, 0);
			whline(SP->slk_winptr, 0, COLS);

			for (i = 0; i < labels; i++)
				mvwprintw(SP->slk_winptr, 0, 
					slk[i].start_col, "F%d", i + 1);

			SP->slk_winptr->_attrs = save_attr;
		}

		touchwin(SP->slk_winptr);
	}
}

void PDC_slk_free(void)
{
	if (slk)
	{
		if (SP->slk_winptr)
		{
			delwin(SP->slk_winptr);
			SP->slk_winptr = (WINDOW *)NULL;
		}

		free(slk);
		slk = (struct SLK *)NULL;

		label_length = 0;
		labels = 0;
		label_fmt = 0;
		label_line = 0;
		hidden = FALSE;
	}
}

int PDC_mouse_in_slk(int y, int x)
{
	int i;

	PDC_LOG(("PDC_mouse_in_slk() - called: y->%d x->%d\n", y, x));

	/* If the line on which the mouse was clicked is NOT the last 
	   line of the screen, we are not interested in it. */

	if (!slk || !SP->slk_winptr ||
	   (y != SP->slk_winptr->_begy + label_line))
		return 0;

	for (i = 0; i < labels; i++)
		if (x >= slk[i].start_col &&
		    x < (slk[i].start_col + label_length))
			return i + 1;

	return 0;
}

#ifdef PDC_WIDE
int slk_wset(int labnum, const wchar_t *label, int justify)
{
	PDC_LOG(("slk_wset() - called\n"));

	if (labnum < 1 || labnum > labels || justify < 0 || justify > 2)
		return ERR;

	labnum--;

	if (!label || !(*label)) 
	{
		/* Clear the label */

		*slk[labnum].label = 0;
		slk[labnum].format = 0;
		slk[labnum].len = 0;
	}
	else
	{
		int i, j = 0;

		/* Skip leading spaces */

		while (label[j] == L' ')
			j++;

		/* Copy it */

		for (i = 0; i < label_length; i++)
		{
			chtype ch = label[i + j];

			slk[labnum].label[i] = ch;

			if (!ch)
				break;
		}

		/* Drop trailing spaces */

		while ((i + j) && (label[i + j - 1] == L' '))
			i--;

		slk[labnum].label[i] = 0;
		slk[labnum].format = justify;
		slk[labnum].len = i;
	}

	_drawone(labnum);

	return OK;
}

wchar_t *slk_wlabel(int labnum)
{
	static wchar_t temp[33];
	chtype *p;
	int i;

	PDC_LOG(("slk_wlabel() - called\n"));

	if (labnum < 1 || labnum > labels)
		return (wchar_t *)0;

	for (i = 0, p = slk[labnum - 1].label; *p; i++)
		temp[i] = *p++;

	temp[i] = '\0';

	return temp;
}
#endif