[BACK]Return to wwframe.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / window

Annotation of src/usr.bin/window/wwframe.c, Revision 1.2

1.2     ! niklas      1: /*     $NetBSD: wwframe.c,v 1.4 1996/02/08 21:49:05 mycroft Exp $      */
1.1       deraadt     2:
                      3: /*
                      4:  * Copyright (c) 1983, 1993
                      5:  *     The Regents of the University of California.  All rights reserved.
                      6:  *
                      7:  * This code is derived from software contributed to Berkeley by
                      8:  * Edward Wang at The University of California, Berkeley.
                      9:  *
                     10:  * Redistribution and use in source and binary forms, with or without
                     11:  * modification, are permitted provided that the following conditions
                     12:  * are met:
                     13:  * 1. Redistributions of source code must retain the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer.
                     15:  * 2. Redistributions in binary form must reproduce the above copyright
                     16:  *    notice, this list of conditions and the following disclaimer in the
                     17:  *    documentation and/or other materials provided with the distribution.
                     18:  * 3. All advertising materials mentioning features or use of this software
                     19:  *    must display the following acknowledgement:
                     20:  *     This product includes software developed by the University of
                     21:  *     California, Berkeley and its contributors.
                     22:  * 4. Neither the name of the University nor the names of its contributors
                     23:  *    may be used to endorse or promote products derived from this software
                     24:  *    without specific prior written permission.
                     25:  *
                     26:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     27:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     28:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     29:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     30:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     31:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     32:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     33:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     34:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     35:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     36:  * SUCH DAMAGE.
                     37:  */
                     38:
                     39: #ifndef lint
                     40: #if 0
                     41: static char sccsid[] = "@(#)wwframe.c  8.1 (Berkeley) 6/6/93";
                     42: #else
1.2     ! niklas     43: static char rcsid[] = "$NetBSD: wwframe.c,v 1.4 1996/02/08 21:49:05 mycroft Exp $";
1.1       deraadt    44: #endif
                     45: #endif /* not lint */
                     46:
                     47: #include "ww.h"
                     48: #include "tt.h"
                     49:
                     50: #define frameok(w, r, c) (w1 = wwindex[wwsmap[r][c]], \
                     51:        w1->ww_fmap || w1->ww_order > (w)->ww_order)
                     52:
                     53: wwframe(w, wframe)
                     54: register struct ww *w;
                     55: struct ww *wframe;
                     56: {
                     57:        register r, c;
                     58:        char a1, a2, a3;
                     59:        char b1, b2, b3;
                     60:        register code;
                     61:        register struct ww *w1;
                     62:
                     63:        if (w->ww_w.t > 0) {
                     64:                r = w->ww_w.t - 1;
                     65:                c = w->ww_i.l - 1;
                     66:                a1 = 0;
                     67:                a2 = 0;
                     68:                b1 = 0;
                     69:                b2 = c < 0 || frameok(w, r, c);
                     70:
                     71:                for (; c < w->ww_i.r; c++) {
                     72:                        if (c + 1 >= wwncol) {
                     73:                                a3 = 1;
                     74:                                b3 = 1;
                     75:                        } else {
1.2     ! niklas     76:                                a3 = w->ww_index == wwsmap[r + 1][c + 1];
1.1       deraadt    77:                                b3 = frameok(w, r, c + 1);
                     78:                        }
                     79:                        if (b2) {
                     80:                                code = 0;
                     81:                                if ((a1 || a2) && b1)
                     82:                                        code |= WWF_L;
                     83:                                if ((a2 || a3) && b3)
                     84:                                        code |= WWF_R;
                     85:                                if (code)
                     86:                                        wwframec(wframe, r, c, code|WWF_TOP);
                     87:                        }
                     88:                        a1 = a2;
                     89:                        a2 = a3;
                     90:                        b1 = b2;
                     91:                        b2 = b3;
                     92:                }
                     93:                if ((a1 || a2) && b1 && b2)
                     94:                        wwframec(wframe, r, c, WWF_L|WWF_TOP);
                     95:        }
                     96:
                     97:        if (w->ww_w.b < wwnrow) {
                     98:                r = w->ww_w.b;
                     99:                c = w->ww_i.l - 1;
                    100:                a1 = 0;
                    101:                a2 = 0;
                    102:                b1 = 0;
                    103:                b2 = c < 0 || frameok(w, r, c);
                    104:
                    105:                for (; c < w->ww_i.r; c++) {
                    106:                        if (c + 1 >= wwncol) {
                    107:                                a3 = 1;
                    108:                                b3 = 1;
                    109:                        } else {
1.2     ! niklas    110:                                a3 = w->ww_index == wwsmap[r - 1][c + 1];
1.1       deraadt   111:                                b3 = frameok(w, r, c + 1);
                    112:                        }
                    113:                        if (b2) {
                    114:                                code = 0;
                    115:                                if ((a1 || a2) && b1)
                    116:                                        code |= WWF_L;
                    117:                                if ((a2 || a3) && b3)
                    118:                                        code |= WWF_R;
                    119:                                if (code)
                    120:                                        wwframec(wframe, r, c, code);
                    121:                        }
                    122:                        a1 = a2;
                    123:                        a2 = a3;
                    124:                        b1 = b2;
                    125:                        b2 = b3;
                    126:                }
                    127:                if ((a1 || a2) && b1 && b2)
                    128:                        wwframec(wframe, r, c, WWF_L);
                    129:        }
                    130:
                    131:        if (w->ww_w.l > 0) {
                    132:                r = w->ww_i.t - 1;
                    133:                c = w->ww_w.l - 1;
                    134:                a1 = 0;
                    135:                a2 = 0;
                    136:                b1 = 0;
                    137:                b2 = r < 0 || frameok(w, r, c);
                    138:
                    139:                for (; r < w->ww_i.b; r++) {
                    140:                        if (r + 1 >= wwnrow) {
                    141:                                a3 = 1;
                    142:                                b3 = 1;
                    143:                        } else {
                    144:                                a3 = w->ww_index == wwsmap[r + 1][c + 1];
                    145:                                b3 = frameok(w, r + 1, c);
                    146:                        }
                    147:                        if (b2) {
                    148:                                code = 0;
                    149:                                if ((a1 || a2) && b1)
                    150:                                        code |= WWF_U;
                    151:                                if ((a2 || a3) && b3)
                    152:                                        code |= WWF_D;
                    153:                                if (code)
                    154:                                        wwframec(wframe, r, c, code);
                    155:                        }
                    156:                        a1 = a2;
                    157:                        a2 = a3;
                    158:                        b1 = b2;
                    159:                        b2 = b3;
                    160:                }
                    161:                if ((a1 || a2) && b1 && b2)
                    162:                        wwframec(wframe, r, c, WWF_U);
                    163:        }
                    164:
                    165:        if (w->ww_w.r < wwncol) {
                    166:                r = w->ww_i.t - 1;
                    167:                c = w->ww_w.r;
                    168:                a1 = 0;
                    169:                a2 = 0;
                    170:                b1 = 0;
                    171:                b2 = r < 0 || frameok(w, r, c);
                    172:
                    173:                for (; r < w->ww_i.b; r++) {
                    174:                        if (r + 1 >= wwnrow) {
                    175:                                a3 = 1;
                    176:                                b3 = 1;
                    177:                        } else {
                    178:                                a3 = w->ww_index == wwsmap[r + 1][c - 1];
                    179:                                b3 = frameok(w, r + 1, c);
                    180:                        }
                    181:                        if (b2) {
                    182:                                code = 0;
                    183:                                if ((a1 || a2) && b1)
                    184:                                        code |= WWF_U;
                    185:                                if ((a2 || a3) && b3)
                    186:                                        code |= WWF_D;
                    187:                                if (code)
                    188:                                        wwframec(wframe, r, c, code);
                    189:                        }
                    190:                        a1 = a2;
                    191:                        a2 = a3;
                    192:                        b1 = b2;
                    193:                        b2 = b3;
                    194:                }
                    195:                if ((a1 || a2) && b1 && b2)
                    196:                        wwframec(wframe, r, c, WWF_U);
                    197:        }
                    198: }
                    199:
                    200: wwframec(f, r, c, code)
                    201: register struct ww *f;
                    202: register r, c;
                    203: char code;
                    204: {
                    205:        char oldcode;
1.2     ! niklas    206:        register unsigned char *smap;
1.1       deraadt   207:
                    208:        if (r < f->ww_i.t || r >= f->ww_i.b || c < f->ww_i.l || c >= f->ww_i.r)
                    209:                return;
                    210:
                    211:        smap = &wwsmap[r][c];
                    212:
                    213:        {
                    214:                register struct ww *w;
                    215:
                    216:                w = wwindex[*smap];
                    217:                if (w->ww_order > f->ww_order) {
                    218:                        if (w != &wwnobody && w->ww_win[r][c] == 0)
                    219:                                w->ww_nvis[r]--;
                    220:                        *smap = f->ww_index;
                    221:                }
                    222:        }
                    223:
                    224:        if (f->ww_fmap != 0) {
                    225:                register char *fmap;
                    226:
                    227:                fmap = &f->ww_fmap[r][c];
                    228:                oldcode = *fmap;
                    229:                *fmap |= code;
                    230:                if (code & WWF_TOP)
                    231:                        *fmap &= ~WWF_LABEL;
                    232:                code = *fmap;
                    233:        } else
                    234:                oldcode = 0;
                    235:        {
                    236:                register char *win = &f->ww_win[r][c];
                    237:
                    238:                if (*win == WWM_GLS && *smap == f->ww_index)
                    239:                        f->ww_nvis[r]++;
                    240:                *win &= ~WWM_GLS;
                    241:        }
                    242:        if (oldcode != code && (code & WWF_LABEL) == 0) {
                    243:                register short frame;
                    244:
                    245:                frame = tt.tt_frame[code & WWF_MASK];
                    246:                f->ww_buf[r][c].c_w = frame;
                    247:                if (wwsmap[r][c] == f->ww_index) {
                    248:                        wwtouched[r] |= WWU_TOUCHED;
                    249:                        wwns[r][c].c_w = frame;
                    250:                }
                    251:        }
                    252: }