![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scrollbar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xterm|
Return to scrollbar.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xterm |
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.