1 /* Copyright (c) 1980 Regents of the University of California */ 2 static char *sccsid = "@(#)ex_vwind.c 5.1 08/20/80"; 3 #include "ex.h" 4 #include "ex_tty.h" 5 #include "ex_vis.h" 6 7 /* 8 * Routines to adjust the window, showing specified lines 9 * in certain positions on the screen, and scrolling in both 10 * directions. Code here is very dependent on mode (open versus visual). 11 */ 12 13 /* 14 * Move in a nonlocal way to line addr. 15 * If it isn't on screen put it in specified context. 16 * New position for cursor is curs. 17 * Like most routines here, we vsave(). 18 */ 19 vmoveto(addr, curs, context) 20 register line *addr; 21 char *curs; 22 char context; 23 { 24 25 markit(addr); 26 vsave(); 27 vjumpto(addr, curs, context); 28 } 29 30 /* 31 * Vjumpto is like vmoveto, but doesn't mark previous 32 * context or save linebuf as current line. 33 */ 34 vjumpto(addr, curs, context) 35 register line *addr; 36 char *curs; 37 char context; 38 { 39 40 noteit(0); 41 if (context != 0) 42 vcontext(addr, context); 43 else 44 vshow(addr, NOLINE); 45 noteit(1); 46 vnline(curs); 47 } 48 49 /* 50 * Go up or down cnt (negative is up) to new position curs. 51 */ 52 vupdown(cnt, curs) 53 register int cnt; 54 char *curs; 55 { 56 57 if (cnt > 0) 58 vdown(cnt, 0, 0); 59 else if (cnt < 0) 60 vup(-cnt, 0, 0); 61 if (vcnt == 0) 62 vrepaint(curs); 63 else 64 vnline(curs); 65 } 66 67 /* 68 * Go up cnt lines, afterwards preferring to be ind 69 * logical lines from the top of the screen. 70 * If scroll, then we MUST use a scroll. 71 * Otherwise clear and redraw if motion is far. 72 */ 73 vup(cnt, ind, scroll) 74 register int cnt, ind; 75 bool scroll; 76 { 77 register int i, tot; 78 79 if (dot == one) { 80 beep(); 81 return; 82 } 83 vsave(); 84 i = lineDOT() - 1; 85 if (cnt > i) { 86 ind -= cnt - i; 87 if (ind < 0) 88 ind = 0; 89 cnt = i; 90 } 91 if (!scroll && cnt <= vcline) { 92 vshow(dot - cnt, NOLINE); 93 return; 94 } 95 cnt -= vcline, dot -= vcline, vcline = 0; 96 if (hold & HOLDWIG) 97 goto contxt; 98 if (state == VISUAL && !AL && !SR && 99 cnt <= WTOP - ZERO && vfit(dot - cnt, cnt) <= WTOP - ZERO) 100 goto okr; 101 tot = WECHO - ZERO; 102 if (state != VISUAL || (!AL && !SR) || (!scroll && (cnt > tot || vfit(dot - cnt, cnt) > tot / 3 + 1))) { 103 if (ind > basWLINES / 2) 104 ind = basWLINES / 3; 105 contxt: 106 vcontext(dot + ind - cnt, '.'); 107 return; 108 } 109 okr: 110 vrollR(cnt); 111 if (scroll) { 112 vcline += ind, dot += ind; 113 if (vcline >= vcnt) 114 dot -= vcline - vcnt + 1, vcline = vcnt - 1; 115 getDOT(); 116 } 117 } 118 119 /* 120 * Like vup, but scrolling down. 121 */ 122 vdown(cnt, ind, scroll) 123 register int cnt, ind; 124 bool scroll; 125 { 126 register int i, tot; 127 128 if (dot == dol) { 129 beep(); 130 return; 131 } 132 vsave(); 133 i = dol - dot; 134 if (cnt > i) { 135 ind -= cnt - i; 136 if (ind < 0) 137 ind = 0; 138 cnt = i; 139 } 140 i = vcnt - vcline - 1; 141 if (!scroll && cnt <= i) { 142 vshow(dot + cnt, NOLINE); 143 return; 144 } 145 cnt -= i, dot += i, vcline += i; 146 if (hold & HOLDWIG) 147 goto dcontxt; 148 if (!scroll) { 149 tot = WECHO - ZERO; 150 if (state != VISUAL || cnt - tot > 0 || vfit(dot, cnt) > tot / 3 + 1) { 151 dcontxt: 152 vcontext(dot + cnt, '.'); 153 return; 154 } 155 } 156 if (cnt > 0) 157 vroll(cnt); 158 if (state == VISUAL && scroll) { 159 vcline -= ind, dot -= ind; 160 if (vcline < 0) 161 dot -= vcline, vcline = 0; 162 getDOT(); 163 } 164 } 165 166 /* 167 * Show line addr in context where on the screen. 168 * Work here is in determining new top line implied by 169 * this placement of line addr, since we always draw from the top. 170 */ 171 vcontext(addr, where) 172 register line *addr; 173 char where; 174 { 175 register line *top; 176 177 getline(*addr); 178 if (state != VISUAL) 179 top = addr; 180 else switch (where) { 181 182 case '^': 183 addr = vback(addr, basWLINES - vdepth()); 184 getline(*addr); 185 /* fall into ... */ 186 187 case '-': 188 top = vback(addr, basWLINES - vdepth()); 189 getline(*addr); 190 break; 191 192 case '.': 193 top = vback(addr, basWLINES / 2 - vdepth()); 194 getline(*addr); 195 break; 196 197 default: 198 top = addr; 199 break; 200 } 201 if (state == ONEOPEN && LINE(0) == WBOT) 202 vup1(); 203 vcnt = vcline = 0; 204 vclean(); 205 if (state == CRTOPEN) 206 vup1(); 207 vshow(addr, top); 208 } 209 210 /* 211 * Get a clean line. If we are in a hard open 212 * we may be able to reuse the line we are on 213 * if it is blank. This is a real win. 214 */ 215 vclean() 216 { 217 218 if (state != VISUAL && state != CRTOPEN) { 219 destcol = 0; 220 if (!ateopr()) 221 vup1(); 222 vcnt = 0; 223 } 224 } 225 226 /* 227 * Show line addr with the specified top line on the screen. 228 * Top may be 0; in this case have vcontext compute the top 229 * (and call us recursively). Eventually, we clear the screen 230 * (or its open mode equivalent) and redraw. 231 */ 232 vshow(addr, top) 233 line *addr, *top; 234 { 235 #ifndef CBREAK 236 register bool fried = 0; 237 #endif 238 register int cnt = addr - dot; 239 register int i = vcline + cnt; 240 short oldhold = hold; 241 242 if (state != HARDOPEN && state != ONEOPEN && i >= 0 && i < vcnt) { 243 dot = addr; 244 getDOT(); 245 vcline = i; 246 return; 247 } 248 if (state != VISUAL) { 249 dot = addr; 250 vopen(dot, WBOT); 251 return; 252 } 253 if (top == 0) { 254 vcontext(addr, '.'); 255 return; 256 } 257 dot = top; 258 #ifndef CBREAK 259 if (vcookit(2)) 260 fried++, vcook(); 261 #endif 262 oldhold = hold; 263 hold |= HOLDAT; 264 vclear(); 265 vreset(0); 266 vredraw(WTOP); 267 /* error if vcline >= vcnt ! */ 268 vcline = addr - top; 269 dot = addr; 270 getDOT(); 271 hold = oldhold; 272 vsync(LASTLINE); 273 #ifndef CBREAK 274 if (fried) 275 flusho(), vraw(); 276 #endif 277 } 278 279 /* 280 * reset the state. 281 * If inecho then leave us at the beginning of the echo 282 * area; we are called this way in the middle of a :e escape 283 * from visual, e.g. 284 */ 285 vreset(inecho) 286 bool inecho; 287 { 288 289 vcnt = vcline = 0; 290 WTOP = basWTOP; 291 WLINES = basWLINES; 292 if (inecho) 293 splitw = 1, vgoto(WECHO, 0); 294 } 295 296 /* 297 * Starting from which line preceding tp uses almost (but not more 298 * than) cnt physical lines? 299 */ 300 line * 301 vback(tp, cnt) 302 register int cnt; 303 register line *tp; 304 { 305 register int d; 306 307 if (cnt > 0) 308 for (; tp > one; tp--) { 309 getline(tp[-1]); 310 d = vdepth(); 311 if (d > cnt) 312 break; 313 cnt -= d; 314 } 315 return (tp); 316 } 317 318 /* 319 * How much scrolling will it take to roll cnt lines starting at tp? 320 */ 321 vfit(tp, cnt) 322 register line *tp; 323 int cnt; 324 { 325 register int j; 326 327 j = 0; 328 while (cnt > 0) { 329 cnt--; 330 getline(tp[cnt]); 331 j += vdepth(); 332 } 333 if (tp > dot) 334 j -= WBOT - LASTLINE; 335 return (j); 336 } 337 338 /* 339 * Roll cnt lines onto the screen. 340 */ 341 vroll(cnt) 342 register int cnt; 343 { 344 #ifndef CBREAK 345 register bool fried = 0; 346 #endif 347 short oldhold = hold; 348 349 #ifdef ADEBUG 350 if (trace) 351 tfixnl(), fprintf(trace, "vroll(%d)\n", cnt); 352 #endif 353 if (state != VISUAL) 354 hold |= HOLDAT|HOLDROL; 355 if (WBOT == WECHO) { 356 vcnt = 0; 357 if (state == ONEOPEN) 358 vup1(); 359 } 360 #ifndef CBREAK 361 if (vcookit(cnt)) 362 fried++, vcook(); 363 #endif 364 for (; cnt > 0 && Peekkey != ATTN; cnt--) { 365 dot++, vcline++; 366 vopen(dot, LASTLINE); 367 vscrap(); 368 } 369 hold = oldhold; 370 if (state == HARDOPEN) 371 sethard(); 372 vsyncCL(); 373 #ifndef CBREAK 374 if (fried) 375 flusho(), vraw(); 376 #endif 377 } 378 379 /* 380 * Roll backwards (scroll up). 381 */ 382 vrollR(cnt) 383 register int cnt; 384 { 385 register bool fried = 0; 386 short oldhold = hold; 387 388 #ifdef ADEBUG 389 if (trace) 390 tfixnl(), fprintf(trace, "vrollR(%d), dot=%d\n", cnt, lineDOT()); 391 #endif 392 #ifndef CBREAK 393 if (vcookit(cnt)) 394 fried++, vcook(); 395 #endif 396 if (WBOT == WECHO) 397 vcnt = 0; 398 heldech = 0; 399 hold |= HOLDAT|HOLDECH; 400 for (; cnt > 0 && Peekkey != ATTN; cnt--) { 401 dot--; 402 vopen(dot, WTOP); 403 vscrap(); 404 } 405 hold = oldhold; 406 if (heldech) 407 vclrech(0); 408 vsync(LINE(vcnt-1)); 409 #ifndef CBREAK 410 if (fried) 411 flusho(), vraw(); 412 #endif 413 } 414 415 /* 416 * Go into cooked mode (allow interrupts) during 417 * a scroll if we are at less than 1200 baud and not 418 * a 'vi' command, of if we are in a 'vi' command and the 419 * scroll is more than 2 full screens. 420 * 421 * BUG: An interrupt during a scroll in this way 422 * dumps to command mode. 423 */ 424 vcookit(cnt) 425 register int cnt; 426 { 427 428 return (cnt > 1 && (ospeed < B1200 && !initev || cnt > LINES * 2)); 429 } 430 431 /* 432 * Determine displayed depth of current line. 433 */ 434 vdepth() 435 { 436 register int d; 437 438 d = (column(NOSTR) + WCOLS - 1 + (Putchar == listchar) + IN) / WCOLS; 439 #ifdef ADEBUG 440 if (trace) 441 tfixnl(), fprintf(trace, "vdepth returns %d\n", d == 0 ? 1 : d); 442 #endif 443 return (d == 0 ? 1 : d); 444 } 445 446 /* 447 * Move onto a new line, with cursor at position curs. 448 */ 449 vnline(curs) 450 char *curs; 451 { 452 453 if (curs) 454 wcursor = curs; 455 else if (vmoving) 456 wcursor = vfindcol(vmovcol); 457 else 458 wcursor = vskipwh(linebuf); 459 cursor = linebuf; 460 vmove(); 461 } 462