/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1988 AT&T	*/
/*	  All Rights Reserved	*/

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*LINTLIBRARY*/

#include	<sys/types.h>
#include	<stdlib.h>
#include	"curses_inc.h"

/*
 * Initialize usage of soft labels
 * This routine should be called before each call of newscreen
 * or initscr to initialize for the next terminal.
 *
 * ng:	number of groupings. If gp is NULL, it denotes one
 * 	of two default groupings:
 * 	0:	- - -   - -   - - -
 * 	1:      - - - -     - - - -
 * gp:	groupings.
 */

static	void	_init_slk_func(void);
static  int	_slk_setpos(int, short *);
static	int	_ngroups, _groups[LABMAX];

int
slk_start(int ng, int *gp)
{
	int	i = 0, j = 0;

	if (gp == NULL) {
		switch (ng) {
			case 2 :
				_ngroups = 2;
				_groups[0] = 4;
				_groups[1] = 4;
				break;

			case 3 :
no_format :
				_ngroups = 3;
				_groups[0] = 3;
				_groups[1] = 2;
				_groups[2] = 3;
				break;

			default :
				if (label_format) {
				    int		k;
				    char	ch1[3], *ch = label_format;

					/*CONSTCOND*/
					while (TRUE) {
						if ((*ch == ',') ||
						    (*ch == '\0')) {
							ch1[i] = '\0';
							if ((k = atoi(ch1)) <=
							    0)
								goto err;
							_groups[j++] = k;
							i = 0;
							if (*ch == '\0') {
								break;
							}
						} else
							ch1[i++] = *ch++;
					}
				} else
					goto no_format;
				break;
		}
	} else {
		for (; i < ng; i++) {
			if ((j += gp[i]) > LABMAX)
err :
				return (ERR);
			_groups[i] = gp[i];
		}
		_ngroups = ng;
	}

	/* signal newscreen() */
	_slk_init = _init_slk_func;
	return (OK);
}

static	void
_init_slk_func(void)
{
	int	i, len, num;
	SLK_MAP	*slk;
	char	*cp, *ep;
	WINDOW	*win;

	/* clear this out to ready for next time */
	_slk_init = NULL;

	/* get space for slk structure */
	if ((slk = (SLK_MAP *) malloc(sizeof (SLK_MAP))) == NULL) {
		curs_errno = CURS_BAD_MALLOC;
#ifdef	DEBUG
		strcpy(curs_parm_err, "_init_slk_func");
#endif	/* DEBUG */
		return;
	}

	/* compute actual number of labels */
	num = 0;
	for (i = 0; i < _ngroups; i++)
		num += _groups[i];

	/* max label length */
	if (plab_norm && (label_height * label_width >= LABLEN) &&
	    (num_labels >= num)) {
		win = NULL;
		goto next;
	} else {
		if ((win = newwin(1, COLS, LINES - 1, 0)) == NULL)
			goto err;
		win->_leave = TRUE;
		(void) wattrset(win, A_REVERSE | A_DIM);

		/* remove one line from the screen */
		LINES = --SP->lsize;
		if ((len = (COLS - 1) / (num + 1)) > LABLEN) {
next :
			len = LABLEN;
		}
	}

	/* positions to place labels */
	if (len <= 0 || num <= 0 || (_slk_setpos(len, slk->_labx) == ERR)) {
		if (win != NULL)
			(void) delwin(win);
err :
		free(slk);
	} else {
		/* LINTED */
		slk->_num = (short) num;
		/* LINTED */
		slk->_len = (short) len;

		for (i = 0; i < num; ++i) {
			cp = slk->_ldis[i];
			ep = cp + len;
			for (; cp < ep; ++cp)
				*cp = ' ';
			*ep = '\0';
			slk->_lval[i][0] = '\0';
			slk->_lch[i] = TRUE;
		}

		slk->_changed = TRUE;
		slk->_win = win;

		_do_slk_ref = _slk_update;
		_do_slk_tch = slk_touch;
		_do_slk_noref = slk_noutrefresh;

		SP->slk = slk;
	}
}


/*
 * Compute placements of labels. The general idea is to spread
 * the groups out evenly. This routine is designed for the day
 * when > 8 labels and other kinds of groupings may be desired.
 *
 * The main assumption behind the algorithm is that the total
 * # of labels in all the groups is <= LABMAX.
 *
 * len: length of a label
 * labx: to return the coords of the labels.
 */

static int
_slk_setpos(int len, short *labx)
{
	int	i, k, n, spread, left, begadd;
	int	grpx[LABMAX];

	/* compute starting coords for each group */
	grpx[0] = 0;
	if (_ngroups > 1) {
		/* spacing between groups */
		for (i = 0, n = 0; i < _ngroups; ++i)
			n += _groups[i] * (len + 1) - 1;
		if ((spread = (COLS - (n + 1))/(_ngroups - 1)) <= 0)
			return (ERR);
		left = (COLS-(n + 1)) % (_ngroups - 1);
		begadd = (_ngroups / 2) - (left / 2);

		/* coords of groups */
		for (i = 1; i < _ngroups; ++i) {
			grpx[i] = grpx[i - 1] + (_groups[i - 1] *
			    (len + 1) - 1) + spread;
			if (left > 0 && i > begadd) {
				grpx[i]++;
				left--;
			}
		}
	}

	/* now set coords of each label */
	n = 0;
	for (i = 0; i < _ngroups; ++i)
		for (k = 0; k < _groups[i]; ++k)
			labx[n++] = grpx[i] + k * (len + 1);
	return (OK);
}