Return to wind.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove

Annotation of 43BSDTahoe/new/jove/wind.c, revision 1.1

1.1     ! root        1: /***************************************************************************
        !             2:  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
        !             3:  * is provided to you without charge, and with no warranty.  You may give  *
        !             4:  * away copies of JOVE, including sources, provided that this notice is    *
        !             5:  * included in all the files.                                              *
        !             6:  ***************************************************************************/
        !             7: 
        !             8: /* This creates/deletes/divides/grows/shrinks windows.  */
        !             9: 
        !            10: #include "jove.h"
        !            11: #include "termcap.h"
        !            12: 
        !            13: private char   onlyone[] = "You only have one window!",
        !            14:                toosmall[] = "Resulting window would be too small.";
        !            15: 
        !            16: Window *curwind,
        !            17:        *fwind = 0;
        !            18: 
        !            19: /* First line in a Window */
        !            20: 
        !            21: int
        !            22: FLine(w)
        !            23: register Window        *w;
        !            24: {
        !            25:        register Window *wp = fwind;
        !            26:        register int    lineno = -1;
        !            27: 
        !            28:        do {
        !            29:                if (wp == w)
        !            30:                        return lineno + 1;
        !            31:                lineno += wp->w_height;
        !            32:                wp = wp->w_next;
        !            33:        } while (wp != fwind);
        !            34:        complain("window?");
        !            35:        /* NOTREACHED */
        !            36: }
        !            37: 
        !            38: /* Delete `wp' from the screen.  If it is the only window left
        !            39:    on the screen, then complain.  It gives its body
        !            40:    to the next window if there is one, otherwise the previous
        !            41:    window gets the body.  */
        !            42: 
        !            43: void
        !            44: del_wind(wp)
        !            45: register Window        *wp;
        !            46: {
        !            47:        register Window *prev = wp->w_prev;
        !            48: 
        !            49:        if (one_windp())
        !            50:                complain(onlyone);
        !            51: 
        !            52:        wp->w_prev->w_next = wp->w_next;
        !            53:        wp->w_next->w_prev = wp->w_prev;
        !            54:        
        !            55:        if (fwind == wp) {
        !            56:                fwind = wp->w_next;
        !            57:                fwind->w_height += wp->w_height;
        !            58:                /* Here try to do something intelligent for redisplay() */
        !            59:                SetTop(fwind, prev_line(fwind->w_top, wp->w_height));
        !            60:                if (curwind == wp)
        !            61:                        SetWind(fwind);
        !            62:        } else {
        !            63:                prev->w_height += wp->w_height;
        !            64:                if (curwind == wp)
        !            65:                        SetWind(prev);
        !            66:        }
        !            67: #ifdef MAC
        !            68:        RemoveScrollBar(wp);
        !            69:        Windchange++;
        !            70: #endif
        !            71:        free((char *) wp);
        !            72: }
        !            73: 
        !            74: /* Divide the window WP N times, or at least once.  Complains if WP is too
        !            75:    small to be split into that many pieces.  It returns the new window. */
        !            76: 
        !            77: Window *
        !            78: div_wind(wp, n)
        !            79: register Window        *wp;
        !            80: {
        !            81:        register Window *new;
        !            82:        int     amt;
        !            83: 
        !            84:        if (n < 1)
        !            85:                n = 1;
        !            86:        amt = wp->w_height / (n + 1);
        !            87:        if (amt < 2)
        !            88:                complain(toosmall);
        !            89: 
        !            90:        while (--n >= 0) {
        !            91:                new = (Window *) emalloc(sizeof (Window));
        !            92:                new->w_flags = 0;
        !            93:                new->w_LRscroll = 0;
        !            94: 
        !            95:                new->w_height = amt;
        !            96:                wp->w_height -= amt;
        !            97: 
        !            98:                /* set the lines such that w_line is the center in
        !            99:                   each Window */
        !           100:                new->w_line = wp->w_line;
        !           101:                new->w_char = wp->w_char;
        !           102:                new->w_bufp = wp->w_bufp;
        !           103:                new->w_top = prev_line(new->w_line, HALF(new));
        !           104: 
        !           105:                /* Link the new window into the list */
        !           106:                new->w_prev = wp;
        !           107:                new->w_next = wp->w_next;
        !           108:                new->w_next->w_prev = new;
        !           109:                wp->w_next = new;
        !           110: #ifdef MAC
        !           111:                new->w_control = 0;
        !           112: #endif
        !           113:        }
        !           114: #ifdef MAC
        !           115:        Windchange++;
        !           116: #endif
        !           117:        return new;
        !           118: }
        !           119: 
        !           120: /* Initialze the first window setting the bounds to the size of the
        !           121:    screen.  There is no buffer with this window.  See parse for the
        !           122:    setting of this window. */
        !           123: 
        !           124: void
        !           125: winit()
        !           126: {
        !           127:        register Window *w;
        !           128: 
        !           129:        w = curwind = fwind = (Window *) emalloc(sizeof (Window));
        !           130:        w->w_line = w->w_top = 0;
        !           131:        w->w_LRscroll = 0;
        !           132:        w->w_flags = 0;
        !           133:        w->w_char = 0;
        !           134:        w->w_next = w->w_prev = fwind;
        !           135:        w->w_height = ILI;
        !           136: #ifdef MAC
        !           137:        w->w_control = 0;
        !           138:        Windchange++;
        !           139: #endif
        !           140: }
        !           141: 
        !           142: /* Change to previous window. */
        !           143: 
        !           144: void
        !           145: PrevWindow()
        !           146: {
        !           147:        register Window *new = curwind->w_prev;
        !           148: 
        !           149:        if (Asking)
        !           150:                complain((char *) 0);
        !           151:        if (one_windp())
        !           152:                complain(onlyone);
        !           153:        SetWind(new);
        !           154: }
        !           155: 
        !           156: /* Make NEW the current Window */
        !           157: 
        !           158: void
        !           159: SetWind(new)
        !           160: register Window        *new;
        !           161: {
        !           162:        if (!Asking) {          /* can you say kludge? */
        !           163:                curwind->w_line = curline;
        !           164:                curwind->w_char = curchar;
        !           165:                curwind->w_bufp = curbuf;
        !           166:        }
        !           167:        if (new == curwind)
        !           168:                return;
        !           169:        SetBuf(new->w_bufp);
        !           170:        if (!inlist(new->w_bufp->b_first, new->w_line)) {
        !           171:                new->w_line = curline;
        !           172:                new->w_char = curchar;
        !           173:        }
        !           174:        DotTo(new->w_line, new->w_char);
        !           175:        if (curchar > strlen(linebuf))
        !           176:                new->w_char = curchar = strlen(linebuf);
        !           177:        curwind = new;
        !           178: }
        !           179: 
        !           180: /* delete the current window if it isn't the only one left */
        !           181: 
        !           182: void
        !           183: DelCurWindow()
        !           184: {
        !           185:        SetABuf(curwind->w_bufp);
        !           186:        del_wind(curwind);
        !           187: }
        !           188: 
        !           189: /* put the current line of `w' in the middle of the window */
        !           190: 
        !           191: void
        !           192: CentWind(w)
        !           193: register Window        *w;
        !           194: {
        !           195:        SetTop(w, prev_line(w->w_line, HALF(w)));
        !           196: }
        !           197: 
        !           198: int    ScrollStep = 0;         /* full scrolling */
        !           199: 
        !           200: /* Calculate the new topline of the window.  If ScrollStep == 0
        !           201:    it means we should center the current line in the window. */
        !           202: 
        !           203: void
        !           204: CalcWind(w)
        !           205: register Window        *w;
        !           206: {
        !           207:        register int    up;
        !           208:        int     scr_step;
        !           209:        Line    *newtop;
        !           210: 
        !           211:        if (ScrollStep == 0)    /* Means just center it */
        !           212:                CentWind(w);
        !           213:        else {
        !           214:                up = inorder(w->w_line, 0, w->w_top, 0);
        !           215:                if (up == -1) {
        !           216:                        CentWind(w);
        !           217:                        return;
        !           218:                }
        !           219:                scr_step = (ScrollStep < 0) ? SIZE(w) + ScrollStep :
        !           220:                           ScrollStep - 1;
        !           221:                if (up)         /* point is above the screen */
        !           222:                        newtop = prev_line(w->w_line, scr_step);
        !           223:                else
        !           224:                        newtop = prev_line(w->w_line, (SIZE(w) - 1 - scr_step));
        !           225:                if (LineDist(newtop, w->w_top) >= SIZE(w) - 1)
        !           226:                        CentWind(w);
        !           227:                else
        !           228:                        SetTop(w, newtop);
        !           229:        }
        !           230: }
        !           231: 
        !           232: /* This is bound to C-X 4 [BTF].  To make the screen stay the
        !           233:    same we have to remember various things, like the current
        !           234:    top line in the current window.  It's sorta gross, but it's
        !           235:    necessary because of the way this is implemented (i.e., in
        !           236:    terms of do_find(), do_select() which manipulate the windows. */
        !           237: 
        !           238: void
        !           239: WindFind()
        !           240: {
        !           241:        register Buffer *obuf = curbuf,
        !           242:                        *nbuf;
        !           243:        Line    *ltop = curwind->w_top;
        !           244:        Bufpos  savedot;
        !           245:        extern void
        !           246:                FindTag(),
        !           247:                BufSelect(),
        !           248:                FindFile();
        !           249: 
        !           250:        DOTsave(&savedot);
        !           251: 
        !           252:        switch (waitchar((int *) 0)) {
        !           253:        case 't':
        !           254:        case 'T':
        !           255:                ExecCmd((data_obj *) FindCmd(FindTag));
        !           256:                break;
        !           257: 
        !           258:        case 'b':
        !           259:        case 'B':
        !           260:                ExecCmd((data_obj *) FindCmd(BufSelect));
        !           261:                break;
        !           262: 
        !           263:        case 'f':
        !           264:        case 'F':
        !           265:                ExecCmd((data_obj *) FindCmd(FindFile));
        !           266:                break;
        !           267: 
        !           268:        default:
        !           269:                complain("T: find-tag, F: find-file, B: select-buffer.");
        !           270:        }
        !           271: 
        !           272:        nbuf = curbuf;
        !           273:        SetBuf(obuf);
        !           274:        SetDot(&savedot);
        !           275:        SetTop(curwind, ltop);  /* there! it's as if we did nothing */
        !           276: 
        !           277:        if (one_windp())
        !           278:                (void) div_wind(curwind, 1);
        !           279: 
        !           280:        tiewind(curwind->w_next, nbuf);
        !           281:        SetWind(curwind->w_next);
        !           282: }
        !           283: 
        !           284: /* Go into one window mode by deleting all the other windows */
        !           285: 
        !           286: void
        !           287: OneWindow()
        !           288: {
        !           289:        while (curwind->w_next != curwind)
        !           290:                del_wind(curwind->w_next);
        !           291: }
        !           292: 
        !           293: Window *
        !           294: windbp(bp)
        !           295: register Buffer        *bp;
        !           296: {
        !           297: 
        !           298:        register Window *wp = fwind;
        !           299: 
        !           300:        if (bp == 0)
        !           301:                return 0;
        !           302:        do {
        !           303:                if (wp->w_bufp == bp)
        !           304:                        return wp;
        !           305:                wp = wp->w_next;
        !           306:        } while (wp != fwind);
        !           307:        return 0;
        !           308: }
        !           309: 
        !           310: /* Change window into the next window.  Curwind becomes the new window. */
        !           311: 
        !           312: void
        !           313: NextWindow()
        !           314: {
        !           315:        register Window *new = curwind->w_next;
        !           316: 
        !           317:        if (Asking)
        !           318:                complain((char *) 0);
        !           319:        if (one_windp())
        !           320:                complain(onlyone);
        !           321:        SetWind(new);
        !           322: }
        !           323: 
        !           324: /* Scroll the next Window */
        !           325: 
        !           326: void
        !           327: PageNWind()
        !           328: {
        !           329:        if (one_windp())
        !           330:                complain(onlyone);
        !           331:        NextWindow();
        !           332:        NextPage();
        !           333:        PrevWindow();
        !           334: }
        !           335: 
        !           336: Window *
        !           337: w_nam_typ(name, type)
        !           338: register char  *name;
        !           339: {
        !           340:        register Window *w;
        !           341:        register Buffer *b;
        !           342: 
        !           343:        b = buf_exists(name);
        !           344:        w = fwind;
        !           345:        if (b) do {
        !           346:                if (w->w_bufp == b)
        !           347:                        return w;
        !           348:        } while ((w = w->w_next) != fwind);
        !           349: 
        !           350:        w = fwind;
        !           351:        do {
        !           352:                if (w->w_bufp->b_type == type)
        !           353:                        return w;
        !           354:        } while ((w = w->w_next) != fwind);
        !           355: 
        !           356:        return 0;
        !           357: }
        !           358: 
        !           359: /* Put a window with the buffer `name' in it.  Erase the buffer if
        !           360:    `clobber' is non-zero. */
        !           361: 
        !           362: void
        !           363: pop_wind(name, clobber, btype)
        !           364: register char  *name;
        !           365: {
        !           366:        register Window *wp;
        !           367:        register Buffer *newb;
        !           368: 
        !           369:        if (newb = buf_exists(name))
        !           370:                btype = -1;     /* if the buffer exists, don't change
        !           371:                                   it's type */
        !           372:        if ((wp = w_nam_typ(name, btype)) == 0) {
        !           373:                if (one_windp())
        !           374:                        SetWind(div_wind(curwind, 1));
        !           375:                else
        !           376:                        PrevWindow();
        !           377:        } else
        !           378:                SetWind(wp);
        !           379: 
        !           380:        newb = do_select((Window *) 0, name);
        !           381:        if (clobber) {
        !           382:                initlist(newb);
        !           383:                newb->b_modified = NO;
        !           384:        }
        !           385:        tiewind(curwind, newb);
        !           386:        if (btype != -1)
        !           387:                newb->b_type = btype;
        !           388:        SetBuf(newb);
        !           389: }
        !           390: 
        !           391: void
        !           392: GrowWindow()
        !           393: {
        !           394:        WindSize(curwind, abs(arg_value()));
        !           395: }
        !           396: 
        !           397: void
        !           398: ShrWindow()
        !           399: {
        !           400:        WindSize(curwind, -abs(arg_value()));
        !           401: }
        !           402: 
        !           403: /* Change the size of the window by inc.  First arg is the window,
        !           404:    second is the increment. */
        !           405: 
        !           406: void
        !           407: WindSize(w, inc)
        !           408: register Window        *w;
        !           409: register int   inc;
        !           410: {
        !           411:        if (one_windp())
        !           412:                complain(onlyone);
        !           413: 
        !           414:        if (inc == 0)
        !           415:                return;
        !           416:        else if (inc < 0) {     /* Shrinking this Window. */
        !           417:                if (w->w_height + inc < 2)
        !           418:                        complain(toosmall);
        !           419:                w->w_height += inc;
        !           420:                w->w_prev->w_height -= inc;
        !           421:        } else                  /* Growing the window. */
        !           422:                WindSize(w->w_next, -inc);
        !           423: #ifdef MAC
        !           424:        Windchange++;
        !           425: #endif
        !           426: }
        !           427: 
        !           428: /* Set the topline of the window, calculating its number in the buffer.
        !           429:    This is for numbering the lines only. */
        !           430: 
        !           431: void
        !           432: SetTop(w, line)
        !           433: Window *w;
        !           434: register Line  *line;
        !           435: {
        !           436:        register Line   *lp = w->w_bufp->b_first;
        !           437:        register int    num = 0;
        !           438: 
        !           439:        w->w_top = line;
        !           440:        if (w->w_flags & W_NUMLINES) {
        !           441:                while (lp) {
        !           442:                        num += 1;
        !           443:                        if (line == lp)
        !           444:                                break;
        !           445:                        lp = lp->l_next;
        !           446:                }
        !           447:                w->w_topnum = num;
        !           448:        }
        !           449: }
        !           450: 
        !           451: void
        !           452: WNumLines()
        !           453: {
        !           454:        curwind->w_flags ^= W_NUMLINES; 
        !           455:        SetTop(curwind, curwind->w_top);
        !           456: }
        !           457: 
        !           458: void
        !           459: WVisSpace()
        !           460: {
        !           461:        curwind->w_flags ^= W_VISSPACE;
        !           462:        ClAndRedraw();
        !           463: }
        !           464: 
        !           465: /* Return the line number that `line' occupies in `windes' */
        !           466: 
        !           467: int
        !           468: in_window(windes, line)
        !           469: register Window        *windes;
        !           470: register Line  *line;
        !           471: {
        !           472:        register int    i;
        !           473:        register Line   *top = windes->w_top;
        !           474: 
        !           475:        for (i = 0; top && i < windes->w_height - 1; i++, top = top->l_next)
        !           476:                if (top == line)
        !           477:                        return FLine(windes) + i;
        !           478:        return -1;
        !           479: }
        !           480: 
        !           481: void
        !           482: SplitWind()
        !           483: {
        !           484:        SetWind(div_wind(curwind, is_an_arg() ? (arg_value() - 1) : 1));
        !           485: }
        !           486: 
        !           487: /* Goto the window with the named buffer.  If no such window
        !           488:    exists, pop one and attach the buffer to it. */
        !           489: void
        !           490: GotoWind()
        !           491: {
        !           492:        extern Buffer   *lastbuf;
        !           493:        char    *bname;
        !           494:        Window  *w;
        !           495: 
        !           496:        bname = ask_buf(lastbuf);
        !           497:        w = curwind->w_next;
        !           498:        do {
        !           499:                if (w->w_bufp->b_name == bname) {
        !           500:                        SetABuf(curbuf);
        !           501:                        SetWind(w);
        !           502:                        return;
        !           503:                }
        !           504:                w = w->w_next;
        !           505:        } while (w != curwind);
        !           506:        SetABuf(curbuf);
        !           507:        pop_wind(bname, NO, -1);
        !           508: }
        !           509: 
        !           510: void
        !           511: ScrollRight()
        !           512: {
        !           513:        int     amt = (is_an_arg() ? arg_value() : 10);
        !           514: 
        !           515:        if (curwind->w_LRscroll - amt < 0)
        !           516:                curwind->w_LRscroll = 0;
        !           517:        else
        !           518:                curwind->w_LRscroll -= amt;
        !           519:        UpdModLine = YES;
        !           520: }
        !           521: 
        !           522: void
        !           523: ScrollLeft()
        !           524: {
        !           525:        int     amt = (is_an_arg() ? arg_value() : 10);
        !           526: 
        !           527:        curwind->w_LRscroll += amt;
        !           528:        UpdModLine = YES;
        !           529: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.