Return to scrollbar.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xterm

Annotation of 43BSDTahoe/new/X/xterm/scrollbar.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     @(#)scrollbar.c 1.11 (Berkeley/CSRG) 9/18/87
        !             3:  *     $Source: /u1/X/xterm/RCS/scrollbar.c,v $
        !             4:  *     $Header: scrollbar.c,v 10.100 86/12/01 14:45:27 jg Rel $
        !             5:  */
        !             6: 
        !             7: #include <stdio.h>
        !             8: #include <sys/time.h>
        !             9: #include <X/Xlib.h>
        !            10: #include <setjmp.h>
        !            11: #include "scrollbar.h"
        !            12: #include "ptyx.h"
        !            13: #include "data.h"
        !            14: #include "error.h"
        !            15: #ifdef MODEMENU
        !            16: #include "menu.h"
        !            17: #endif MODEMENU
        !            18: 
        !            19: #include "button.ic"
        !            20: #include "dark.ic"
        !            21: #include "light.ic"
        !            22: #include "upline.ic"
        !            23: #include "downline.ic"
        !            24: #include "uppage.ic"
        !            25: #include "downpage.ic"
        !            26: #include "top.ic"
        !            27: #include "bottom.ic"
        !            28: #include "saveoff.ic"
        !            29: #include "saveon.ic"
        !            30: #include "sbcursor.cursor"
        !            31: #include "sbcursor_mask.cursor"
        !            32: #ifndef lint
        !            33: static char csrg_id[] = "@(#)scrollbar.c       1.11\t(Berkeley/CSRG)\t9/18/87";
        !            34: static char sccs_id[] = "@(#)scrollbar.c\tX10/6.6B\t12/26/86";
        !            35: #endif lint
        !            36: 
        !            37: static struct timeval stepspeed;
        !            38: 
        !            39: ScrollBar *
        !            40: CreateScrollBar(w, x, y, height, fg, bg, bordertile, val, valregion,
        !            41:  topval, botval, arrow)
        !            42:        Window w;
        !            43:        int x, y, height, fg, bg, val, valregion, topval, botval;
        !            44:        Pixmap bordertile;
        !            45:        Cursor arrow;
        !            46: {
        !            47:        register ScrollBar *sb;
        !            48:        register int i;
        !            49:        Pixmap btile, bgnd;
        !            50:        extern char *calloc();
        !            51:        static Window Make_tiled_window();
        !            52:        extern Pixmap Make_tile();
        !            53: 
        !            54:        if(!w || height < MINSCROLLBARHEIGHT ||
        !            55:         (sb = (ScrollBar *)calloc(1, sizeof(ScrollBar))) == NULL)
        !            56:                return(NULL);
        !            57:        btile = bordertile;
        !            58:        if(bg == BlackPixel && fg == WhitePixel) {
        !            59:                bg = WhitePixel;
        !            60:                fg = BlackPixel;
        !            61:                if(btile == WhitePixmap)
        !            62:                        btile = BlackPixmap;
        !            63:        }
        !            64:        sb->fg = fg;
        !            65:        sb->bg = bg;
        !            66:        sb->cursor = XCreateCursor(sbcursor_width, sbcursor_height,
        !            67:                                   sbcursor_bits, sbcursor_mask_bits,
        !            68:                                   sbcursor_x_hot, sbcursor_y_hot,
        !            69:                                   fg, bg, GXcopy);
        !            70:        if((sb->bar = Make_tiled_window(light_width, light_height, light_bits,
        !            71:         fg, bg, &bgnd, w, x, y, (SCROLLBARWIDTH - 1), height, 1, bordertile))
        !            72:         == NULL)
        !            73:                goto failed_bar;
        !            74:        if((sb->button = XCreateWindow(sb->bar, -1, -1, (SCROLLBARWIDTH - 1),
        !            75:         BUTTONHEIGHT - 1, 1, btile, bgnd)) == NULL)
        !            76:                goto failed_button;
        !            77:        if((sb->save = XCreateWindow(sb->bar, -1, BUTTONHEIGHT - 1,
        !            78:         (SCROLLBARWIDTH - 1), BUTTONHEIGHT - 1, 1, btile, bgnd)) == NULL)
        !            79:                goto failed_save;
        !            80:        if((sb->region = Make_tiled_window(dark_width, dark_height, dark_bits,
        !            81:         fg, bg, &bgnd, sb->bar, 0, 0, (SCROLLBARWIDTH - 1), 10, 0,
        !            82:         (Pixmap)NULL)) == NULL) {
        !            83:                XDestroyWindow(sb->save);
        !            84: failed_save:
        !            85:                XDestroyWindow(sb->button);
        !            86: failed_button:
        !            87:                XDestroyWindow(sb->bar);
        !            88: failed_bar:
        !            89:                free((char *)sb);
        !            90:                return(NULL);
        !            91:        }
        !            92:        sb->savebits[SAVE_OFF] = saveoff_bits;
        !            93:        sb->savebits[SAVE_ON] = saveon_bits;
        !            94:        sb->buttonbits[BUTTON_UPLINE / 2] = upline_bits;
        !            95:        sb->buttonbits[BUTTON_DOWNLINE / 2] = downline_bits;
        !            96:        sb->buttonbits[BUTTON_UPPAGE / 2] = uppage_bits;
        !            97:        sb->buttonbits[BUTTON_DOWNPAGE / 2] = downpage_bits;
        !            98:        sb->buttonbits[BUTTON_TOP / 2] = top_bits;
        !            99:        sb->buttonbits[BUTTON_BOTTOM / 2] = bottom_bits;
        !           100:        sb->buttonbits[BUTTON_NORMAL / 2] = button_bits;
        !           101:        XDefineCursor(sb->bar, sb->cursor);
        !           102:        XSelectInput(sb->bar, ButtonPressed | ButtonReleased | ExposeWindow |
        !           103:         EnterWindow | LeaveWindow | UnmapWindow);
        !           104:        XSelectInput(sb->button, EnterWindow | LeaveWindow);
        !           105:        XMapWindow(sb->button); /* will really map when bar is mapped */
        !           106:        XMapWindow(sb->save);   /* will really map when bar is mapped */
        !           107:        sb->buttonstate = sb->buttonset = BUTTON_NORMAL;
        !           108:        sb->savestate = sb->saveset = SAVE_ON;
        !           109:        sb->set.value = val;
        !           110:        sb->set.regionheight = valregion;
        !           111:        sb->set.topvalue = topval;
        !           112:        sb->set.bottomvalue = botval;
        !           113:        sb->set.height = height - BARSTART;
        !           114:        return(sb);
        !           115: }
        !           116: 
        !           117: ShowScrollBar(sb)
        !           118:        register ScrollBar *sb;
        !           119: {
        !           120:        if(sb->visible)
        !           121:                return;
        !           122:        sb->visible = 1;
        !           123:        if(sb->regionvisible) {
        !           124:                XUnmapWindow(sb->region);
        !           125:                sb->regionvisible = 0;
        !           126:        }
        !           127:        XMapWindow(sb->bar);
        !           128:        DrawScrollRegion(sb);
        !           129:        sb->action = SHOW;
        !           130: }
        !           131: 
        !           132: HideScrollBar(sb)
        !           133:        register ScrollBar *sb;
        !           134: {
        !           135:        if(!sb->visible)
        !           136:                return;
        !           137:        sb->visible = 0;
        !           138:        XUnmapWindow(sb->bar);
        !           139: }
        !           140: 
        !           141: DrawScrollRegion(sb)
        !           142:        register ScrollBar *sb;
        !           143: {
        !           144:        register int region, temp;
        !           145: 
        !           146:        if(sb->set.regionheight <= 0)
        !           147:                sb->set.regionheight = 0;
        !           148:        if((region = sb->set.topvalue - sb->set.bottomvalue) >= 0) {
        !           149:                if(sb->set.value > sb->set.topvalue)
        !           150:                        sb->set.value = sb->set.topvalue;
        !           151:                else if(sb->set.value < sb->set.bottomvalue)
        !           152:                        sb->set.value = sb->set.bottomvalue;
        !           153:        } else {
        !           154:                region = -region;
        !           155:                if(sb->set.value < sb->set.topvalue)
        !           156:                        sb->set.value = sb->set.topvalue;
        !           157:                else if(sb->set.value > sb->set.bottomvalue)
        !           158:                        sb->set.value = sb->set.bottomvalue;
        !           159:        }
        !           160:        if(sb->set.value == sb->set.topvalue) {
        !           161:                sb->set.pixelheight = (region == 0) ? sb->set.height :
        !           162:                 (sb->set.height - 1) * sb->set.regionheight /
        !           163:                 (sb->set.regionheight + region);
        !           164:                sb->set.y = BARSTART;
        !           165:        } else if(sb->set.value == sb->set.bottomvalue) {
        !           166:                sb->set.pixelheight = (sb->set.height - 1) *
        !           167:                 sb->set.regionheight / (sb->set.regionheight + region);
        !           168:                sb->set.y = BARSTART + sb->set.height - sb->set.pixelheight;
        !           169:        } else {
        !           170:                if(sb->set.topvalue >= sb->set.bottomvalue) {
        !           171:                        temp = sb->set.topvalue - 1;
        !           172:                        region = temp - (sb->set.bottomvalue + 1);
        !           173:                        sb->set.y = temp - sb->set.value;
        !           174:                } else {
        !           175:                        temp = sb->set.topvalue + 1;
        !           176:                        region = (sb->set.bottomvalue - 1) - temp;
        !           177:                        sb->set.y = sb->set.value - temp;
        !           178:                }
        !           179:                sb->set.y = (BARSTART + 1) + sb->set.y * (sb->set.height - 2) /
        !           180:                 (temp = sb->set.regionheight + region);
        !           181:                sb->set.pixelheight = (sb->set.height - 2) *
        !           182:                 sb->set.regionheight / temp;
        !           183:        }
        !           184:        if(sb->set.pixelheight <= 0)
        !           185:                sb->set.pixelheight = 1;
        !           186:        if(sb->set.regionheight == 0) {
        !           187:                sb->state = sb->set;
        !           188:                if(sb->regionvisible) {
        !           189:                        XUnmapWindow(sb->region);
        !           190:                        sb->regionvisible = 0;
        !           191:                }
        !           192:                return;
        !           193:        }
        !           194:        if(!sb->visible || sb->regionvisible
        !           195:         && sb->state.y == sb->set.y
        !           196:         && sb->state.pixelheight == sb->set.pixelheight) {
        !           197:                sb->state = sb->set;
        !           198:                return;
        !           199:        }
        !           200:        sb->state = sb->set;
        !           201:        XConfigureWindow(sb->region, 0, sb->state.y, (SCROLLBARWIDTH - 1),
        !           202:         sb->state.pixelheight);
        !           203:        if(!sb->regionvisible) {
        !           204:                XMapWindow(sb->region);
        !           205:                sb->regionvisible = 1;
        !           206:        }
        !           207: }
        !           208: 
        !           209: DrawButton(sb)
        !           210:        register ScrollBar *sb;
        !           211: {
        !           212:        register int fg, bg;
        !           213: 
        !           214:        if(sb->visible && sb->buttonstate != sb->buttonset) {
        !           215:                if((sb->buttonstate = sb->buttonset) & HILITED) {
        !           216:                        fg = sb->bg;
        !           217:                        bg = sb->fg;
        !           218:                } else {
        !           219:                        fg = sb->fg;
        !           220:                        bg = sb->bg;
        !           221:                }
        !           222:                XBitmapBitsPut(sb->button, 0, 0, SCROLLBARWIDTH - 1,
        !           223:                 BUTTONHEIGHT - 1, sb->buttonbits[sb->buttonstate / 2],
        !           224:                 fg, bg, (Bitmap)0, GXcopy, AllPlanes);
        !           225:        }
        !           226: }
        !           227: 
        !           228: DrawSave(sb)
        !           229:        register ScrollBar *sb;
        !           230: {
        !           231:        if(sb->visible && sb->savestate != sb->saveset)
        !           232:                XBitmapBitsPut(sb->save, 0, 0, SCROLLBARWIDTH - 1,
        !           233:                 BUTTONHEIGHT - 1, sb->savebits[sb->savestate = sb->saveset],
        !           234:                 sb->fg, sb->bg, (Bitmap)0, GXcopy, AllPlanes);
        !           235: }
        !           236: 
        !           237: ResizeScrollBar(sb, x, y, height, region)
        !           238:        register ScrollBar *sb;
        !           239:        int x, y, height, region;
        !           240: {
        !           241:        register int act;
        !           242: 
        !           243:        act = sb->action;
        !           244:        sb->action = NONE;
        !           245:        switch(act) {
        !           246:         case SHOW:
        !           247:                return;
        !           248:         case HIDE:
        !           249:                HideScrollBar(sb);
        !           250:                return;
        !           251:        }
        !           252:        if(!sb->visible)
        !           253:                return;
        !           254:        if(sb->regionvisible) {
        !           255:                XUnmapWindow(sb->region);
        !           256:                sb->regionvisible = 0;
        !           257:        }
        !           258:        XConfigureWindow(sb->bar, x, y, (SCROLLBARWIDTH - 1), height);
        !           259:        sb->set.height = height - BARSTART;
        !           260:        sb->set.regionheight = region;
        !           261:        DrawScrollRegion(sb);
        !           262: }
        !           263: 
        !           264: PositionRegion(sb, y)
        !           265:        register ScrollBar *sb;
        !           266:        register int y;
        !           267: {
        !           268:        if(y <= BARSTART)
        !           269:                sb->set.value = sb->set.topvalue;
        !           270:        else if(y >= BARSTART + sb->set.height *
        !           271:         (sb->set.bottomvalue - sb->set.topvalue) /
        !           272:         (sb->set.bottomvalue + sb->set.regionheight - sb->set.topvalue))
        !           273:                sb->set.value = sb->set.bottomvalue;
        !           274:        else
        !           275:                sb->set.value = sb->set.topvalue + (y - BARSTART) *
        !           276:                 (sb->set.bottomvalue + sb->set.regionheight - sb->set.topvalue)
        !           277:                 / sb->set.height;
        !           278:        DrawScrollRegion(sb);
        !           279:        return(sb->state.value);
        !           280: }
        !           281: 
        !           282: ButtonRegion(sb)
        !           283:        register ScrollBar *sb;
        !           284: {
        !           285:        register int reverse, pagesize;
        !           286: 
        !           287:        if(!(sb->buttonset & HILITED))
        !           288:                return(sb->set.value);
        !           289:        reverse = (sb->set.bottomvalue > sb->set.topvalue);
        !           290:        pagesize = sb->set.regionheight - 1;
        !           291:        switch(sb->buttonset) {
        !           292:         case BUTTON_UPLINEHI:
        !           293:                if(reverse)
        !           294:                        sb->set.value--;
        !           295:                else
        !           296:                        sb->set.value++;
        !           297:                break;
        !           298:         case BUTTON_DOWNLINEHI:
        !           299:                if(reverse)
        !           300:                        sb->set.value++;
        !           301:                else
        !           302:                        sb->set.value--;
        !           303:                break;
        !           304:         case BUTTON_UPPAGEHI:
        !           305:                if(reverse)
        !           306:                        sb->set.value -= pagesize;
        !           307:                else
        !           308:                        sb->set.value += pagesize;
        !           309:                break;
        !           310:         case BUTTON_DOWNPAGEHI:
        !           311:                if(reverse)
        !           312:                        sb->set.value += pagesize;
        !           313:                else
        !           314:                        sb->set.value -= pagesize;
        !           315:                break;
        !           316:         case BUTTON_TOPHI:
        !           317:                sb->set.value = sb->set.topvalue;
        !           318:                break;
        !           319:         case BUTTON_BOTTOMHI:
        !           320:                sb->set.value = sb->set.bottomvalue;
        !           321:        }
        !           322:        DrawScrollRegion(sb);
        !           323:        return(sb->set.value);
        !           324: }
        !           325: 
        !           326: DownButtonDown(term, reply, pty)
        !           327:        Terminal *term;
        !           328:        register XKeyOrButtonEvent *reply;
        !           329:        int pty;                        /* file descriptor of pty */
        !           330: {
        !           331:        register Screen *screen = &term->screen;
        !           332:        register ScrollBar *sb = screen->sb;
        !           333:        register Window window = reply->subwindow;
        !           334: 
        !           335:        if(!window || window == sb->region) {
        !           336:                register int page = sb->set.regionheight;
        !           337:                register int height = sb->set.height + BARSTART;
        !           338: 
        !           339:                if (reply->detail & ShiftMask)
        !           340:                        sb->set.value += page * (height - reply->y) / height;
        !           341:                else
        !           342:                        sb->set.value += page * reply->y / height;
        !           343:                DrawScrollRegion(sb);
        !           344:                WindowScroll(screen, sb->set.value);
        !           345:                sb->buttonset = BUTTON_DOWNLINEHI;
        !           346:                stepspeed.tv_usec = PAUSETIME;
        !           347:                screen->timeout = &stepspeed;
        !           348:                return;
        !           349:        }
        !           350:        if(window == sb->save) {
        !           351:                SetSaveState(sb, !GetSaveState(sb));
        !           352:                return;
        !           353:        }
        !           354:        if(window != sb->button) {
        !           355:                Bell();
        !           356:                return;
        !           357:        }
        !           358:        if(reply->detail & ControlMask)
        !           359:                sb->buttonset = BUTTON_BOTTOMHI;
        !           360:        else if(reply->detail & ShiftMask)
        !           361:                sb->buttonset = BUTTON_DOWNPAGEHI;
        !           362:        else {
        !           363:                sb->buttonset = BUTTON_DOWNLINEHI;
        !           364:                stepspeed.tv_usec = PAUSETIME;
        !           365:                screen->timeout = &stepspeed;
        !           366:                WindowScroll(screen, ButtonRegion(screen->sb));
        !           367:        }
        !           368:        DrawButton(sb);
        !           369: }
        !           370: 
        !           371: UpButtonDown(term, reply, pty)
        !           372:        Terminal *term;
        !           373:        register XKeyOrButtonEvent *reply;
        !           374:        int pty;                        /* file descriptor of pty */
        !           375: {
        !           376:        register Screen *screen = &term->screen;
        !           377:        register ScrollBar *sb = screen->sb;
        !           378:        register Window window = reply->subwindow;
        !           379: 
        !           380:        if(window == sb->save) {
        !           381:                SetSaveState(sb, !GetSaveState(sb));
        !           382:                return;
        !           383:        }
        !           384:        if(!window || window == sb->region) {
        !           385:                register int page = sb->set.regionheight;
        !           386:                register int height = sb->set.height + BARSTART;
        !           387: 
        !           388:                if (reply->detail & ShiftMask)
        !           389:                        sb->set.value -= page * (height - reply->y) / height;
        !           390:                else
        !           391:                        sb->set.value -= page * reply->y / height;
        !           392:                DrawScrollRegion(sb);
        !           393:                WindowScroll(screen, sb->set.value);
        !           394:                sb->buttonset = BUTTON_UPLINEHI;
        !           395:                stepspeed.tv_usec = PAUSETIME;
        !           396:                screen->timeout = &stepspeed;
        !           397:                return;
        !           398:        }
        !           399:        if(window != sb->button) {
        !           400:                Bell();
        !           401:                return;
        !           402:        }
        !           403:        if(reply->detail & ControlMask)
        !           404:                sb->buttonset = BUTTON_TOPHI;
        !           405:        else if(reply->detail & ShiftMask)
        !           406:                sb->buttonset = BUTTON_UPPAGEHI;
        !           407:        else {
        !           408:                sb->buttonset = BUTTON_UPLINEHI;
        !           409:                stepspeed.tv_usec = PAUSETIME;
        !           410:                screen->timeout = &stepspeed;
        !           411:                WindowScroll(screen, ButtonRegion(screen->sb));
        !           412:        }
        !           413:        DrawButton(sb);
        !           414: }
        !           415: 
        !           416: ButtonUp(term, reply, pty)
        !           417:        Terminal *term;
        !           418:        XKeyOrButtonEvent *reply;
        !           419:        int pty;                        /* file descriptor of pty */
        !           420: {
        !           421:        register Screen *screen = &term->screen;
        !           422:        register ScrollBar *sb = screen->sb;
        !           423:        register int state;
        !           424: 
        !           425:        if((state = GetButtonState(sb)) == BUTTON_NORMAL)
        !           426:                return;
        !           427:        /* don't scroll further on line mode */
        !           428:        if(state > BUTTON_DOWNLINEHI)
        !           429:                WindowScroll(screen, ButtonRegion(sb));
        !           430:        sb->buttonset = BUTTON_NORMAL;
        !           431:        DrawButton(sb);
        !           432:        screen->timeout = NULL;
        !           433:        XUngrabMouse();
        !           434: }
        !           435: 
        !           436: WindowScroll(screen, top)
        !           437:        register Screen *screen;
        !           438:        int top;
        !           439: {
        !           440:        register int i, lines;
        !           441:        register int scrolltop, scrollheight, refreshtop;
        !           442: 
        !           443:        if((i = screen->topline - top) == 0)
        !           444:                return;
        !           445:        if(screen->cursor_state)
        !           446:                HideCursor();
        !           447:        lines = i > 0 ? i : -i;
        !           448:        if(lines > screen->max_row + 1)
        !           449:                lines = screen->max_row + 1;
        !           450:        scrollheight = screen->max_row - lines + 1;
        !           451:        if(i > 0)
        !           452:                refreshtop = scrolltop = 0;
        !           453:        else {
        !           454:                scrolltop = lines;
        !           455:                refreshtop = scrollheight;
        !           456:        }
        !           457:        if(scrollheight > 0) {
        !           458:                if (screen->multiscroll && scrollheight == 1 &&
        !           459:                 screen->topline == 0 && screen->top_marg == 0 &&
        !           460:                 screen->bot_marg == screen->max_row) {
        !           461:                        if (screen->incopy < 0 && screen->scrolls == 0)
        !           462:                                CopyWait (screen);
        !           463:                        screen->scrolls++;
        !           464:                } else {
        !           465:                        if (screen->incopy)
        !           466:                                CopyWait (screen);
        !           467:                        screen->incopy = -1;
        !           468:                }
        !           469:                XMoveArea(VWindow(screen), screen->border, scrolltop *
        !           470:                 FontHeight(screen) + screen->border + Titlebar(screen),
        !           471:                 screen->border, (scrolltop + i) * FontHeight(screen) +
        !           472:                 screen->border + Titlebar(screen), Width(screen),
        !           473:                 scrollheight * FontHeight(screen));
        !           474:        }
        !           475:        screen->topline = top;
        !           476:        XTileSet(VWindow(screen), screen->border, refreshtop * FontHeight(screen) +
        !           477:         screen->border + Titlebar(screen), Width(screen), lines *
        !           478:         FontHeight(screen), screen->bgndtile);
        !           479:        ScrnRefresh(screen, refreshtop, 0, lines, screen->max_col + 1);
        !           480: }
        !           481: 
        !           482: ScrollBarOn(screen, show, init)
        !           483:        register Screen *screen;
        !           484:        int show, init;
        !           485: {
        !           486:        register int border = 2 * screen->border;
        !           487:        register int i;
        !           488:        char *realloc(), *calloc();
        !           489: 
        !           490:        if(screen->scrollbar)
        !           491:                return;
        !           492:        if(!screen->sb) {
        !           493:                if((screen->sb = CreateScrollBar(VWindow(screen),
        !           494:                 Width(screen) + border, Titlebar(screen) - 1,
        !           495:                 Height(screen) + border, screen->foreground,
        !           496:                 screen->background, screen->bordertile, 0,
        !           497:                 screen->max_row + 1, 0, 0, screen->arrow)) == NULL) {
        !           498:                        Bell();
        !           499:                        return;
        !           500:                }
        !           501:                if((screen->allbuf = (ScrnBuf) realloc(screen->buf,
        !           502:                 2*(screen->max_row + 2 + screen->savelines) * sizeof(char *)))
        !           503:                 == NULL)
        !           504:                        Error (ERROR_SBRALLOC);
        !           505:                screen->buf = &screen->allbuf[2 * screen->savelines];
        !           506:                bcopy ((char *)screen->allbuf, (char *)screen->buf,
        !           507:                 2 * (screen->max_row + 2) * sizeof (char *));
        !           508:                for(i = 2 * screen->savelines - 1 ; i >= 0 ; i--)
        !           509:                        if((screen->allbuf[i] =
        !           510:                         calloc(screen->max_col + 1, sizeof(char))) == NULL)
        !           511:                                Error (ERROR_SBRALLOC2);
        !           512:                screen->sb->saveset = !screen->alternate;
        !           513:        } else {
        !           514:                XConfigureWindow(screen->sb->bar, FullWidth(screen),
        !           515:                 Titlebar(screen) - 1, (SCROLLBARWIDTH - 1),
        !           516:                 i = FullHeight(screen) - Titlebar(screen));
        !           517:                screen->sb->set.height = i - BARSTART;
        !           518:                screen->sb->set.regionheight = screen->max_row + 1;
        !           519:        }
        !           520:        if(show) {
        !           521:                screen->scrollbar = SCROLLBARWIDTH;
        !           522:                ShowScrollBar(screen->sb);
        !           523:                if(!init) {
        !           524:                        XSetResizeHint(VWindow(screen), border + SCROLLBARWIDTH,
        !           525:                         border + Titlebar(screen) + screen->statusheight,
        !           526:                         FontWidth(screen), FontHeight(screen));
        !           527:                        XChangeWindow(VWindow(screen), (screen->max_col + 1) *
        !           528:                         FontWidth(screen) + border + SCROLLBARWIDTH,
        !           529:                         FontHeight(screen) * (screen->max_row + 1) +
        !           530:                         screen->statusheight + border + Titlebar(screen));
        !           531:                }
        !           532:        }
        !           533: }
        !           534: 
        !           535: ScrollBarOff(screen)
        !           536:        register Screen *screen;
        !           537: {
        !           538:        register int border = 2 * screen->border;
        !           539: 
        !           540:        if(!screen->scrollbar)
        !           541:                return;
        !           542:        screen->sb->action = HIDE;
        !           543:        screen->scrollbar = 0;
        !           544:        XSetResizeHint(VWindow(screen), border, border + Titlebar(screen) +
        !           545:         screen->statusheight, FontWidth(screen), FontHeight(screen));
        !           546:        XChangeWindow(VWindow(screen), (screen->max_col + 1) * FontWidth(screen) +
        !           547:         border, FontHeight(screen) * (screen->max_row + 1) + screen->statusheight
        !           548:         + border + Titlebar(screen));
        !           549: }
        !           550: 
        !           551: ClearLinesOffTop(screen)
        !           552:        register Screen *screen;
        !           553: {
        !           554:        if(!screen->sb)
        !           555:                return;
        !           556:        if(screen->topline)
        !           557:                WindowScroll(screen, 0);
        !           558:        SetScrollBarTop(screen->sb, 0);
        !           559:        DrawScrollRegion(screen->sb);
        !           560: }
        !           561: 
        !           562: SetSaveState(sb, state)
        !           563:        register ScrollBar *sb;
        !           564:        int state;
        !           565: {
        !           566:        extern Terminal term;
        !           567:        register Screen *screen = &term.screen;
        !           568: 
        !           569:        if(screen->alternate)
        !           570:                return;
        !           571:        if(screen->scroll_amt)
        !           572:                FlushScroll(screen);
        !           573:        sb->saveset = state;
        !           574:        DrawSave(sb);
        !           575: }
        !           576: 
        !           577: SetButtonState(sb, state)
        !           578:        register ScrollBar *sb;
        !           579:        int state;
        !           580: {
        !           581:        sb->buttonset = state;
        !           582:        DrawButton(sb);
        !           583: }
        !           584: 
        !           585: static Window
        !           586: Make_tiled_window(bitmap_width, bitmap_height, bitmap_bits, foreground,
        !           587:  background, bgnd, parent, x, y, width, height, borderwidth, bordertile)
        !           588:        int bitmap_width, bitmap_height, foreground, background, x, y, width,
        !           589:         height, borderwidth;
        !           590:        short *bitmap_bits;
        !           591:        Window parent;
        !           592:        Pixmap *bgnd, bordertile;
        !           593: {
        !           594:        register Pixmap pix;
        !           595:        register Window w;
        !           596:        extern Pixmap Make_tile();
        !           597: 
        !           598:        if((pix = Make_tile(bitmap_width, bitmap_height, bitmap_bits,
        !           599:         foreground, background)) == NULL)
        !           600:                return(NULL);
        !           601:        w = XCreateWindow(parent, x, y, width, height, borderwidth, bordertile,
        !           602:         pix);
        !           603:        *bgnd = pix;
        !           604:        return(w);
        !           605: }
        !           606: 
        !           607: Pixmap
        !           608: Make_tile(bitmap_width, bitmap_height, bitmap_bits, foreground, background)
        !           609:        int bitmap_width, bitmap_height, foreground, background;
        !           610:        short *bitmap_bits;
        !           611: {
        !           612:        register Bitmap bm;
        !           613:        register Pixmap pix;
        !           614: 
        !           615:        if((bm = XStoreBitmap(bitmap_width, bitmap_height, bitmap_bits))
        !           616:         == NULL)
        !           617:                return(NULL);
        !           618:        pix = XMakePixmap(bm, foreground, background);
        !           619:        XFreeBitmap(bm);
        !           620:        return(pix);
        !           621: }
        !           622: 
        !           623: ScrollToBottom(sb)
        !           624: register ScrollBar *sb;
        !           625: {
        !           626:        SetScrollBarValue(sb, GetScrollBarBottom(sb));
        !           627:        DrawScrollRegion(sb);
        !           628:        WindowScroll(&term.screen, GetScrollBarValue(sb));
        !           629: }
        !           630: 
        !           631: #ifdef MODEMENU
        !           632: #define        SMENU_SCROLLKEY 0
        !           633: #define        SMENU_SCROLLINPUT (SMENU_SCROLLKEY+1)
        !           634: #define        SMENU_LINESTOP  (SMENU_SCROLLINPUT+1)
        !           635: #define        SMENU_LINE      (SMENU_LINESTOP+1)
        !           636: #define        SMENU_CLEARTOP  (SMENU_LINE+1)
        !           637: #define        SMENU_HIDE      (SMENU_CLEARTOP+1)
        !           638: 
        !           639: static char *stext[] = {
        !           640:        "Scroll to Bottom on Key",
        !           641:        "Scroll to Bottom on Input",
        !           642:        "Lines Off Top Saved",
        !           643:        "-",
        !           644:        "Clear Lines Off Top",
        !           645:        "Hide Scrollbar",
        !           646:        0,
        !           647: };
        !           648: 
        !           649: 
        !           650: static int salternate;
        !           651: static int slinestop;
        !           652: static int sscrollinput;
        !           653: static int sscrollkey;
        !           654: 
        !           655: Menu *ssetupmenu(menu)
        !           656: register Menu **menu;
        !           657: {
        !           658:        register Screen *screen = &term.screen;
        !           659:        register char **cp;
        !           660: 
        !           661:        if (*menu == NULL) {
        !           662:                if ((*menu = NewMenu("Scrollbar", re_verse)) == NULL)
        !           663:                        return(NULL);
        !           664:                for(cp = stext ; *cp ; cp++)
        !           665:                        AddMenuItem(*menu, *cp);
        !           666:                if(sscrollkey = screen->scrollkey)
        !           667:                        CheckItem(*menu, SMENU_SCROLLKEY);
        !           668:                if(sscrollinput = screen->scrollinput)
        !           669:                        CheckItem(*menu, SMENU_SCROLLINPUT);
        !           670:                if(slinestop = (screen->sb && GetSaveState(screen->sb)))
        !           671:                        CheckItem(*menu, SMENU_LINESTOP);
        !           672:                if(salternate = screen->alternate)
        !           673:                        DisableItem(*menu, SMENU_LINESTOP);
        !           674:                DisableItem(*menu, SMENU_LINE);
        !           675:                return(*menu);
        !           676:        }
        !           677:        if(sscrollkey != screen->scrollkey)
        !           678:                SetItemCheck(*menu, SMENU_SCROLLKEY, (sscrollkey =
        !           679:                 screen->scrollkey));
        !           680:        if(sscrollinput != screen->scrollinput)
        !           681:                SetItemCheck(*menu, SMENU_SCROLLINPUT, (sscrollinput =
        !           682:                 screen->scrollinput));
        !           683:        if(screen->sb && slinestop != GetSaveState(screen->sb))
        !           684:                SetItemCheck(*menu, SMENU_LINESTOP, (slinestop =
        !           685:                 GetSaveState(screen->sb)));
        !           686:        if(salternate != screen->alternate)
        !           687:                SetItemDisable(*menu, SMENU_LINESTOP, (salternate =
        !           688:                 screen->alternate));
        !           689:        return(*menu);
        !           690: }
        !           691: 
        !           692: sdomenufunc(item)
        !           693: int item;
        !           694: {
        !           695:        register Screen *screen = &term.screen;
        !           696: 
        !           697:        switch (item) {
        !           698:         case SMENU_SCROLLKEY:
        !           699:                screen->scrollkey = !screen->scrollkey;
        !           700:                break;
        !           701: 
        !           702:         case SMENU_SCROLLINPUT:
        !           703:                screen->scrollinput = !screen->scrollinput;
        !           704:                break;
        !           705: 
        !           706:         case SMENU_LINESTOP:
        !           707:                SetSaveState(screen->sb, !GetSaveState(screen->sb));
        !           708:                break;
        !           709: 
        !           710:         case SMENU_CLEARTOP:
        !           711:                ClearLinesOffTop(screen);
        !           712:                break;
        !           713: 
        !           714:         case SMENU_HIDE:
        !           715:                ScrollBarOff(screen);
        !           716:                break;
        !           717:        }
        !           718: }
        !           719: #endif MODEMENU

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