URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [services/] [curses/] [pdcurses/] [current/] [src/] [pdcurses/] [slk.c] - Blame information for rev 786

Details | Compare with Previous | View Log


/* Public Domain Curses */
 
#include <curspriv.h>
 
RCSID("$Id: slk.c,v 1.1 2009/05/10 08:29:53 jld 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:
 
 
                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)
 
        slk_refresh(), slk_noutrefresh() and slk_touch() are analogous
        to refresh(), noutrefresh() and touch().
 
  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.
 
       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);
#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)) )
                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

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [services/] [curses/] [pdcurses/] [current/] [src/] [pdcurses/] [slk.c] - Blame information for rev 786

Line No.	Rev	Author	Line
1	786	skrzyp	`/* Public Domain Curses */`
2
3			`#include <curspriv.h>`
4
5			`RCSID("$Id: slk.c,v 1.1 2009/05/10 08:29:53 jld Exp $")`
6
7			`/man-start*************************************************************`
8
9			`Name: slk`
10
11			`Synopsis:`
12			`int slk_init(int fmt);`
13			`int slk_set(int labnum, const char *label, int justify);`
14			`int slk_refresh(void);`
15			`int slk_noutrefresh(void);`
16			`char *slk_label(int labnum);`
17			`int slk_clear(void);`
18			`int slk_restore(void);`
19			`int slk_touch(void);`
20			`int slk_attron(const chtype attrs);`
21			`int slk_attr_on(const attr_t attrs, void *opts);`
22			`int slk_attrset(const chtype attrs);`
23			`int slk_attr_set(const attr_t attrs, short color_pair, void *opts);`
24			`int slk_attroff(const chtype attrs);`
25			`int slk_attr_off(const attr_t attrs, void *opts);`
26			`int slk_color(short color_pair);`
27
28			`int slk_wset(int labnum, const wchar_t *label, int justify);`
29
30			`int PDC_mouse_in_slk(int y, int x);`
31			`void PDC_slk_free(void);`
32			`void PDC_slk_initialize(void);`
33
34			`wchar_t *slk_wlabel(int labnum)`
35
36			`Description:`
37			`These functions manipulate a window that contain Soft Label Keys`
38			`(SLK). To use the SLK functions, a call to slk_init() must be`
39			`made BEFORE initscr() or newterm(). slk_init() removes 1 or 2`
40			`lines from the useable screen, depending on the format selected.`
41
42			`The line(s) removed from the screen are used as a separate`
43			`window, in which SLKs are displayed.`
44
45			`slk_init() requires a single parameter which describes the`
46			`format of the SLKs as follows:`
47
48
49			`1 4-4 format`
50			`2 4-4-4 format (ncurses extension)`
51			`3 4-4-4 format with index line (ncurses extension)`
52			`2 lines used`
53			`55 5-5 format (pdcurses format)`
54
55			`slk_refresh(), slk_noutrefresh() and slk_touch() are analogous`
56			`to refresh(), noutrefresh() and touch().`
57
58			`Return Value:`
59			`All functions return OK on success and ERR on error.`
60
61			`Portability X/Open BSD SYS V`
62			`slk_init Y - Y`
63			`slk_set Y - Y`
64			`slk_refresh Y - Y`
65			`slk_noutrefresh Y - Y`
66			`slk_label Y - Y`
67			`slk_clear Y - Y`
68			`slk_restore Y - Y`
69			`slk_touch Y - Y`
70			`slk_attron Y - Y`
71			`slk_attrset Y - Y`
72			`slk_attroff Y - Y`
73			`slk_attr_on Y`
74			`slk_attr_set Y`
75			`slk_attr_off Y`
76			`slk_wset Y`
77			`PDC_mouse_in_slk - - -`
78			`PDC_slk_free - - -`
79			`PDC_slk_initialize - - -`
80			`slk_wlabel - - -`
81
82			`man-end**************************************************************/`
83
84			`#include <stdlib.h>`
85
86			`enum { LABEL_NORMAL = 8, LABEL_EXTENDED = 10, LABEL_NCURSES_EXTENDED = 12 };`
87
88			`static int label_length = 0;`
89			`static int labels = 0;`
90			`static int label_fmt = 0;`
91			`static int label_line = 0;`
92			`static bool hidden = FALSE;`
93
94			`static struct SLK {`
95			`chtype label[32];`
96			`int len;`
97			`int format;`
98			`int start_col;`
99			`} slk = (struct SLK )NULL;`
100
101			`/* slk_init() is the slk initialization routine.`
102			`This must be called before initscr().`
103
104			`label_fmt = 0, 1 or 55.`
105
106			`1 = 4 - 4 format`
107			`2 = 4-4-4 format (ncurses extension for PC 12 function keys)`
108			`3 = 4-4-4 format (ncurses extension for PC 12 function keys -`
109			`with index line)`
110			`55 = 5 - 5 format (extended for PC, 10 function keys) */`
111
112			`int slk_init(int fmt)`
113			`{`
114			`PDC_LOG(("slk_init() - called\n"));`
115
116			`if (SP)`
117			`return ERR;`
118
119			`switch (fmt)`
120			`{`
121			`case 0: /* 3 - 2 - 3 */`
122			`labels = LABEL_NORMAL;`
123			`break;`
124
125			`case 1: /* 4 - 4 */`
126			`labels = LABEL_NORMAL;`
127			`break;`
128
129			`case 2: /* 4 4 4 */`
130			`labels = LABEL_NCURSES_EXTENDED;`
131			`break;`
132
133			`case 3: /* 4 4 4 with index */`
134			`labels = LABEL_NCURSES_EXTENDED;`
135			`break;`
136
137			`case 55: /* 5 - 5 */`
138			`labels = LABEL_EXTENDED;`
139			`break;`
140
141			`default:`
142			`return ERR;`
143			`}`
144
145			`label_fmt = fmt;`
146
147			`slk = calloc(labels, sizeof(struct SLK));`
148
149			`if (!slk)`
150			`labels = 0;`
151
152			`return slk ? OK : ERR;`
153			`}`
154
155			`/* draw a single button */`
156
157			`static void _drawone(int num)`
158			`{`
159			`int i, col, slen;`
160
161			`if (hidden)`
162			`return;`
163
164			`slen = slk[num].len;`
165
166			`switch (slk[num].format)`
167			`{`
168			`case 0: /* LEFT */`
169			`col = 0;`
170			`break;`
171
172			`case 1: /* CENTER */`
173			`col = (label_length - slen) / 2;`
174
175			`if (col + slen > label_length)`
176			`--col;`
177			`break;`
178
179			`default: /* RIGHT */`
180			`col = label_length - slen;`
181			`}`
182
183			`wmove(SP->slk_winptr, label_line, slk[num].start_col);`
184
185			`for (i = 0; i < label_length; ++i)`
186			`waddch(SP->slk_winptr, (i >= col && i < (col + slen)) ?`
187			`slk[num].label[i - col] : ' ');`
188			`}`
189
190			`/* redraw each button */`
191
192			`static void _redraw(void)`
193			`{`
194			`int i;`
195
196			`for (i = 0; i < labels; ++i)`
197			`_drawone(i);`
198			`}`
199
200			`/* slk_set() Used to set a slk label to a string.`
201
202			`labnum = 1 - 8 (or 10) (number of the label)`
203			`label = string (8 or 7 bytes total), or NULL`
204			`justify = 0 : left, 1 : center, 2 : right */`
205
206			`int slk_set(int labnum, const char *label, int justify)`
207			`{`
208			`#ifdef PDC_WIDE`
209			`wchar_t wlabel[32];`
210
211			`PDC_mbstowcs(wlabel, label, 31);`
212			`return slk_wset(labnum, wlabel, justify);`
213			`#else`
214			`PDC_LOG(("slk_set() - called\n"));`
215
216			`if (labnum < 1 \|\| labnum > labels \|\| justify < 0 \|\| justify > 2)`
217			`return ERR;`
218
219			`labnum--;`
220
221			`if (!label \|\| !(*label))`
222			`{`
223			`/* Clear the label */`
224
225			`*slk[labnum].label = 0;`
226			`slk[labnum].format = 0;`
227			`slk[labnum].len = 0;`
228			`}`
229			`else`
230			`{`
231			`int i, j = 0;`
232
233			`/* Skip leading spaces */`
234
235			`while (label[j] == ' ')`
236			`j++;`
237
238			`/* Copy it */`
239
240			`for (i = 0; i < label_length; i++)`
241			`{`
242			`chtype ch = label[i + j];`
243
244			`slk[labnum].label[i] = ch;`
245
246			`if (!ch)`
247			`break;`
248			`}`
249
250			`/* Drop trailing spaces */`
251
252			`while ((i + j) && (label[i + j - 1] == ' '))`
253			`i--;`
254
255			`slk[labnum].label[i] = 0;`
256			`slk[labnum].format = justify;`
257			`slk[labnum].len = i;`
258			`}`
259
260			`_drawone(labnum);`
261
262			`return OK;`
263			`#endif`
264			`}`
265
266			`int slk_refresh(void)`
267			`{`
268			`PDC_LOG(("slk_refresh() - called\n"));`
269
270			`return (slk_noutrefresh() == ERR) ? ERR : doupdate();`
271			`}`
272
273			`int slk_noutrefresh(void)`
274			`{`
275			`PDC_LOG(("slk_noutrefresh() - called\n"));`
276
277			`return wnoutrefresh(SP->slk_winptr);`
278			`}`
279
280			`char *slk_label(int labnum)`
281			`{`
282			`static char temp[33];`
283			`#ifdef PDC_WIDE`
284			`wchar_t *wtemp = slk_wlabel(labnum);`
285
286			`PDC_wcstombs(temp, wtemp, 32);`
287			`#else`
288			`chtype *p;`
289			`int i;`
290
291			`PDC_LOG(("slk_label() - called\n"));`
292
293			`if (labnum < 1 \|\| labnum > labels)`
294			`return (char *)0;`
295
296			`for (i = 0, p = slk[labnum - 1].label; *p; i++)`
297			`temp[i] = *p++;`
298
299			`temp[i] = '\0';`
300			`#endif`
301			`return temp;`
302			`}`
303
304			`int slk_clear(void)`
305			`{`
306			`PDC_LOG(("slk_clear() - called\n"));`
307
308			`hidden = TRUE;`
309			`werase(SP->slk_winptr);`
310			`return wrefresh(SP->slk_winptr);`
311			`}`
312
313			`int slk_restore(void)`
314			`{`
315			`PDC_LOG(("slk_restore() - called\n"));`
316
317			`hidden = FALSE;`
318			`_redraw();`
319			`return wrefresh(SP->slk_winptr);`
320			`}`
321
322			`int slk_touch(void)`
323			`{`
324			`PDC_LOG(("slk_touch() - called\n"));`
325
326			`return touchwin(SP->slk_winptr);`
327			`}`
328
329			`int slk_attron(const chtype attrs)`
330			`{`
331			`int rc;`
332
333			`PDC_LOG(("slk_attron() - called\n"));`
334
335			`rc = wattron(SP->slk_winptr, attrs);`
336			`_redraw();`
337
338			`return rc;`
339			`}`
340
341			`int slk_attr_on(const attr_t attrs, void *opts)`
342			`{`
343			`PDC_LOG(("slk_attr_on() - called\n"));`
344
345			`return slk_attron(attrs);`
346			`}`
347
348			`int slk_attroff(const chtype attrs)`
349			`{`
350			`int rc;`
351
352			`PDC_LOG(("slk_attroff() - called\n"));`
353
354			`rc = wattroff(SP->slk_winptr, attrs);`
355			`_redraw();`
356
357			`return rc;`
358			`}`
359
360			`int slk_attr_off(const attr_t attrs, void *opts)`
361			`{`
362			`PDC_LOG(("slk_attr_off() - called\n"));`
363
364			`return slk_attroff(attrs);`
365			`}`
366
367			`int slk_attrset(const chtype attrs)`
368			`{`
369			`int rc;`
370
371			`PDC_LOG(("slk_attrset() - called\n"));`
372
373			`rc = wattrset(SP->slk_winptr, attrs);`
374			`_redraw();`
375
376			`return rc;`
377			`}`
378
379			`int slk_color(short color_pair)`
380			`{`
381			`int rc;`
382
383			`PDC_LOG(("slk_color() - called\n"));`
384
385			`rc = wcolor_set(SP->slk_winptr, color_pair, NULL);`
386			`_redraw();`
387
388			`return rc;`
389			`}`
390
391			`int slk_attr_set(const attr_t attrs, short color_pair, void *opts)`
392			`{`
393			`PDC_LOG(("slk_attr_set() - called\n"));`
394
395			`return slk_attrset(attrs \| COLOR_PAIR(color_pair));`
396			`}`
397
398			`static void _slk_calc(void)`
399			`{`
400			`int i, center, col = 0;`
401			`label_length = COLS / labels;`
402
403			`if (label_length > 31)`
404			`label_length = 31;`
405
406			`switch (label_fmt)`
407			`{`
408			`case 0: /* 3 - 2 - 3 F-Key layout */`
409
410			`--label_length;`
411
412			`slk[0].start_col = col;`
413			`slk[1].start_col = (col += label_length);`
414			`slk[2].start_col = (col += label_length);`
415
416			`center = COLS / 2;`
417
418			`slk[3].start_col = center - label_length + 1;`
419			`slk[4].start_col = center + 1;`
420
421			`col = COLS - (label_length * 3) + 1;`
422
423			`slk[5].start_col = col;`
424			`slk[6].start_col = (col += label_length);`
425			`slk[7].start_col = (col += label_length);`
426			`break;`
427
428			`case 1: /* 4 - 4 F-Key layout */`
429
430			`for (i = 0; i < 8; i++)`
431			`{`
432			`slk[i].start_col = col;`
433			`col += label_length;`
434
435			`if (i == 3)`
436			`col = COLS - (label_length * 4) + 1;`
437			`}`
438
439			`break;`
440
441			`case 2: /* 4 4 4 F-Key layout */`
442			`case 3: /* 4 4 4 F-Key layout with index */`
443
444			`for (i = 0; i < 4; i++)`
445			`{`
446			`slk[i].start_col = col;`
447			`col += label_length;`
448			`}`
449
450			`center = COLS/2;`
451
452			`slk[4].start_col = center - (label_length * 2) + 1;`
453			`slk[5].start_col = center - label_length - 1;`
454			`slk[6].start_col = center + 1;`
455			`slk[7].start_col = center + label_length + 1;`
456
457			`col = COLS - (label_length * 4) + 1;`
458
459			`for (i = 8; i < 12; i++)`
460			`{`
461			`slk[i].start_col = col;`
462			`col += label_length;`
463			`}`
464
465			`break;`
466
467			`default: /* 5 - 5 F-Key layout */`
468
469			`for (i = 0; i < 10; i++)`
470			`{`
471			`slk[i].start_col = col;`
472			`col += label_length;`
473
474			`if (i == 4)`
475			`col = COLS - (label_length * 5) + 1;`
476			`}`
477			`}`
478
479			`--label_length;`
480
481			`/* make sure labels are all in window */`
482
483			`_redraw();`
484			`}`
485
486			`void PDC_slk_initialize(void)`
487			`{`
488			`if (slk)`
489			`{`
490			`if (label_fmt == 3)`
491			`{`
492			`SP->slklines = 2;`
493			`label_line = 1;`
494			`}`
495			`else`
496			`SP->slklines = 1;`
497
498			`if (!SP->slk_winptr)`
499			`{`
500			`if ( !(SP->slk_winptr = newwin(SP->slklines, COLS,`
501			`LINES - SP->slklines, 0)) )`
502			`return;`
503
504			`wattrset(SP->slk_winptr, A_REVERSE);`
505			`}`
506
507			`_slk_calc();`
508
509			`/* if we have an index line, display it now */`
510
511			`if (label_fmt == 3)`
512			`{`
513			`chtype save_attr;`
514			`int i;`
515
516			`save_attr = SP->slk_winptr->_attrs;`
517			`wattrset(SP->slk_winptr, A_NORMAL);`
518			`wmove(SP->slk_winptr, 0, 0);`
519			`whline(SP->slk_winptr, 0, COLS);`
520
521			`for (i = 0; i < labels; i++)`
522			`mvwprintw(SP->slk_winptr, 0, slk[i].start_col, "F%d", i + 1);`
523
524			`SP->slk_winptr->_attrs = save_attr;`
525			`}`
526
527			`touchwin(SP->slk_winptr);`
528			`}`
529			`}`
530
531			`void PDC_slk_free(void)`
532			`{`
533			`if (slk)`
534			`{`
535			`if (SP->slk_winptr)`
536			`{`
537			`delwin(SP->slk_winptr);`
538			`SP->slk_winptr = (WINDOW *)NULL;`
539			`}`
540
541			`free(slk);`
542			`slk = (struct SLK *)NULL;`
543
544			`label_length = 0;`
545			`labels = 0;`
546			`label_fmt = 0;`
547			`label_line = 0;`
548			`hidden = FALSE;`
549			`}`
550			`}`
551
552			`int PDC_mouse_in_slk(int y, int x)`
553			`{`
554			`int i;`
555
556			`PDC_LOG(("PDC_mouse_in_slk() - called: y->%d x->%d\n", y, x));`
557
558			`/* If the line on which the mouse was clicked is NOT the last line`
559			`of the screen, we are not interested in it. */`
560
561			`if (!slk \|\| !SP->slk_winptr \|\| (y != SP->slk_winptr->_begy + label_line))`
562			`return 0;`
563
564			`for (i = 0; i < labels; i++)`
565			`if (x >= slk[i].start_col && x < (slk[i].start_col + label_length))`
566			`return i + 1;`
567
568			`return 0;`
569			`}`
570
571			`#ifdef PDC_WIDE`
572			`int slk_wset(int labnum, const wchar_t *label, int justify)`
573			`{`
574			`PDC_LOG(("slk_wset() - called\n"));`
575
576			`if (labnum < 1 \|\| labnum > labels \|\| justify < 0 \|\| justify > 2)`
577			`return ERR;`
578
579			`labnum--;`
580
581			`if (!label \|\| !(*label))`
582			`{`
583			`/* Clear the label */`
584
585			`*slk[labnum].label = 0;`
586			`slk[labnum].format = 0;`
587			`slk[labnum].len = 0;`
588			`}`
589			`else`
590			`{`
591			`int i, j = 0;`
592
593			`/* Skip leading spaces */`
594
595			`while (label[j] == L' ')`
596			`j++;`
597
598			`/* Copy it */`
599
600			`for (i = 0; i < label_length; i++)`
601			`{`
602			`chtype ch = label[i + j];`
603
604			`slk[labnum].label[i] = ch;`
605
606			`if (!ch)`
607			`break;`
608			`}`
609
610			`/* Drop trailing spaces */`
611
612			`while ((i + j) && (label[i + j - 1] == L' '))`
613			`i--;`
614
615			`slk[labnum].label[i] = 0;`
616			`slk[labnum].format = justify;`
617			`slk[labnum].len = i;`
618			`}`
619
620			`_drawone(labnum);`
621
622			`return OK;`
623			`}`
624
625			`wchar_t *slk_wlabel(int labnum)`
626			`{`
627			`static wchar_t temp[33];`
628			`chtype *p;`
629			`int i;`
630
631			`PDC_LOG(("slk_wlabel() - called\n"));`
632
633			`if (labnum < 1 \|\| labnum > labels)`
634			`return (wchar_t *)0;`
635
636			`for (i = 0, p = slk[labnum - 1].label; *p; i++)`
637			`temp[i] = *p++;`
638
639			`temp[i] = '\0';`
640
641			`return temp;`
642			`}`
643			`#endif`