1 /* $NetBSD: fancy.c,v 1.20 2024/11/29 21:48:44 dholland Exp $ */ 2 3 /* 4 * Copyright (c) 1980, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 #if 0 35 static char sccsid[] = "@(#)fancy.c 8.1 (Berkeley) 5/31/93"; 36 #else 37 __RCSID("$NetBSD: fancy.c,v 1.20 2024/11/29 21:48:44 dholland Exp $"); 38 #endif 39 #endif /* not lint */ 40 41 #include "back.h" 42 43 static void bsect(int, int, int, int); 44 static void fixpos(int, int, int, int, int); 45 static void fixcol(int, int, int, int, int); 46 static void newline(void); 47 48 /* 49 * These need to be declared so they come out as commons, because 50 * termcap might or might not define some of them. Our termcap defines 51 * PC, BC, and UP only. This is gross. 52 * 53 * XXX: rewrite this crap using curses. 54 */ 55 #if 0 56 char PC; /* padding character */ 57 char *BC; /* backspace sequence */ 58 #endif 59 static char *CD; /* clear to end of screen sequence */ 60 static char *CE; /* clear to end of line sequence */ 61 static char *CL; /* clear screen sequence */ 62 static char *CM; /* cursor movement instructions */ 63 static char *HO; /* home cursor sequence */ 64 static char *MC; /* column cursor movement map */ 65 static char *ML; /* row cursor movement map */ 66 static char *ND; /* forward cursor sequence */ 67 #if 0 68 char *UP; /* up cursor sequence */ 69 #endif 70 71 static int lHO; /* length of HO */ 72 static int lBC; /* length of BC */ 73 static int lND; /* length of ND */ 74 static int lUP; /* length of UP */ 75 static int CO; /* number of columns */ 76 static int LI; /* number of lines */ 77 static int *linect; /* array of lengths of lines on screen (the 78 * actual screen is not stored) */ 79 80 /* two letter codes */ 81 static char tcap[] = "bccdceclcmhomcmlndup"; 82 /* corresponding strings */ 83 static char **tstr[] = {&BC, &CD, &CE, &CL, &CM, &HO, &MC, &ML, &ND, &UP}; 84 85 static char tbuf[1024]; /* buffer for decoded termcap entries */ 86 87 static int oldb[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88 0, 0, 0, 0, 0, 0}; 89 90 static int oldr; 91 static int oldw; 92 /* "real" cursor positions, so it knows when to reposition. These are -1 if 93 * curr and curc are accurate */ 94 static int realr; 95 static int realc; 96 97 void 98 fboard(void) 99 { 100 int i, j, l; 101 102 curmove(0, 0); /* do top line */ 103 for (i = 0; i < 53; i++) 104 fancyc('_'); 105 106 curmove(15, 0); /* do bottom line */ 107 for (i = 0; i < 53; i++) 108 fancyc('_'); 109 110 l = 1; /* do vertical lines */ 111 for (i = 52; i > -1; i -= 28) { 112 curmove((l == 1 ? 1 : 15), i); 113 fancyc('|'); 114 for (j = 0; j < 14; j++) { 115 curmove(curr + l, curc - 1); 116 fancyc('|'); 117 } 118 if (i == 24) 119 i += 32; 120 l = -l; /* alternate directions */ 121 } 122 123 curmove(2, 1); /* label positions 13-18 */ 124 for (i = 13; i < 18; i++) { 125 fancyc('1'); 126 fancyc((i % 10) + '0'); 127 curmove(curr, curc + 2); 128 } 129 fancyc('1'); 130 fancyc('8'); 131 132 curmove(2, 29); /* label positions 19-24 */ 133 fancyc('1'); 134 fancyc('9'); 135 for (i = 20; i < 25; i++) { 136 curmove(curr, curc + 2); 137 fancyc('2'); 138 fancyc((i % 10) + '0'); 139 } 140 141 curmove(14, 1); /* label positions 12-7 */ 142 fancyc('1'); 143 fancyc('2'); 144 for (i = 11; i > 6; i--) { 145 curmove(curr, curc + 2); 146 fancyc(i > 9 ? '1' : ' '); 147 fancyc((i % 10) + '0'); 148 } 149 150 curmove(14, 30); /* label positions 6-1 */ 151 fancyc('6'); 152 for (i = 5; i > 0; i--) { 153 curmove(curr, curc + 3); 154 fancyc(i + '0'); 155 } 156 157 for (i = 12; i > 6; i--)/* print positions 12-7 */ 158 if (board[i]) 159 bsect(board[i], 13, 1 + 4 * (12 - i), -1); 160 161 if (board[0]) /* print red men on bar */ 162 bsect(board[0], 13, 25, -1); 163 164 for (i = 6; i > 0; i--) /* print positions 6-1 */ 165 if (board[i]) 166 bsect(board[i], 13, 29 + 4 * (6 - i), -1); 167 168 l = (off[1] < 0 ? off[1] + 15 : off[1]); /* print white's home */ 169 bsect(l, 3, 54, 1); 170 171 curmove(8, 25); /* print the word BAR */ 172 fancyc('B'); 173 fancyc('A'); 174 fancyc('R'); 175 176 for (i = 13; i < 19; i++) /* print positions 13-18 */ 177 if (board[i]) 178 bsect(board[i], 3, 1 + 4 * (i - 13), 1); 179 180 if (board[25]) /* print white's men on bar */ 181 bsect(board[25], 3, 25, 1); 182 183 for (i = 19; i < 25; i++) /* print positions 19-24 */ 184 if (board[i]) 185 bsect(board[i], 3, 29 + 4 * (i - 19), 1); 186 187 l = (off[0] < 0 ? off[0] + 15 : off[0]); /* print red's home */ 188 bsect(-l, 13, 54, -1); 189 190 for (i = 0; i < 26; i++)/* save board position for refresh later */ 191 oldb[i] = board[i]; 192 oldr = (off[1] < 0 ? off[1] + 15 : off[1]); 193 oldw = -(off[0] < 0 ? off[0] + 15 : off[0]); 194 } 195 /* 196 * bsect (b,rpos,cpos,cnext) 197 * Print the contents of a board position. "b" has the value of the 198 * position, "rpos" is the row to start printing, "cpos" is the column to 199 * start printing, and "cnext" is positive if the position starts at the top 200 * and negative if it starts at the bottom. The value of "cpos" is checked 201 * to see if the position is a player's home, since those are printed 202 * differently. 203 */ 204 static void 205 bsect(int b, int rpos, int cpos, int cnext) 206 { 207 int j; /* index */ 208 int n; /* number of men on position */ 209 int bct; /* counter */ 210 int k; /* index */ 211 char pc; /* color of men on position */ 212 213 bct = 0; 214 n = abs(b); /* initialize n and pc */ 215 pc = (b > 0 ? 'r' : 'w'); 216 217 if (n < 6 && cpos < 54) /* position cursor at start */ 218 curmove(rpos, cpos + 1); 219 else 220 curmove(rpos, cpos); 221 222 for (j = 0; j < 5; j++) { /* print position row by row */ 223 224 for (k = 0; k < 15; k += 5) /* print men */ 225 if (n > j + k) 226 fancyc(pc); 227 228 if (j < 4) { /* figure how far to back up for next row */ 229 if (n < 6) { /* stop if none left */ 230 if (j + 1 == n) 231 break; 232 bct = 1; /* single column */ 233 } else { 234 if (n < 11) { /* two columns */ 235 if (cpos == 54) { /* home pos */ 236 if (j + 5 >= n) 237 bct = 1; 238 else 239 bct = 2; 240 } 241 if (cpos < 54) { /* not home */ 242 if (j + 6 >= n) 243 bct = 1; 244 else 245 bct = 2; 246 } 247 } else { /* three columns */ 248 if (j + 10 >= n) 249 bct = 2; 250 else 251 bct = 3; 252 } 253 } 254 /* reposition cursor */ 255 curmove(curr + cnext, curc - bct); 256 } 257 } 258 } 259 260 void 261 refresh(void) 262 { 263 int i, r, c; 264 265 r = curr; /* save current position */ 266 c = curc; 267 268 for (i = 12; i > 6; i--)/* fix positions 12-7 */ 269 if (board[i] != oldb[i]) { 270 fixpos(oldb[i], board[i], 13, 1 + (12 - i) * 4, -1); 271 oldb[i] = board[i]; 272 } 273 if (board[0] != oldb[0]) { /* fix red men on bar */ 274 fixpos(oldb[0], board[0], 13, 25, -1); 275 oldb[0] = board[0]; 276 } 277 for (i = 6; i > 0; i--) /* fix positions 6-1 */ 278 if (board[i] != oldb[i]) { 279 fixpos(oldb[i], board[i], 13, 29 + (6 - i) * 4, -1); 280 oldb[i] = board[i]; 281 } 282 i = -(off[0] < 0 ? off[0] + 15 : off[0]); /* fix white's home */ 283 if (oldw != i) { 284 fixpos(oldw, i, 13, 54, -1); 285 oldw = i; 286 } 287 for (i = 13; i < 19; i++) /* fix positions 13-18 */ 288 if (board[i] != oldb[i]) { 289 fixpos(oldb[i], board[i], 3, 1 + (i - 13) * 4, 1); 290 oldb[i] = board[i]; 291 } 292 if (board[25] != oldb[25]) { /* fix white men on bar */ 293 fixpos(oldb[25], board[25], 3, 25, 1); 294 oldb[25] = board[25]; 295 } 296 for (i = 19; i < 25; i++) /* fix positions 19-24 */ 297 if (board[i] != oldb[i]) { 298 fixpos(oldb[i], board[i], 3, 29 + (i - 19) * 4, 1); 299 oldb[i] = board[i]; 300 } 301 i = (off[1] < 0 ? off[1] + 15 : off[1]); /* fix red's home */ 302 if (oldr != i) { 303 fixpos(oldr, i, 3, 54, 1); 304 oldr = i; 305 } 306 curmove(r, c); /* return to saved position */ 307 newpos(); 308 buflush(); 309 } 310 311 static void 312 fixpos(int cur, int new, int r, int c, int inc) 313 { 314 int o, n, nv; 315 int ov, nc; 316 char col; 317 318 nc = 0; 319 if (cur * new >= 0) { 320 ov = abs(cur); 321 nv = abs(new); 322 col = (cur + new > 0 ? 'r' : 'w'); 323 o = (ov - 1) / 5; 324 n = (nv - 1) / 5; 325 if (o == n) { 326 if (o == 2) 327 nc = c + 2; 328 if (o == 1) 329 nc = c < 54 ? c : c + 1; 330 if (o == 0) 331 nc = c < 54 ? c + 1 : c; 332 if (ov > nv) 333 fixcol(r + inc * (nv - n * 5), nc, 334 abs(ov - nv), ' ', inc); 335 else 336 fixcol(r + inc * (ov - o * 5), nc, 337 abs(ov - nv), col, inc); 338 return; 339 } else { 340 if (c < 54) { 341 if (o + n == 1) { 342 if (n) { 343 fixcol(r, c, abs(nv - 5), col, 344 inc); 345 if (ov != 5) 346 fixcol(r + inc * ov, 347 c + 1, abs(ov - 5), 348 col, inc); 349 } else { 350 fixcol(r, c, abs(ov - 5), ' ', 351 inc); 352 if (nv != 5) 353 fixcol(r + inc * nv, 354 c + 1, abs(nv - 5), 355 ' ', inc); 356 } 357 return; 358 } 359 if (n == 2) { 360 if (ov != 10) 361 fixcol(r + inc * (ov - 5), c, 362 abs(ov - 10), col, inc); 363 fixcol(r, c + 2, abs(nv - 10), col, 364 inc); 365 } else { 366 if (nv != 10) 367 fixcol(r + inc * (nv - 5), c, 368 abs(nv - 10), ' ', inc); 369 fixcol(r, c + 2, abs(ov - 10), ' ', 370 inc); 371 } 372 return; 373 } 374 if (n > o) { 375 fixcol(r + inc * (ov % 5), c + o, 376 abs(5 * n - ov), col, inc); 377 if (nv != 5 * n) 378 fixcol(r, c + n, abs(5 * n - nv), 379 col, inc); 380 } else { 381 fixcol(r + inc * (nv % 5), c + n, 382 abs(5 * n - nv), ' ', inc); 383 if (ov != 5 * o) 384 fixcol(r, c + o, abs(5 * o - ov), 385 ' ', inc); 386 } 387 return; 388 } 389 } 390 nv = abs(new); 391 fixcol(r, c + 1, nv, new > 0 ? 'r' : 'w', inc); 392 if (abs(cur) <= abs(new)) 393 return; 394 fixcol(r + inc * new, c + 1, abs(cur + new), ' ', inc); 395 } 396 397 static void 398 fixcol(int r, int c, int l, int ch, int inc) 399 { 400 int i; 401 402 curmove(r, c); 403 fancyc(ch); 404 for (i = 1; i < l; i++) { 405 curmove(curr + inc, curc - 1); 406 fancyc(ch); 407 } 408 } 409 410 void 411 curmove(int r, int c) 412 { 413 if (curr == r && curc == c) 414 return; 415 if (realr == -1) { 416 realr = curr; 417 realc = curc; 418 } 419 curr = r; 420 curc = c; 421 } 422 423 void 424 newpos(void) 425 { 426 int r; /* destination row */ 427 int c; /* destination column */ 428 int mode = -1; /* mode of movement */ 429 430 int ccount = 1000; /* character count */ 431 int i; /* index */ 432 int n; /* temporary variable */ 433 char *m; /* string containing CM movement */ 434 435 436 m = NULL; 437 if (realr == -1) /* see if already there */ 438 return; 439 440 r = curr; /* set current and dest. positions */ 441 c = curc; 442 curr = realr; 443 curc = realc; 444 445 /* double check position */ 446 if (curr == r && curc == c) { 447 realr = realc = -1; 448 return; 449 } 450 if (CM) { /* try CM to get there */ 451 mode = 0; 452 m = (char *) tgoto(CM, c, r); 453 ccount = (int)strlen(m); 454 } 455 /* try HO and local movement */ 456 if (HO && (n = r + c * lND + lHO) < ccount) { 457 mode = 1; 458 ccount = n; 459 } 460 /* try various LF combinations */ 461 if (r >= curr) { 462 /* CR, LF, and ND */ 463 if ((n = (r - curr) + c * lND + 1) < ccount) { 464 mode = 2; 465 ccount = n; 466 } 467 /* LF, ND */ 468 if (c >= curc && (n = (r - curr) + (c - curc) * lND) < ccount) { 469 mode = 3; 470 ccount = n; 471 } 472 /* LF, BS */ 473 if (c < curc && (n = (r - curr) + (curc - c) * lBC) < ccount) { 474 mode = 4; 475 ccount = n; 476 } 477 } 478 /* try corresponding UP combinations */ 479 if (r < curr) { 480 /* CR, UP, and ND */ 481 if ((n = (curr - r) * lUP + c * lND + 1) < ccount) { 482 mode = 5; 483 ccount = n; 484 } 485 /* UP and ND */ 486 if (c >= curc && 487 (n = (curr - r) * lUP + (c - curc) * lND) < ccount) { 488 mode = 6; 489 ccount = n; 490 } 491 /* UP and BS */ 492 if (c < curc && 493 (n = (curr - r) * lUP + (curc - c) * lBC) < ccount) { 494 mode = 7; 495 ccount = n; 496 } 497 } 498 /* space over */ 499 if (curr == r && c > curc && linect[r] < curc && c - curc < ccount) 500 mode = 8; 501 502 switch (mode) { 503 504 case -1: /* error! */ 505 write(2, "\r\nInternal cursor error.\r\n", 26); 506 getout(0); 507 /* NOTREACHED */ 508 509 /* direct cursor motion */ 510 case 0: 511 tputs(m, abs(curr - r), addbuf); 512 break; 513 514 /* relative to "home" */ 515 case 1: 516 tputs(HO, r, addbuf); 517 for (i = 0; i < r; i++) 518 addbuf('\012'); 519 for (i = 0; i < c; i++) 520 tputs(ND, 1, addbuf); 521 break; 522 523 /* CR and down and over */ 524 case 2: 525 addbuf('\015'); 526 for (i = 0; i < r - curr; i++) 527 addbuf('\012'); 528 for (i = 0; i < c; i++) 529 tputs(ND, 1, addbuf); 530 break; 531 532 /* down and over */ 533 case 3: 534 for (i = 0; i < r - curr; i++) 535 addbuf('\012'); 536 for (i = 0; i < c - curc; i++) 537 tputs(ND, 1, addbuf); 538 break; 539 540 /* down and back */ 541 case 4: 542 for (i = 0; i < r - curr; i++) 543 addbuf('\012'); 544 for (i = 0; i < curc - c; i++) 545 addbuf('\010'); 546 break; 547 548 /* CR and up and over */ 549 case 5: 550 addbuf('\015'); 551 for (i = 0; i < curr - r; i++) 552 tputs(UP, 1, addbuf); 553 for (i = 0; i < c; i++) 554 tputs(ND, 1, addbuf); 555 break; 556 557 /* up and over */ 558 case 6: 559 for (i = 0; i < curr - r; i++) 560 tputs(UP, 1, addbuf); 561 for (i = 0; i < c - curc; i++) 562 tputs(ND, 1, addbuf); 563 break; 564 565 /* up and back */ 566 case 7: 567 for (i = 0; i < curr - r; i++) 568 tputs(UP, 1, addbuf); 569 for (i = 0; i < curc - c; i++) { 570 if (BC) 571 tputs(BC, 1, addbuf); 572 else 573 addbuf('\010'); 574 } 575 break; 576 577 /* safe space */ 578 case 8: 579 for (i = 0; i < c - curc; i++) 580 addbuf(' '); 581 } 582 583 /* fix positions */ 584 curr = r; 585 curc = c; 586 realr = -1; 587 realc = -1; 588 } 589 590 void 591 clear(void) 592 { 593 int i; 594 595 /* double space if can't clear */ 596 if (CL == NULL) { 597 writel("\n\n"); 598 return; 599 } 600 curr = curc = 0; /* fix position markers */ 601 realr = realc = -1; 602 for (i = 0; i < 24; i++)/* clear line counts */ 603 linect[i] = -1; 604 buffnum = -1; /* ignore leftover buffer contents */ 605 tputs(CL, CO, addbuf); /* put CL in buffer */ 606 } 607 608 void 609 fancyc(int c) 610 { 611 int sp; /* counts spaces in a tab */ 612 613 if (c == '\007') { /* bells go in blindly */ 614 addbuf(c); 615 return; 616 } 617 /* process tabs, use spaces if the tab should be erasing things, 618 * otherwise use cursor movement routines. Note this does not use 619 * hardware tabs at all. */ 620 if (c == '\t') { 621 sp = (curc + 8) & (~7); /* compute spaces */ 622 /* check line length */ 623 if (linect[curr] >= curc || sp < 4) { 624 for (; sp > curc; sp--) 625 addbuf(' '); 626 curc = sp; /* fix curc */ 627 } else 628 curmove(curr, sp); 629 return; 630 } 631 /* do newline be calling newline */ 632 if (c == '\n') { 633 newline(); 634 return; 635 } 636 /* ignore any other control chars */ 637 if (c < ' ') 638 return; 639 640 /* if an erasing space or non-space, just add it to buffer. Otherwise 641 * use cursor movement routine, so that multiple spaces will be 642 * grouped together */ 643 if (c > ' ' || linect[curr] >= curc) { 644 newpos(); /* make sure position correct */ 645 addbuf(c); /* add character to buffer */ 646 /* fix line length */ 647 if (c == ' ' && linect[curr] == curc) 648 linect[curr]--; 649 else 650 if (linect[curr] < curc) 651 linect[curr] = curc; 652 curc++; /* fix curc */ 653 } else 654 /* use cursor movement routine */ 655 curmove(curr, curc + 1); 656 } 657 658 void 659 clend(void) 660 { 661 int i; 662 663 if (CD) { 664 tputs(CD, CO - curr, addbuf); 665 for (i = curr; i < LI; i++) 666 linect[i] = -1; 667 return; 668 } 669 curmove(i = curr, 0); 670 cline(); 671 while (curr < LI - 1) { 672 curmove(curr + 1, 0); 673 if (linect[curr] > -1) 674 cline(); 675 } 676 curmove(i, 0); 677 } 678 679 void 680 cline(void) 681 { 682 int c; 683 684 if (curc > linect[curr]) 685 return; 686 newpos(); 687 if (CE) { 688 tputs(CE, 1, addbuf); 689 linect[curr] = curc - 1; 690 } else { 691 c = curc - 1; 692 while (linect[curr] > c) { 693 addbuf(' '); 694 curc++; 695 linect[curr]--; 696 } 697 curmove(curr, c + 1); 698 } 699 } 700 701 static void 702 newline(void) 703 { 704 cline(); 705 if (curr == LI - 1) 706 curmove(begscr, 0); 707 else 708 curmove(curr + 1, 0); 709 } 710 711 int 712 getcaps(const char *s) 713 { 714 char *code; /* two letter code */ 715 char ***cap; /* pointer to cap string */ 716 char *bufp; /* pointer to cap buffer */ 717 char tentry[1024]; /* temporary uncoded caps buffer */ 718 719 tgetent(tentry, s); /* get uncoded termcap entry */ 720 721 LI = tgetnum("li"); /* get number of lines */ 722 if (LI == -1) 723 LI = 12; 724 CO = tgetnum("co"); /* get number of columns */ 725 if (CO == -1) 726 CO = 65; 727 728 bufp = tbuf; /* get padding character */ 729 tgetstr("pc", &bufp); 730 if (bufp != tbuf) 731 PC = *tbuf; 732 else 733 PC = 0; 734 735 bufp = tbuf; /* get string entries */ 736 cap = tstr; 737 for (code = tcap; *code; code += 2) 738 **cap++ = (char *) tgetstr(code, &bufp); 739 740 /* get pertinent lengths */ 741 if (HO) 742 lHO = (int)strlen(HO); 743 if (BC) 744 lBC = (int)strlen(BC); 745 else 746 lBC = 1; 747 if (UP) 748 lUP = (int)strlen(UP); 749 if (ND) 750 lND = (int)strlen(ND); 751 if (LI < 24 || CO < 72 || !(CL && UP && ND)) { 752 /* force CL to null because this is what's tested in clear() */ 753 CL = NULL; 754 return (0); 755 } 756 linect = (int *) calloc(LI + 1, sizeof(int)); 757 if (linect == NULL) { 758 write(2, "\r\nOut of memory!\r\n", 18); 759 getout(0); 760 } 761 return (1); 762 } 763
Indexes created Sat Sep 20 22:09:52 GMT 2025