/*
 * 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 (c) 1988 AT&T */
/*    All Rights Reserved   */


/*
 *      Copyright (c) 1997, by Sun Microsystems, Inc.
 *      All rights reserved.
 */

/*LINTLIBRARY*/

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

/*
 *      Clear the space occupied by a multicolumn character
 */

int
_mbclrch(WINDOW *win, int y, int x)
{
        chtype  *wcp, *ep, *wp, wc;

        /* ASSERT(_scrmax > 1); */

        wcp = win->_y[y];
        wp = wcp + x;

        /* compute the bounds for the character */
        if (ISCBIT(*wp)) {
                for (; wp >= wcp; --wp)
                        if (!ISCBIT(*wp))
                                break;
                if (wp < wcp)
                        return (ERR);
        }
        wc = RBYTE(*wp);
        ep = wp + _curs_scrwidth[TYPE(wc)];
        if (ep > wcp + win->_maxx)
                return (ERR);

        /* update the change structure */
        /*LINTED*/
        if ((x = (int)(wp - wcp)) < win->_firstch[y])
                /*LINTED*/
                win->_firstch[y] = (short)x;
        /*LINTED*/
        if ((x = (int)(ep - wcp) - 1) > win->_lastch[y])
                /*LINTED*/
                win->_lastch[y] = (short)x;

        /* clear the character */
        for (; wp < ep; ++wp)
                *wp = win->_bkgd;
        return (OK);
}



/*
 *      Make sure the window cursor point to a valid place.
 *      If win->_insmode or isedge, the cursor has to
 *      point to the start of a whole character; otherwise, the
 *      cursor has to point to a part of a whole character.
 */

int
_mbvalid(WINDOW *win)
{
        chtype  *wp, *wcp, *ecp, wc;
        int             x;
        bool    isedge;

        /* ASSERT(_scrmax > 1); */

        x = win->_curx;
        wcp = win->_y[win->_cury];
        wp = wcp + x;
        if (!ISMBIT(*wp))
                return (OK);

        ecp = wcp + win->_maxx;
        isedge = FALSE;

        /* make wp points to the start column of a mb-character */
        if (ISCBIT(*wp)) {
                for (; wp >= wcp; --wp)
                        if (!ISCBIT(*wp))
                                break;
                if (wp < wcp) {
                        for (wp = wcp + x + 1; wp < ecp; ++wp)
                                if (!ISCBIT(*wp))
                                        break;
                        if (wp >= ecp)
                                return (ERR);
                        isedge = TRUE;
                }
        }

        /* make sure that wp points to a whole character */
        wc = RBYTE(*wp);
        if (wp + _curs_scrwidth[TYPE(wc)] > ecp) {
                for (wp -= 1; wp >= wcp; --wp)
                        if (!ISCBIT(*wp))
                                break;
                if (wp < wcp)
                        return (ERR);
                isedge = TRUE;
        }

        if (isedge || win->_insmode)
                /*LINTED*/
                win->_curx = (short)(wp-wcp);
        return (OK);
}



/*
 *      Add/insert multi-byte characters
 */

int
_mbaddch(WINDOW *win, chtype a, chtype c)
{
        int             n, x, y, nc, m, len, nbyte, ty;
        chtype          *wcp, wc;
        char            *wch, rc[2];

        /* ASSERT(_mbtrue); */

        /* decode the character into a sequence of bytes */
        nc = 0;
        if (ISCBIT(c))
                /*LINTED*/
                rc[nc++] = (char)(LBYTE(c)|MBIT);
        if (ISMBIT(c))
                /*LINTED*/
                rc[nc++] = (char)RBYTE(c);

        a |= win->_attrs;

        /* add the sequence to the image */
        for (n = 0; n < nc; ++n) {
                wc = RBYTE(rc[n]);
                ty = TYPE(wc);
                wch = win->_waitc;

                /* first byte of a multi-byte character */
                if (ty > 0 || win->_nbyte < 0) {
                        /*LINTED*/
                        wch[0] = (char)wc;
                        win->_nbyte = cswidth[ty] + (ty == 0 ? 0 : 1);
                        win->_index = 1;
                } else {
                /* non-first byte */
                        /*LINTED*/
                        wch[win->_index] = (char)wc;
                        win->_index += 1;
                }

                /* if character is not ready to process */
                if (win->_index < win->_nbyte)
                        continue;

                /* begin processing the character */
                nbyte = win->_nbyte;
                win->_nbyte = -1;
                wc = RBYTE(wch[0]);
                len = _curs_scrwidth[TYPE(wc)];

                /* window too small or char cannot be stored */
                if (len > win->_maxx || 2*len < nbyte)
                        continue;

                /* if the character won't fit into the line */
                if ((win->_curx + len) > win->_maxx &&
                    (win->_insmode || waddch(win, '\n') == ERR))
                        continue;

                y = win->_cury;
                x = win->_curx;
                wcp = win->_y[y] + x;

                if (win->_insmode) {
                        /* perform the right shift */
                        if (_mbinsshift(win, len) == ERR)
                                continue;
                } else if (_scrmax > 1) {
                        /* clear any multi-byte char about to be overwritten */
                        for (m = 0; m < len; ++m)
                                if (ISMBIT(wcp[m]) &&
                                    _mbclrch(win, y, x + m) == ERR)
                                        break;
                        if (m < len)
                                continue;
                }

                /* pack two bytes at a time */
                for (m = nbyte/2; m > 0; m -= 1, wch += 2)
                        *wcp++ = _CHAR((RBYTE(wch[1]) << 8) |
                            RBYTE(wch[0])) | CBIT | a;

                /* do the remaining byte if any */
                if ((nbyte%2) != 0)
                        *wcp++ = RBYTE(wch[0]) | CBIT | a;

                /* fill-in for remaining display columns */
                for (m = (nbyte / 2) + (nbyte % 2); m < len; ++m)
                        *wcp++ = (CBIT|MBIT) | a;

                /* the first column has Continue BIT off */
                win->_y[y][x] &= ~CBIT;

                if (win->_insmode == FALSE) {
                        if (x < win->_firstch[y])
                                /*LINTED*/
                                win->_firstch[y] = (short)x;
                        if ((x += len-1) >= win->_maxx)
                                x = win->_maxx-1;
                        if (x > win->_lastch[y])
                                /*LINTED*/
                                win->_lastch[y] = (short)x;

                        if ((win->_curx += len) >= win->_maxx) {
                                if (y >= (win->_maxy-1) || y == win->_bmarg) {
                                        win->_curx = win->_maxx-1;
                                        if (wscrl(win, 1) == ERR)
                                                continue;
                                } else {
                                        win->_cury += 1;
                                        win->_curx = 0;
                                }
                        }
                }
        }

        return (OK);
}