Subversion Repositories Kolibri OS

/* PDCurses */

#include 

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

attr

----

### Synopsis

    int attroff(chtype attrs);

    int wattroff(WINDOW *win, chtype attrs);

    int attron(chtype attrs);

    int wattron(WINDOW *win, chtype attrs);

    int attrset(chtype attrs);

    int wattrset(WINDOW *win, chtype attrs);

    int standend(void);

    int wstandend(WINDOW *win);

    int standout(void);

    int wstandout(WINDOW *win);

    int color_set(short color_pair, void *opts);

    int wcolor_set(WINDOW *win, short color_pair, void *opts);

    int attr_get(attr_t *attrs, short *color_pair, void *opts);

    int attr_off(attr_t attrs, void *opts);

    int attr_on(attr_t attrs, void *opts);

    int attr_set(attr_t attrs, short color_pair, void *opts);

    int wattr_get(WINDOW *win, attr_t *attrs, short *color_pair,

                  void *opts);

    int wattr_off(WINDOW *win, attr_t attrs, void *opts);

    int wattr_on(WINDOW *win, attr_t attrs, void *opts);

    int wattr_set(WINDOW *win, attr_t attrs, short color_pair,

                  void *opts);

    int chgat(int n, attr_t attr, short color, const void *opts);

    int mvchgat(int y, int x, int n, attr_t attr, short color,

                const void *opts);

    int mvwchgat(WINDOW *win, int y, int x, int n, attr_t attr,

                 short color, const void *opts);

    int wchgat(WINDOW *win, int n, attr_t attr, short color,

               const void *opts);

    chtype getattrs(WINDOW *win);

    int underend(void);

    int wunderend(WINDOW *win);

    int underscore(void);

    int wunderscore(WINDOW *win);

### Description

   These functions manipulate the current attributes and/or colors of

   the named window. These attributes can be any combination of

   A_STANDOUT, A_REVERSE, A_BOLD, A_DIM, A_BLINK, A_UNDERLINE. These

   constants are defined in  and can be combined with the

   bitwise-OR operator (|).

   The current attributes of a window are applied to all chtypes that

   are written into the window with waddch(). Attributes are a property

   of the chtype, and move with the character through any scrolling or

   insert/delete operations.

   wattrset() sets the current attributes of the given window to attrs.

   attrset() is the stdscr version.

   wattroff() turns off the named attributes without affecting any other

   attributes; wattron() turns them on.

   wcolor_set() sets the window color to the value of color_pair. opts

   is unused.

   standout() is the same as attron(A_STANDOUT). standend() is the same

   as attrset(A_NORMAL); that is, it turns off all attributes.

   The attr_* and wattr_* functions are intended for use with the WA_*

   attributes. In PDCurses, these are the same as A_*, and there is no

   difference in bevahior from the chtype-based functions. In all cases,

   opts is unused.

   wattr_get() retrieves the attributes and color pair for the specified

   window.

   wchgat() sets the color pair and attributes for the next n cells on

   the current line of a given window, without changing the existing

   text, or alterting the window's attributes. An n of -1 extends the

   change to the edge of the window. The changes take effect

   immediately. opts is unused.

   wunderscore() turns on the A_UNDERLINE attribute; wunderend() turns

   it off. underscore() and underend() are the stdscr versions.

### Return Value

   All functions return OK on success and ERR on error.

### Portability

                             X/Open  ncurses  NetBSD

    attroff                     Y       Y       Y

    wattroff                    Y       Y       Y

    attron                      Y       Y       Y

    wattron                     Y       Y       Y

    attrset                     Y       Y       Y

    wattrset                    Y       Y       Y

    standend                    Y       Y       Y

    wstandend                   Y       Y       Y

    standout                    Y       Y       Y

    wstandout                   Y       Y       Y

    color_set                   Y       Y       Y

    wcolor_set                  Y       Y       Y

    attr_get                    Y       Y       Y

    wattr_get                   Y       Y       Y

    attr_on                     Y       Y       Y

    wattr_on                    Y       Y       Y

    attr_off                    Y       Y       Y

    wattr_off                   Y       Y       Y

    attr_set                    Y       Y       Y

    wattr_set                   Y       Y       Y

    chgat                       Y       Y       Y

    wchgat                      Y       Y       Y

    mvchgat                     Y       Y       Y

    mvwchgat                    Y       Y       Y

    getattrs                    -       Y       Y

    underend                    -       -       Y

    wunderend                   -       -       Y

    underscore                  -       -       Y

    wunderscore                 -       -       Y

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

int wattroff(WINDOW *win, chtype attrs)

{

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

    if (!win)

        return ERR;

    win->_attrs &= (~attrs & A_ATTRIBUTES);

    return OK;

}

int attroff(chtype attrs)

{

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

    return wattroff(stdscr, attrs);

}

int wattron(WINDOW *win, chtype attrs)

{

    chtype newcolr, oldcolr, newattr, oldattr;

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

    if (!win)

        return ERR;

    if ((win->_attrs & A_COLOR) && (attrs & A_COLOR))

    {

        oldcolr = win->_attrs & A_COLOR;

        oldattr = win->_attrs ^ oldcolr;

        newcolr = attrs & A_COLOR;

        newattr = (attrs & A_ATTRIBUTES) ^ newcolr;

        newattr |= oldattr;

        win->_attrs = newattr | newcolr;

    }

    else

        win->_attrs |= (attrs & A_ATTRIBUTES);

    return OK;

}

int attron(chtype attrs)

{

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

    return wattron(stdscr, attrs);

}

int wattrset(WINDOW *win, chtype attrs)

{

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

    if (!win)

        return ERR;

    win->_attrs = attrs & A_ATTRIBUTES;

    return OK;

}

int attrset(chtype attrs)

{

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

    return wattrset(stdscr, attrs);

}

int standend(void)

{

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

    return wattrset(stdscr, A_NORMAL);

}

int standout(void)

{

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

    return wattrset(stdscr, A_STANDOUT);

}

int wstandend(WINDOW *win)

{

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

    return wattrset(win, A_NORMAL);

}

int wstandout(WINDOW *win)

{

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

    return wattrset(win, A_STANDOUT);

}

chtype getattrs(WINDOW *win)

{

    return win ? win->_attrs : 0;

}

int wcolor_set(WINDOW *win, short color_pair, void *opts)

{

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

    if (!win)

        return ERR;

    win->_attrs = (win->_attrs & ~A_COLOR) | COLOR_PAIR(color_pair);

    return OK;

}

int color_set(short color_pair, void *opts)

{

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

    return wcolor_set(stdscr, color_pair, opts);

}

int wattr_get(WINDOW *win, attr_t *attrs, short *color_pair, void *opts)

{

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

    if (!win)

        return ERR;

    if (attrs)

        *attrs = win->_attrs & (A_ATTRIBUTES & ~A_COLOR);

    if (color_pair)

        *color_pair = PAIR_NUMBER(win->_attrs);

    return OK;

}

int attr_get(attr_t *attrs, short *color_pair, void *opts)

{

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

    return wattr_get(stdscr, attrs, color_pair, opts);

}

int wattr_off(WINDOW *win, attr_t attrs, void *opts)

{

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

    return wattroff(win, attrs);

}

int attr_off(attr_t attrs, void *opts)

{

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

    return wattroff(stdscr, attrs);

}

int wattr_on(WINDOW *win, attr_t attrs, void *opts)

{

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

    return wattron(win, attrs);

}

int attr_on(attr_t attrs, void *opts)

{

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

    return wattron(stdscr, attrs);

}

int wattr_set(WINDOW *win, attr_t attrs, short color_pair, void *opts)

{

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

    if (!win)

        return ERR;

    win->_attrs = (attrs & (A_ATTRIBUTES & ~A_COLOR)) | COLOR_PAIR(color_pair);

    return OK;

}

int attr_set(attr_t attrs, short color_pair, void *opts)

{

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

    return wattr_set(stdscr, attrs, color_pair, opts);

}

int wchgat(WINDOW *win, int n, attr_t attr, short color, const void *opts)

{

    chtype *dest, newattr;

    int startpos, endpos;

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

    if (!win)

        return ERR;

    newattr = (attr & A_ATTRIBUTES) | COLOR_PAIR(color);

    startpos = win->_curx;

    endpos = ((n < 0) ? win->_maxx : min(startpos + n, win->_maxx)) - 1;

    dest = win->_y[win->_cury];

    for (n = startpos; n <= endpos; n++)

        dest[n] = (dest[n] & A_CHARTEXT) | newattr;

    n = win->_cury;

    if (startpos < win->_firstch[n] || win->_firstch[n] == _NO_CHANGE)

        win->_firstch[n] = startpos;

    if (endpos > win->_lastch[n])

        win->_lastch[n] = endpos;

    PDC_sync(win);

    return OK;

}

int chgat(int n, attr_t attr, short color, const void *opts)

{

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

    return wchgat(stdscr, n, attr, color, opts);

}

int mvchgat(int y, int x, int n, attr_t attr, short color, const void *opts)

{

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

    if (move(y, x) == ERR)

        return ERR;

    return wchgat(stdscr, n, attr, color, opts);

}

int mvwchgat(WINDOW *win, int y, int x, int n, attr_t attr, short color,

             const void *opts)

{

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

    if (wmove(win, y, x) == ERR)

        return ERR;

    return wchgat(win, n, attr, color, opts);

}

int underend(void)

{

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

    return wattroff(stdscr, A_UNDERLINE);

}

int wunderend(WINDOW *win)

{

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

    return wattroff(win, A_UNDERLINE);

}

int underscore(void)

{

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

    return wattron(stdscr, A_UNDERLINE);

}

int wunderscore(WINDOW *win)

{

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

    return wattron(win, A_UNDERLINE);

}