1 /* $NetBSD: refresh.c,v 1.76 2012/04/21 11:33:16 blymn Exp $ */ 2 3 /* 4 * Copyright (c) 1981, 1993, 1994 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[] = "@(#)refresh.c 8.7 (Berkeley) 8/13/94"; 36 #else 37 __RCSID("$NetBSD: refresh.c,v 1.76 2012/04/21 11:33:16 blymn Exp $"); 38 #endif 39 #endif /* not lint */ 40 41 #include <stdlib.h> 42 #include <string.h> 43 44 #include "curses.h" 45 #include "curses_private.h" 46 47 static void domvcur(int, int, int, int); 48 static int makech(int); 49 static void quickch(void); 50 static void scrolln(int, int, int, int, int); 51 52 static int _cursesi_wnoutrefresh(SCREEN *, WINDOW *, 53 int, int, int, int, int, int); 54 55 #ifdef HAVE_WCHAR 56 int cellcmp( __LDATA *, __LDATA * ); 57 int linecmp( __LDATA *, __LDATA *, size_t ); 58 #endif /* HAVE_WCHAR */ 59 60 #ifndef _CURSES_USE_MACROS 61 62 /* 63 * refresh -- 64 * Make the current screen look like "stdscr" over the area covered by 65 * stdscr. 66 */ 67 int 68 refresh(void) 69 { 70 return wrefresh(stdscr); 71 } 72 73 #endif 74 75 /* 76 * wnoutrefresh -- 77 * Add the contents of "win" to the virtual window. 78 */ 79 int 80 wnoutrefresh(WINDOW *win) 81 { 82 #ifdef DEBUG 83 __CTRACE(__CTRACE_REFRESH, "wnoutrefresh: win %p\n", win); 84 #endif 85 86 return _cursesi_wnoutrefresh(_cursesi_screen, win, 0, 0, win->begy, 87 win->begx, win->maxy, win->maxx); 88 } 89 90 /* 91 * pnoutrefresh -- 92 * Add the contents of "pad" to the virtual window. 93 */ 94 int 95 pnoutrefresh(WINDOW *pad, int pbegy, int pbegx, int sbegy, int sbegx, 96 int smaxy, int smaxx) 97 { 98 int pmaxy, pmaxx; 99 100 #ifdef DEBUG 101 __CTRACE(__CTRACE_REFRESH, "pnoutrefresh: pad %p, flags 0x%08x\n", 102 pad, pad->flags); 103 __CTRACE(__CTRACE_REFRESH, 104 "pnoutrefresh: (%d, %d), (%d, %d), (%d, %d)\n", 105 pbegy, pbegx, sbegy, sbegx, smaxy, smaxx); 106 #endif 107 108 /* SUS says if these are negative, they should be treated as zero */ 109 if (pbegy < 0) 110 pbegy = 0; 111 if (pbegx < 0) 112 pbegx = 0; 113 if (sbegy < 0) 114 sbegy = 0; 115 if (sbegx < 0) 116 sbegx = 0; 117 118 /* Calculate rectangle on pad - used by _cursesi_wnoutrefresh */ 119 pmaxy = pbegy + smaxy - sbegy + 1; 120 pmaxx = pbegx + smaxx - sbegx + 1; 121 122 /* Check rectangle fits in pad */ 123 if (pmaxy > pad->maxy - pad->begy) 124 pmaxy = pad->maxy - pad->begy; 125 if (pmaxx > pad->maxx - pad->begx) 126 pmaxx = pad->maxx - pad->begx; 127 128 if (smaxy - sbegy < 0 || smaxx - sbegx < 0 ) 129 return ERR; 130 131 return _cursesi_wnoutrefresh(_cursesi_screen, pad, 132 pad->begy + pbegy, pad->begx + pbegx, pad->begy + sbegy, 133 pad->begx + sbegx, pmaxy, pmaxx); 134 } 135 136 /* 137 * _cursesi_wnoutrefresh -- 138 * Does the grunt work for wnoutrefresh to the given screen. 139 * Copies the part of the window given by the rectangle 140 * (begy, begx) to (maxy, maxx) at screen position (wbegy, wbegx). 141 */ 142 int 143 _cursesi_wnoutrefresh(SCREEN *screen, WINDOW *win, int begy, int begx, 144 int wbegy, int wbegx, int maxy, int maxx) 145 { 146 147 short sy, wy, wx, y_off, x_off, mx; 148 __LINE *wlp, *vlp; 149 WINDOW *sub_win, *orig; 150 151 #ifdef DEBUG 152 __CTRACE(__CTRACE_REFRESH, "_wnoutrefresh: win %p, flags 0x%08x\n", 153 win, win->flags); 154 __CTRACE(__CTRACE_REFRESH, 155 "_wnoutrefresh: (%d, %d), (%d, %d), (%d, %d)\n", 156 begy, begx, wbegy, wbegx, maxy, maxx); 157 #endif 158 159 if (screen->curwin) 160 return OK; 161 162 /* 163 * Recurse through any sub-windows, mark as dirty lines on the parent 164 * window that are dirty on the sub-window and clear the dirty flag on 165 * the sub-window. 166 */ 167 if (win->orig == 0) { 168 orig = win; 169 for (sub_win = win->nextp; sub_win != win; 170 sub_win = sub_win->nextp) { 171 #ifdef DEBUG 172 __CTRACE(__CTRACE_REFRESH, 173 "wnout_refresh: win %p, sub_win %p\n", 174 orig, sub_win); 175 #endif 176 for (sy = 0; sy < sub_win->maxy; sy++) { 177 if (sub_win->alines[sy]->flags & __ISDIRTY) { 178 orig->alines[sy + sub_win->begy - orig->begy]->flags 179 |= __ISDIRTY; 180 sub_win->alines[sy]->flags 181 &= ~__ISDIRTY; 182 } 183 } 184 } 185 } 186 187 /* Check that cursor position on "win" is valid for "__virtscr" */ 188 if (win->cury + wbegy - begy < screen->__virtscr->maxy && 189 win->cury + wbegy - begy >= 0 && win->cury < maxy - begy) 190 screen->__virtscr->cury = win->cury + wbegy - begy; 191 if (win->curx + wbegx - begx < screen->__virtscr->maxx && 192 win->curx + wbegx - begx >= 0 && win->curx < maxx - begx) 193 screen->__virtscr->curx = win->curx + wbegx - begx; 194 195 /* Copy the window flags from "win" to "__virtscr" */ 196 if (win->flags & __CLEAROK) { 197 if (win->flags & __FULLWIN) 198 screen->__virtscr->flags |= __CLEAROK; 199 win->flags &= ~__CLEAROK; 200 } 201 screen->__virtscr->flags &= ~__LEAVEOK; 202 screen->__virtscr->flags |= win->flags; 203 204 for (wy = begy, y_off = wbegy; wy < maxy && 205 y_off < screen->__virtscr->maxy; wy++, y_off++) { 206 wlp = win->alines[wy]; 207 #ifdef DEBUG 208 __CTRACE(__CTRACE_REFRESH, 209 "_wnoutrefresh: wy %d\tf %d\tl %d\tflags %x\n", 210 wy, *wlp->firstchp, *wlp->lastchp, wlp->flags); 211 #endif 212 if ((wlp->flags & __ISDIRTY) == 0) 213 continue; 214 vlp = screen->__virtscr->alines[y_off]; 215 216 if (*wlp->firstchp < maxx + win->ch_off && 217 *wlp->lastchp >= win->ch_off) { 218 /* Set start column */ 219 wx = begx; 220 x_off = wbegx; 221 if (*wlp->firstchp - win->ch_off > 0) { 222 wx += *wlp->firstchp - win->ch_off; 223 x_off += *wlp->firstchp - win->ch_off; 224 } 225 /* Set finish column */ 226 mx = maxx; 227 if (mx > *wlp->lastchp - win->ch_off + 1) 228 mx = *wlp->lastchp - win->ch_off + 1; 229 if (x_off + (mx - wx) > __virtscr->maxx) 230 mx -= (x_off + maxx) - __virtscr->maxx; 231 /* Copy line from "win" to "__virtscr". */ 232 while (wx < mx) { 233 #ifdef DEBUG 234 __CTRACE(__CTRACE_REFRESH, 235 "_wnoutrefresh: copy from %d, " 236 "%d to %d, %d\n", 237 wy, wx, y_off, x_off); 238 #endif 239 /* Copy character */ 240 vlp->line[x_off].ch = wlp->line[wx].ch; 241 /* Copy attributes */ 242 vlp->line[x_off].attr = wlp->line[wx].attr; 243 /* Check for nca conflict with colour */ 244 if ((vlp->line[x_off].attr & __COLOR) && 245 (vlp->line[x_off].attr & 246 _cursesi_screen->nca)) 247 vlp->line[x_off].attr &= ~__COLOR; 248 #ifdef HAVE_WCHAR 249 if (wlp->line[wx].ch 250 == (wchar_t)btowc((int) win->bch)) { 251 vlp->line[x_off].ch = win->bch; 252 SET_WCOL( vlp->line[x_off], 1 ); 253 if (_cursesi_copy_nsp(win->bnsp, 254 &vlp->line[x_off]) 255 == ERR) 256 return ERR; 257 } 258 #endif /* HAVE_WCHAR */ 259 wx++; 260 x_off++; 261 } 262 263 /* Set flags on "__virtscr" and unset on "win". */ 264 if (wlp->flags & __ISPASTEOL) 265 vlp->flags |= __ISPASTEOL; 266 else 267 vlp->flags &= ~__ISPASTEOL; 268 if (wlp->flags & __ISDIRTY) 269 vlp->flags |= __ISDIRTY; 270 271 #ifdef DEBUG 272 __CTRACE(__CTRACE_REFRESH, 273 "win: firstch = %d, lastch = %d\n", 274 *wlp->firstchp, *wlp->lastchp); 275 #endif 276 /* Set change pointers on "__virtscr". */ 277 if (*vlp->firstchp > 278 *wlp->firstchp + wbegx - win->ch_off) 279 *vlp->firstchp = 280 *wlp->firstchp + wbegx - win->ch_off; 281 if (*vlp->lastchp < 282 *wlp->lastchp + wbegx - win->ch_off) 283 *vlp->lastchp = 284 *wlp->lastchp + wbegx - win->ch_off; 285 #ifdef DEBUG 286 __CTRACE(__CTRACE_REFRESH, 287 "__virtscr: firstch = %d, lastch = %d\n", 288 *vlp->firstchp, *vlp->lastchp); 289 #endif 290 /* 291 * Unset change pointers only if a window, as a pad 292 * can be displayed again without any of the contents 293 * changing. 294 */ 295 if (!(win->flags & __ISPAD)) { 296 /* Set change pointers on "win". */ 297 if (*wlp->firstchp >= win->ch_off) 298 *wlp->firstchp = maxx + win->ch_off; 299 if (*wlp->lastchp < maxx + win->ch_off) 300 *wlp->lastchp = win->ch_off; 301 if ((*wlp->lastchp < *wlp->firstchp) || 302 (*wlp->firstchp >= maxx + win->ch_off) || 303 (*wlp->lastchp <= win->ch_off)) { 304 #ifdef DEBUG 305 __CTRACE(__CTRACE_REFRESH, 306 "_wnoutrefresh: " 307 "line %d notdirty\n", wy); 308 #endif 309 wlp->flags &= ~__ISDIRTY; 310 } 311 } 312 } 313 } 314 return OK; 315 } 316 317 /* 318 * wrefresh -- 319 * Make the current screen look like "win" over the area covered by 320 * win. 321 */ 322 int 323 wrefresh(WINDOW *win) 324 { 325 int retval; 326 327 #ifdef DEBUG 328 __CTRACE(__CTRACE_REFRESH, "wrefresh: win %p\n", win); 329 #endif 330 331 _cursesi_screen->curwin = (win == _cursesi_screen->curscr); 332 if (!_cursesi_screen->curwin) 333 retval = _cursesi_wnoutrefresh(_cursesi_screen, win, 0, 0, 334 win->begy, win->begx, win->maxy, win->maxx); 335 else 336 retval = OK; 337 if (retval == OK) { 338 retval = doupdate(); 339 if (!(win->flags & __LEAVEOK)) { 340 win->cury = max(0, curscr->cury - win->begy); 341 win->curx = max(0, curscr->curx - win->begx); 342 } 343 } 344 _cursesi_screen->curwin = 0; 345 return(retval); 346 } 347 348 /* 349 * prefresh -- 350 * Make the current screen look like "pad" over the area coverd by 351 * the specified area of pad. 352 */ 353 int 354 prefresh(WINDOW *pad, int pbegy, int pbegx, int sbegy, int sbegx, 355 int smaxy, int smaxx) 356 { 357 int retval; 358 359 #ifdef DEBUG 360 __CTRACE(__CTRACE_REFRESH, "prefresh: pad %p, flags 0x%08x\n", 361 pad, pad->flags); 362 #endif 363 /* Retain values in case pechochar() is called. */ 364 pad->pbegy = pbegy; 365 pad->pbegx = pbegx; 366 pad->sbegy = sbegy; 367 pad->sbegx = sbegx; 368 pad->smaxy = smaxy; 369 pad->smaxx = smaxx; 370 371 /* Use pnoutrefresh() to avoid duplicating code here */ 372 retval = pnoutrefresh(pad, pbegy, pbegx, sbegy, sbegx, smaxy, smaxx); 373 if (retval == OK) { 374 retval = doupdate(); 375 if (!(pad->flags & __LEAVEOK)) { 376 pad->cury = max(0, curscr->cury - pad->begy); 377 pad->curx = max(0, curscr->curx - pad->begx); 378 } 379 } 380 return(retval); 381 } 382 383 /* 384 * doupdate -- 385 * Make the current screen look like the virtual window "__virtscr". 386 */ 387 int 388 doupdate(void) 389 { 390 WINDOW *win; 391 __LINE *wlp; 392 short wy; 393 int dnum; 394 #ifdef HAVE_WCHAR 395 __LDATA *lp; 396 nschar_t *np; 397 int x; 398 #endif /* HAVE_WCHAR */ 399 400 /* Check if we need to restart ... */ 401 if (_cursesi_screen->endwin) 402 __restartwin(); 403 404 if (_cursesi_screen->curwin) 405 win = curscr; 406 else 407 win = _cursesi_screen->__virtscr; 408 409 /* Initialize loop parameters. */ 410 _cursesi_screen->ly = curscr->cury; 411 _cursesi_screen->lx = curscr->curx; 412 wy = 0; 413 414 if (!_cursesi_screen->curwin) { 415 for (wy = 0; wy < win->maxy; wy++) { 416 wlp = win->alines[wy]; 417 if (wlp->flags & __ISDIRTY) { 418 #ifndef HAVE_WCHAR 419 wlp->hash = __hash(wlp->line, 420 (size_t)(win->maxx * __LDATASIZE)); 421 #else 422 wlp->hash = 0; 423 for ( x = 0; x < win->maxx; x++ ) { 424 lp = &wlp->line[ x ]; 425 wlp->hash = __hash_more( &lp->ch, 426 sizeof( wchar_t ), wlp->hash ); 427 wlp->hash = __hash_more( &lp->attr, 428 sizeof( attr_t ), wlp->hash ); 429 np = lp->nsp; 430 if (np) { 431 while ( np ) { 432 wlp->hash 433 = __hash_more( 434 &np->ch, 435 sizeof(wchar_t), 436 wlp->hash ); 437 np = np->next; 438 } 439 } 440 } 441 #endif /* HAVE_WCHAR */ 442 } 443 } 444 } 445 446 if ((win->flags & __CLEAROK) || (curscr->flags & __CLEAROK) || 447 _cursesi_screen->curwin) { 448 if (curscr->wattr & __COLOR) 449 __unsetattr(0); 450 tputs(clear_screen, 0, __cputchar); 451 _cursesi_screen->ly = 0; 452 _cursesi_screen->lx = 0; 453 if (!_cursesi_screen->curwin) { 454 curscr->flags &= ~__CLEAROK; 455 curscr->cury = 0; 456 curscr->curx = 0; 457 werase(curscr); 458 } 459 __touchwin(win); 460 win->flags &= ~__CLEAROK; 461 } 462 if (!cursor_address) { 463 if (win->curx != 0) 464 __cputchar('\n'); 465 if (!_cursesi_screen->curwin) 466 werase(curscr); 467 } 468 #ifdef DEBUG 469 __CTRACE(__CTRACE_REFRESH, "doupdate: (%p): curwin = %d\n", win, 470 _cursesi_screen->curwin); 471 __CTRACE(__CTRACE_REFRESH, "doupdate: \tfirstch\tlastch\n"); 472 #endif 473 474 if (!_cursesi_screen->curwin) { 475 /* 476 * Invoke quickch() only if more than a quarter of the lines 477 * in the window are dirty. 478 */ 479 for (wy = 0, dnum = 0; wy < win->maxy; wy++) 480 if (win->alines[wy]->flags & __ISDIRTY) 481 dnum++; 482 if (!__noqch && dnum > (int) win->maxy / 4) 483 quickch(); 484 } 485 486 #ifdef DEBUG 487 { 488 int i, j; 489 490 __CTRACE(__CTRACE_REFRESH, 491 "#####################################\n"); 492 __CTRACE(__CTRACE_REFRESH, 493 "stdscr(%p)-curscr(%p)-__virtscr(%p)\n", 494 stdscr, curscr, _cursesi_screen->__virtscr); 495 for (i = 0; i < curscr->maxy; i++) { 496 __CTRACE(__CTRACE_REFRESH, "C: %d:", i); 497 __CTRACE(__CTRACE_REFRESH, " 0x%x \n", 498 curscr->alines[i]->hash); 499 for (j = 0; j < curscr->maxx; j++) 500 __CTRACE(__CTRACE_REFRESH, "%c", 501 curscr->alines[i]->line[j].ch); 502 __CTRACE(__CTRACE_REFRESH, "\n"); 503 __CTRACE(__CTRACE_REFRESH, " attr:"); 504 for (j = 0; j < curscr->maxx; j++) 505 __CTRACE(__CTRACE_REFRESH, " %x", 506 curscr->alines[i]->line[j].attr); 507 __CTRACE(__CTRACE_REFRESH, "\n"); 508 __CTRACE(__CTRACE_REFRESH, "W: %d:", i); 509 __CTRACE(__CTRACE_REFRESH, " 0x%x \n", 510 win->alines[i]->hash); 511 __CTRACE(__CTRACE_REFRESH, " 0x%x ", 512 win->alines[i]->flags); 513 for (j = 0; j < win->maxx; j++) 514 __CTRACE(__CTRACE_REFRESH, "%c", 515 win->alines[i]->line[j].ch); 516 __CTRACE(__CTRACE_REFRESH, "\n"); 517 __CTRACE(__CTRACE_REFRESH, " attr:"); 518 for (j = 0; j < win->maxx; j++) 519 __CTRACE(__CTRACE_REFRESH, " %x", 520 win->alines[i]->line[j].attr); 521 __CTRACE(__CTRACE_REFRESH, "\n"); 522 #ifdef HAVE_WCHAR 523 __CTRACE(__CTRACE_REFRESH, " nsp:"); 524 for (j = 0; j < curscr->maxx; j++) 525 __CTRACE(__CTRACE_REFRESH, " %p", 526 win->alines[i]->line[j].nsp); 527 __CTRACE(__CTRACE_REFRESH, "\n"); 528 __CTRACE(__CTRACE_REFRESH, " bnsp:"); 529 for (j = 0; j < curscr->maxx; j++) 530 __CTRACE(__CTRACE_REFRESH, " %p", 531 win->bnsp); 532 __CTRACE(__CTRACE_REFRESH, "\n"); 533 #endif /* HAVE_WCHAR */ 534 } 535 } 536 #endif /* DEBUG */ 537 538 for (wy = 0; wy < win->maxy; wy++) { 539 wlp = win->alines[wy]; 540 /* XXX: remove this debug */ 541 #ifdef DEBUG 542 __CTRACE(__CTRACE_REFRESH, 543 "doupdate: wy %d\tf: %d\tl:%d\tflags %x\n", 544 wy, *wlp->firstchp, *wlp->lastchp, wlp->flags); 545 #endif /* DEBUG */ 546 if (!_cursesi_screen->curwin) 547 curscr->alines[wy]->hash = wlp->hash; 548 if (wlp->flags & __ISDIRTY) { 549 #ifdef DEBUG 550 __CTRACE(__CTRACE_REFRESH, 551 "doupdate: [ISDIRTY]wy:%d\tf:%d\tl:%d\n", wy, 552 *wlp->firstchp, *wlp->lastchp); 553 #endif /* DEBUG */ 554 if (makech(wy) == ERR) 555 return (ERR); 556 else { 557 if (*wlp->firstchp >= 0) 558 *wlp->firstchp = win->maxx; 559 if (*wlp->lastchp < win->maxx) 560 *wlp->lastchp = 0; 561 if (*wlp->lastchp < *wlp->firstchp) { 562 #ifdef DEBUG 563 __CTRACE(__CTRACE_REFRESH, 564 "doupdate: line %d notdirty\n", wy); 565 #endif /* DEBUG */ 566 wlp->flags &= ~__ISDIRTY; 567 } 568 } 569 570 } 571 #ifdef DEBUG 572 __CTRACE(__CTRACE_REFRESH, "\t%d\t%d\n", 573 *wlp->firstchp, *wlp->lastchp); 574 #endif /* DEBUG */ 575 } 576 577 #ifdef DEBUG 578 __CTRACE(__CTRACE_REFRESH, "doupdate: ly=%d, lx=%d\n", 579 _cursesi_screen->ly, _cursesi_screen->lx); 580 #endif /* DEBUG */ 581 582 if (_cursesi_screen->curwin) 583 domvcur(_cursesi_screen->ly, _cursesi_screen->lx, 584 win->cury, win->curx); 585 else { 586 if (win->flags & __LEAVEOK) { 587 curscr->cury = _cursesi_screen->ly; 588 curscr->curx = _cursesi_screen->lx; 589 } else { 590 domvcur(_cursesi_screen->ly, _cursesi_screen->lx, 591 win->cury, win->curx); 592 curscr->cury = win->cury; 593 curscr->curx = win->curx; 594 } 595 } 596 597 /* Don't leave the screen with attributes set. */ 598 __unsetattr(0); 599 #ifdef DEBUG 600 #ifdef HAVE_WCHAR 601 { 602 int i, j; 603 604 __CTRACE(__CTRACE_REFRESH, 605 "***********after*****************\n"); 606 __CTRACE(__CTRACE_REFRESH, 607 "stdscr(%p)-curscr(%p)-__virtscr(%p)\n", 608 stdscr, curscr, _cursesi_screen->__virtscr); 609 for (i = 0; i < curscr->maxy; i++) { 610 for (j = 0; j < curscr->maxx; j++) 611 __CTRACE(__CTRACE_REFRESH, 612 "[%d,%d](%x,%x,%p)-(%x,%x,%p)\n", 613 i, j, 614 curscr->alines[i]->line[j].ch, 615 curscr->alines[i]->line[j].attr, 616 curscr->alines[i]->line[j].nsp, 617 _cursesi_screen->__virtscr->alines[i]->line[j].ch, 618 _cursesi_screen->__virtscr->alines[i]->line[j].attr, 619 _cursesi_screen->__virtscr->alines[i]->line[j].nsp); 620 } 621 } 622 #endif /* HAVE_WCHAR */ 623 #endif /* DEBUG */ 624 return fflush(_cursesi_screen->outfd) == EOF ? ERR : OK; 625 } 626 627 /* 628 * makech -- 629 * Make a change on the screen. 630 */ 631 static int 632 makech(int wy) 633 { 634 WINDOW *win; 635 static __LDATA blank; 636 __LDATA *nsp, *csp, *cp, *cep; 637 size_t clsp, nlsp; /* Last space in lines. */ 638 int lch, wx; 639 const char *ce; 640 attr_t lspc; /* Last space colour */ 641 attr_t off, on; 642 643 #ifdef __GNUC__ 644 nlsp = lspc = 0; /* XXX gcc -Wuninitialized */ 645 #endif 646 if (_cursesi_screen->curwin) 647 win = curscr; 648 else 649 win = __virtscr; 650 #ifdef HAVE_WCHAR 651 blank.ch = ( wchar_t )btowc(( int ) win->bch ); 652 blank.attr = 0; 653 if (_cursesi_copy_nsp(win->bnsp, &blank) == ERR) 654 return ERR; 655 SET_WCOL( blank, 1 ); 656 #endif /* HAVE_WCHAR */ 657 #ifdef DEBUG 658 #if HAVE_WCHAR 659 { 660 int x; 661 __LDATA *lp, *vlp; 662 663 __CTRACE(__CTRACE_REFRESH, 664 "[makech-before]wy=%d,curscr(%p)-__virtscr(%p)\n", 665 wy, curscr, __virtscr); 666 for (x = 0; x < curscr->maxx; x++) { 667 lp = &curscr->alines[wy]->line[x]; 668 vlp = &__virtscr->alines[wy]->line[x]; 669 __CTRACE(__CTRACE_REFRESH, 670 "[%d,%d](%x,%x,%x,%x,%p)-" 671 "(%x,%x,%x,%x,%p)\n", 672 wy, x, lp->ch, lp->attr, 673 win->bch, win->battr, lp->nsp, 674 vlp->ch, vlp->attr, 675 win->bch, win->battr, vlp->nsp); 676 } 677 } 678 #endif /* HAVE_WCHAR */ 679 #endif /* DEBUG */ 680 /* Is the cursor still on the end of the last line? */ 681 if (wy > 0 && curscr->alines[wy - 1]->flags & __ISPASTEOL) { 682 domvcur(_cursesi_screen->ly, _cursesi_screen->lx, 683 _cursesi_screen->ly + 1, 0); 684 _cursesi_screen->ly++; 685 _cursesi_screen->lx = 0; 686 } 687 wx = *win->alines[wy]->firstchp; 688 if (wx < 0) 689 wx = 0; 690 else 691 if (wx >= win->maxx) 692 return (OK); 693 lch = *win->alines[wy]->lastchp; 694 if (lch < 0) 695 return (OK); 696 else 697 if (lch >= (int) win->maxx) 698 lch = win->maxx - 1; 699 700 if (_cursesi_screen->curwin) { 701 csp = ␣ 702 #ifdef DEBUG 703 __CTRACE(__CTRACE_REFRESH, "makech: csp is blank\n"); 704 #endif /* DEBUG */ 705 } else { 706 csp = &curscr->alines[wy]->line[wx]; 707 #ifdef DEBUG 708 __CTRACE(__CTRACE_REFRESH, 709 "makech: csp is on curscr:(%d,%d)\n", wy, wx); 710 #endif /* DEBUG */ 711 } 712 713 nsp = &win->alines[wy]->line[wx]; 714 #ifdef DEBUG 715 if ( _cursesi_screen->curwin ) 716 __CTRACE(__CTRACE_REFRESH, 717 "makech: nsp is at curscr:(%d,%d)\n", wy, wx); 718 else 719 __CTRACE(__CTRACE_REFRESH, 720 "makech: nsp is at __virtscr:(%d,%d)\n", wy, wx); 721 #endif /* DEBUG */ 722 if (clr_eol && !_cursesi_screen->curwin) { 723 cp = &win->alines[wy]->line[win->maxx - 1]; 724 lspc = cp->attr & __COLOR; 725 #ifndef HAVE_WCHAR 726 while (cp->ch == ' ' && cp->attr == lspc) /* XXX */ 727 if (cp-- <= win->alines[wy]->line) 728 break; 729 #else 730 while (cp->ch == ( wchar_t )btowc(( int )' ' ) 731 && ( cp->attr & WA_ATTRIBUTES ) == lspc) 732 if (cp-- <= win->alines[wy]->line) 733 break; 734 #endif /* HAVE_WCHAR */ 735 if (win->alines[wy]->line > cp) 736 nlsp = 0; 737 else 738 nlsp = cp - win->alines[wy]->line; 739 } 740 if (!_cursesi_screen->curwin) 741 ce = clr_eol; 742 else 743 ce = NULL; 744 745 while (wx <= lch) { 746 #ifdef DEBUG 747 __CTRACE(__CTRACE_REFRESH, "makech: wx=%d,lch=%d\n", wx, lch); 748 #endif /* DEBUG */ 749 #ifndef HAVE_WCHAR 750 if (memcmp(nsp, csp, sizeof(__LDATA)) == 0) { 751 if (wx <= lch) { 752 while (wx <= lch && 753 memcmp(nsp, csp, sizeof(__LDATA)) == 0) { 754 nsp++; 755 if (!_cursesi_screen->curwin) 756 ++csp; 757 ++wx; 758 } 759 continue; 760 } 761 break; 762 } 763 #else 764 #ifdef DEBUG 765 __CTRACE(__CTRACE_REFRESH, "makech: nsp=(%x,%x,%x,%x,%p)\n", 766 nsp->ch, nsp->attr, win->bch, win->battr, nsp->nsp); 767 __CTRACE(__CTRACE_REFRESH, "makech: csp=(%x,%x,%x,%x,%p)\n", 768 csp->ch, csp->attr, win->bch, win->battr, csp->nsp); 769 #endif /* DEBUG */ 770 if (((nsp->attr & __WCWIDTH) != __WCWIDTH) && 771 cellcmp(nsp, csp)) { 772 if (wx <= lch) { 773 while (wx <= lch && cellcmp( csp, nsp )) { 774 nsp++; 775 if (!_cursesi_screen->curwin) 776 ++csp; 777 ++wx; 778 } 779 continue; 780 } 781 break; 782 } 783 #endif /* HAVE_WCHAR */ 784 domvcur(_cursesi_screen->ly, _cursesi_screen->lx, wy, wx); 785 786 #ifdef DEBUG 787 __CTRACE(__CTRACE_REFRESH, "makech: 1: wx = %d, ly= %d, " 788 "lx = %d, newy = %d, newx = %d\n", 789 wx, _cursesi_screen->ly, _cursesi_screen->lx, wy, wx); 790 #endif 791 _cursesi_screen->ly = wy; 792 _cursesi_screen->lx = wx; 793 #ifndef HAVE_WCHAR 794 while (wx <= lch && memcmp(nsp, csp, sizeof(__LDATA)) != 0) { 795 if (ce != NULL && 796 wx >= nlsp && nsp->ch == ' ' && nsp->attr == lspc) { 797 #else 798 while (!cellcmp(nsp, csp) && wx <= lch) { 799 if (ce != NULL && wx >= nlsp 800 && nsp->ch == (wchar_t)btowc((int)' ') /* XXX */ 801 && (nsp->attr & WA_ATTRIBUTES) == lspc) { 802 803 #endif 804 /* Check for clear to end-of-line. */ 805 cep = &curscr->alines[wy]->line[win->maxx - 1]; 806 #ifndef HAVE_WCHAR 807 while (cep->ch == ' ' && cep->attr == lspc) /* XXX */ 808 #else 809 while (cep->ch == (wchar_t)btowc((int)' ') 810 && (cep->attr & WA_ATTRIBUTES) == lspc) 811 #endif /* HAVE_WCHAR */ 812 if (cep-- <= csp) 813 break; 814 clsp = cep - curscr->alines[wy]->line - 815 win->begx * __LDATASIZE; 816 #ifdef DEBUG 817 __CTRACE(__CTRACE_REFRESH, 818 "makech: clsp = %zu, nlsp = %zu\n", 819 clsp, nlsp); 820 #endif 821 if (((clsp - nlsp >= strlen(clr_eol) && 822 clsp < win->maxx * __LDATASIZE) || 823 wy == win->maxy - 1) && 824 (!(lspc & __COLOR) || 825 ((lspc & __COLOR) && back_color_erase))) { 826 __unsetattr(0); 827 if (__using_color && 828 ((lspc & __COLOR) != 829 (curscr->wattr & __COLOR))) 830 __set_color(curscr, lspc & 831 __COLOR); 832 tputs(clr_eol, 0, __cputchar); 833 _cursesi_screen->lx = wx + win->begx; 834 while (wx++ <= clsp) { 835 csp->attr = lspc; 836 #ifndef HAVE_WCHAR 837 csp->ch = ' '; /* XXX */ 838 #else 839 csp->ch = (wchar_t)btowc((int)' '); 840 SET_WCOL( *csp, 1 ); 841 #endif /* HAVE_WCHAR */ 842 csp++; 843 } 844 return (OK); 845 } 846 ce = NULL; 847 } 848 849 #ifdef DEBUG 850 __CTRACE(__CTRACE_REFRESH, 851 "makech: have attr %08x, need attr %08x\n", 852 curscr->wattr 853 #ifndef HAVE_WCHAR 854 & __ATTRIBUTES 855 #else 856 & WA_ATTRIBUTES 857 #endif 858 , nsp->attr 859 #ifndef HAVE_WCHAR 860 & __ATTRIBUTES 861 #else 862 & WA_ATTRIBUTES 863 #endif 864 ); 865 #endif 866 867 off = (~nsp->attr & curscr->wattr) 868 #ifndef HAVE_WCHAR 869 & __ATTRIBUTES 870 #else 871 & WA_ATTRIBUTES 872 #endif 873 ; 874 875 /* 876 * Unset attributes as appropriate. Unset first 877 * so that the relevant attributes can be reset 878 * (because 'me' unsets 'mb', 'md', 'mh', 'mk', 879 * 'mp' and 'mr'). Check to see if we also turn off 880 * standout, attributes and colour. 881 */ 882 if (off & __TERMATTR && exit_attribute_mode != NULL) { 883 tputs(exit_attribute_mode, 0, __cputchar); 884 curscr->wattr &= __mask_me; 885 off &= __mask_me; 886 } 887 888 /* 889 * Exit underscore mode if appropriate. 890 * Check to see if we also turn off standout, 891 * attributes and colour. 892 */ 893 if (off & __UNDERSCORE && exit_underline_mode != NULL) { 894 tputs(exit_underline_mode, 0, __cputchar); 895 curscr->wattr &= __mask_ue; 896 off &= __mask_ue; 897 } 898 899 /* 900 * Exit standout mode as appropriate. 901 * Check to see if we also turn off underscore, 902 * attributes and colour. 903 * XXX 904 * Should use uc if so/se not available. 905 */ 906 if (off & __STANDOUT && exit_standout_mode != NULL) { 907 tputs(exit_standout_mode, 0, __cputchar); 908 curscr->wattr &= __mask_se; 909 off &= __mask_se; 910 } 911 912 if (off & __ALTCHARSET && exit_alt_charset_mode != NULL) { 913 tputs(exit_alt_charset_mode, 0, __cputchar); 914 curscr->wattr &= ~__ALTCHARSET; 915 } 916 917 /* Set/change colour as appropriate. */ 918 if (__using_color) 919 __set_color(curscr, nsp->attr & __COLOR); 920 921 on = (nsp->attr & ~curscr->wattr) 922 #ifndef HAVE_WCHAR 923 & __ATTRIBUTES 924 #else 925 & WA_ATTRIBUTES 926 #endif 927 ; 928 929 /* 930 * Enter standout mode if appropriate. 931 */ 932 if (on & __STANDOUT && 933 enter_standout_mode != NULL && 934 exit_standout_mode != NULL) 935 { 936 tputs(enter_standout_mode, 0, __cputchar); 937 curscr->wattr |= __STANDOUT; 938 } 939 940 /* 941 * Enter underscore mode if appropriate. 942 * XXX 943 * Should use uc if us/ue not available. 944 */ 945 if (on & __UNDERSCORE && 946 enter_underline_mode != NULL && 947 exit_underline_mode != NULL) 948 { 949 tputs(enter_underline_mode, 0, __cputchar); 950 curscr->wattr |= __UNDERSCORE; 951 } 952 953 /* 954 * Set other attributes as appropriate. 955 */ 956 if (exit_attribute_mode != NULL) { 957 if (on & __BLINK && 958 enter_blink_mode != NULL) 959 { 960 tputs(enter_blink_mode, 0, __cputchar); 961 curscr->wattr |= __BLINK; 962 } 963 if (on & __BOLD && 964 enter_bold_mode != NULL) 965 { 966 tputs(enter_bold_mode, 0, __cputchar); 967 curscr->wattr |= __BOLD; 968 } 969 if (on & __DIM && 970 enter_dim_mode != NULL) 971 { 972 tputs(enter_dim_mode, 0, __cputchar); 973 curscr->wattr |= __DIM; 974 } 975 if (on & __BLANK && 976 enter_secure_mode != NULL) 977 { 978 tputs(enter_secure_mode, 0, __cputchar); 979 curscr->wattr |= __BLANK; 980 } 981 if (on & __PROTECT && 982 enter_protected_mode != NULL) 983 { 984 tputs(enter_protected_mode, 0, __cputchar); 985 curscr->wattr |= __PROTECT; 986 } 987 if (on & __REVERSE && 988 enter_reverse_mode != NULL) 989 { 990 tputs(enter_reverse_mode, 0, __cputchar); 991 curscr->wattr |= __REVERSE; 992 } 993 #ifdef HAVE_WCHAR 994 if (on & WA_TOP && 995 enter_top_hl_mode != NULL) 996 { 997 tputs(enter_top_hl_mode, 0, __cputchar); 998 curscr->wattr |= WA_TOP; 999 } 1000 if (on & WA_LOW && 1001 enter_low_hl_mode != NULL) 1002 { 1003 tputs(enter_low_hl_mode, 0, __cputchar); 1004 curscr->wattr |= WA_LOW; 1005 } 1006 if (on & WA_LEFT && 1007 enter_left_hl_mode != NULL) 1008 { 1009 tputs(enter_left_hl_mode, 0, __cputchar); 1010 curscr->wattr |= WA_LEFT; 1011 } 1012 if (on & WA_RIGHT && 1013 enter_right_hl_mode != NULL) 1014 { 1015 tputs(enter_right_hl_mode, 0, __cputchar); 1016 curscr->wattr |= WA_RIGHT; 1017 } 1018 if (on & WA_HORIZONTAL && 1019 enter_horizontal_hl_mode != NULL) 1020 { 1021 tputs(enter_horizontal_hl_mode, 0, __cputchar); 1022 curscr->wattr |= WA_HORIZONTAL; 1023 } 1024 if (on & WA_VERTICAL && 1025 enter_vertical_hl_mode != NULL) 1026 { 1027 tputs(enter_vertical_hl_mode, 0, __cputchar); 1028 curscr->wattr |= WA_VERTICAL; 1029 } 1030 #endif /* HAVE_WCHAR */ 1031 } 1032 1033 /* Enter/exit altcharset mode as appropriate. */ 1034 if (on & __ALTCHARSET && enter_alt_charset_mode != NULL && 1035 exit_alt_charset_mode != NULL) { 1036 tputs(enter_alt_charset_mode, 0, __cputchar); 1037 curscr->wattr |= __ALTCHARSET; 1038 } 1039 1040 wx++; 1041 if (wx >= win->maxx && 1042 wy == win->maxy - 1 && !_cursesi_screen->curwin) { 1043 if (win->flags & __SCROLLOK) { 1044 if (win->flags & __ENDLINE) 1045 __unsetattr(1); 1046 if (!(win->flags & __SCROLLWIN)) { 1047 if (!_cursesi_screen->curwin) { 1048 csp->attr = nsp->attr; 1049 csp->ch = nsp->ch; 1050 #ifdef HAVE_WCHAR 1051 if (_cursesi_copy_nsp(nsp->nsp, csp) == ERR) 1052 return ERR; 1053 #endif /* HAVE_WCHAR */ 1054 } 1055 #ifndef HAVE_WCHAR 1056 __cputchar((int) nsp->ch); 1057 #else 1058 if ( WCOL( *nsp ) > 0 ) { 1059 __cputwchar((int)nsp->ch); 1060 #ifdef DEBUG 1061 __CTRACE(__CTRACE_REFRESH, 1062 "makech: (%d,%d)putwchar(0x%x)\n", 1063 wy, wx - 1, 1064 nsp->ch ); 1065 #endif /* DEBUG */ 1066 /* 1067 * Output non-spacing 1068 * characters for the 1069 * cell. 1070 */ 1071 __cursesi_putnsp(nsp->nsp, 1072 wy, wx); 1073 1074 } 1075 #endif /* HAVE_WCHAR */ 1076 } 1077 if (wx < curscr->maxx) { 1078 domvcur(_cursesi_screen->ly, wx, 1079 (int) (win->maxy - 1), 1080 (int) (win->maxx - 1)); 1081 } 1082 _cursesi_screen->ly = win->maxy - 1; 1083 _cursesi_screen->lx = win->maxx - 1; 1084 return (OK); 1085 } 1086 } 1087 if (wx < win->maxx || wy < win->maxy - 1 || 1088 !(win->flags & __SCROLLWIN)) { 1089 if (!_cursesi_screen->curwin) { 1090 csp->attr = nsp->attr; 1091 csp->ch = nsp->ch; 1092 #ifdef HAVE_WCHAR 1093 if (_cursesi_copy_nsp(nsp->nsp, 1094 csp) == ERR) 1095 return ERR; 1096 #endif /* HAVE_WCHAR */ 1097 csp++; 1098 } 1099 #ifndef HAVE_WCHAR 1100 __cputchar((int) nsp->ch); 1101 #ifdef DEBUG 1102 __CTRACE(__CTRACE_REFRESH, 1103 "makech: putchar(%c)\n", nsp->ch & 0177); 1104 #endif 1105 #else 1106 if (WCOL(*nsp) > 0) { 1107 __cputwchar((int) nsp->ch); 1108 #ifdef DEBUG 1109 __CTRACE(__CTRACE_REFRESH, 1110 "makech:(%d,%d) putwchar(%x)\n", 1111 wy, wx - 1, nsp->ch); 1112 __cursesi_putnsp(nsp->nsp, wy, wx); 1113 #endif /* DEBUG */ 1114 } 1115 #endif /* HAVE_WCHAR */ 1116 } 1117 if (underline_char && ((nsp->attr & __STANDOUT) || 1118 (nsp->attr & __UNDERSCORE))) { 1119 __cputchar('\b'); 1120 tputs(underline_char, 0, __cputchar); 1121 } 1122 nsp++; 1123 #ifdef DEBUG 1124 __CTRACE(__CTRACE_REFRESH, 1125 "makech: 2: wx = %d, lx = %d\n", 1126 wx, _cursesi_screen->lx); 1127 #endif 1128 } 1129 if (_cursesi_screen->lx == wx) /* If no change. */ 1130 break; 1131 _cursesi_screen->lx = wx; 1132 if (_cursesi_screen->lx >= COLS && auto_right_margin) 1133 _cursesi_screen->lx = COLS - 1; 1134 else 1135 if (wx >= win->maxx) { 1136 domvcur(_cursesi_screen->ly, 1137 _cursesi_screen->lx, 1138 _cursesi_screen->ly, 1139 (int) (win->maxx - 1)); 1140 _cursesi_screen->lx = win->maxx - 1; 1141 } 1142 #ifdef DEBUG 1143 __CTRACE(__CTRACE_REFRESH, "makech: 3: wx = %d, lx = %d\n", 1144 wx, _cursesi_screen->lx); 1145 #endif 1146 } 1147 #ifdef DEBUG 1148 #if HAVE_WCHAR 1149 { 1150 int x; 1151 __LDATA *lp, *vlp; 1152 1153 __CTRACE(__CTRACE_REFRESH, 1154 "makech-after: curscr(%p)-__virtscr(%p)\n", 1155 curscr, __virtscr ); 1156 for (x = 0; x < curscr->maxx; x++) { 1157 lp = &curscr->alines[wy]->line[x]; 1158 vlp = &__virtscr->alines[wy]->line[x]; 1159 __CTRACE(__CTRACE_REFRESH, 1160 "[%d,%d](%x,%x,%x,%x,%p)-" 1161 "(%x,%x,%x,%x,%p)\n", 1162 wy, x, lp->ch, lp->attr, 1163 win->bch, win->battr, lp->nsp, 1164 vlp->ch, vlp->attr, 1165 win->bch, win->battr, vlp->nsp); 1166 } 1167 } 1168 #endif /* HAVE_WCHAR */ 1169 #endif /* DEBUG */ 1170 1171 return (OK); 1172 } 1173 1174 /* 1175 * domvcur -- 1176 * Do a mvcur, leaving attributes if necessary. 1177 */ 1178 static void 1179 domvcur(oy, ox, ny, nx) 1180 int oy, ox, ny, nx; 1181 { 1182 #ifdef DEBUG 1183 __CTRACE(__CTRACE_REFRESH, "domvcur: (%x,%d)=>(%d,%d)\n", 1184 oy, ox, ny, nx ); 1185 #endif /* DEBUG */ 1186 __unsetattr(1); 1187 if ( oy == ny && ox == nx ) 1188 return; 1189 __mvcur(oy, ox, ny, nx, 1); 1190 } 1191 1192 /* 1193 * Quickch() attempts to detect a pattern in the change of the window 1194 * in order to optimize the change, e.g., scroll n lines as opposed to 1195 * repainting the screen line by line. 1196 */ 1197 1198 static __LDATA buf[128]; 1199 static u_int last_hash; 1200 static size_t last_hash_len; 1201 #define BLANKSIZE (sizeof(buf) / sizeof(buf[0])) 1202 1203 static void 1204 quickch(void) 1205 { 1206 #define THRESH (int) __virtscr->maxy / 4 1207 1208 __LINE *clp, *tmp1, *tmp2; 1209 int bsize, curs, curw, starts, startw, i, j; 1210 int n, target, cur_period, bot, top, sc_region; 1211 u_int blank_hash; 1212 attr_t bcolor; 1213 1214 #ifdef __GNUC__ 1215 curs = curw = starts = startw = 0; /* XXX gcc -Wuninitialized */ 1216 #endif 1217 /* 1218 * Find how many lines from the top of the screen are unchanged. 1219 */ 1220 for (top = 0; top < __virtscr->maxy; top++) 1221 #ifndef HAVE_WCHAR 1222 if (__virtscr->alines[top]->flags & __ISDIRTY && 1223 (__virtscr->alines[top]->hash != curscr->alines[top]->hash || 1224 memcmp(__virtscr->alines[top]->line, 1225 curscr->alines[top]->line, 1226 (size_t) __virtscr->maxx * __LDATASIZE) 1227 != 0)) 1228 break; 1229 #else 1230 if (__virtscr->alines[top]->flags & __ISDIRTY && 1231 (__virtscr->alines[top]->hash != curscr->alines[top]->hash || 1232 !linecmp(__virtscr->alines[top]->line, 1233 curscr->alines[top]->line, 1234 (size_t) __virtscr->maxx ))) 1235 break; 1236 #endif /* HAVE_WCHAR */ 1237 else 1238 __virtscr->alines[top]->flags &= ~__ISDIRTY; 1239 /* 1240 * Find how many lines from bottom of screen are unchanged. 1241 */ 1242 for (bot = __virtscr->maxy - 1; bot >= 0; bot--) 1243 #ifndef HAVE_WCHAR 1244 if (__virtscr->alines[bot]->flags & __ISDIRTY && 1245 (__virtscr->alines[bot]->hash != curscr->alines[bot]->hash || 1246 memcmp(__virtscr->alines[bot]->line, 1247 curscr->alines[bot]->line, 1248 (size_t) __virtscr->maxx * __LDATASIZE) 1249 != 0)) 1250 break; 1251 #else 1252 if (__virtscr->alines[bot]->flags & __ISDIRTY && 1253 (__virtscr->alines[bot]->hash != curscr->alines[bot]->hash || 1254 !linecmp(__virtscr->alines[bot]->line, 1255 curscr->alines[bot]->line, 1256 (size_t) __virtscr->maxx ))) 1257 break; 1258 #endif /* HAVE_WCHAR */ 1259 else 1260 __virtscr->alines[bot]->flags &= ~__ISDIRTY; 1261 1262 /* 1263 * Work round an xterm bug where inserting lines causes all the 1264 * inserted lines to be covered with the background colour we 1265 * set on the first line (even if we unset it for subsequent 1266 * lines). 1267 */ 1268 bcolor = __virtscr->alines[min(top, 1269 __virtscr->maxy - 1)]->line[0].attr & __COLOR; 1270 for (i = top + 1, j = 0; i < bot; i++) { 1271 if ((__virtscr->alines[i]->line[0].attr & __COLOR) != bcolor) { 1272 bcolor = __virtscr->alines[i]->line[__virtscr->maxx]. 1273 attr & __COLOR; 1274 j = i - top; 1275 } else 1276 break; 1277 } 1278 top += j; 1279 1280 #ifdef NO_JERKINESS 1281 /* 1282 * If we have a bottom unchanged region return. Scrolling the 1283 * bottom region up and then back down causes a screen jitter. 1284 * This will increase the number of characters sent to the screen 1285 * but it looks better. 1286 */ 1287 if (bot < __virtscr->maxy - 1) 1288 return; 1289 #endif /* NO_JERKINESS */ 1290 1291 /* 1292 * Search for the largest block of text not changed. 1293 * Invariants of the loop: 1294 * - Startw is the index of the beginning of the examined block in 1295 * __virtscr. 1296 * - Starts is the index of the beginning of the examined block in 1297 * curscr. 1298 * - Curw is the index of one past the end of the exmined block in 1299 * __virtscr. 1300 * - Curs is the index of one past the end of the exmined block in 1301 * curscr. 1302 * - bsize is the current size of the examined block. 1303 */ 1304 1305 for (bsize = bot - top; bsize >= THRESH; bsize--) { 1306 for (startw = top; startw <= bot - bsize; startw++) 1307 for (starts = top; starts <= bot - bsize; 1308 starts++) { 1309 for (curw = startw, curs = starts; 1310 curs < starts + bsize; curw++, curs++) 1311 if (__virtscr->alines[curw]->hash != 1312 curscr->alines[curs]->hash) 1313 break; 1314 if (curs != starts + bsize) 1315 continue; 1316 for (curw = startw, curs = starts; 1317 curs < starts + bsize; curw++, curs++) 1318 #ifndef HAVE_WCHAR 1319 if (memcmp(__virtscr->alines[curw]->line, 1320 curscr->alines[curs]->line, 1321 (size_t) __virtscr->maxx * 1322 __LDATASIZE) != 0) 1323 break; 1324 #else 1325 if (!linecmp(__virtscr->alines[curw]->line, 1326 curscr->alines[curs]->line, 1327 (size_t) __virtscr->maxx)) 1328 break; 1329 #endif /* HAVE_WCHAR */ 1330 if (curs == starts + bsize) 1331 goto done; 1332 } 1333 } 1334 done: 1335 1336 /* Did not find anything */ 1337 if (bsize < THRESH) 1338 return; 1339 1340 #ifdef DEBUG 1341 __CTRACE(__CTRACE_REFRESH, "quickch:bsize=%d, starts=%d, startw=%d, " 1342 "curw=%d, curs=%d, top=%d, bot=%d\n", 1343 bsize, starts, startw, curw, curs, top, bot); 1344 #endif 1345 1346 /* 1347 * Make sure that there is no overlap between the bottom and top 1348 * regions and the middle scrolled block. 1349 */ 1350 if (bot < curs) 1351 bot = curs - 1; 1352 if (top > starts) 1353 top = starts; 1354 1355 n = startw - starts; 1356 1357 #ifdef DEBUG 1358 __CTRACE(__CTRACE_REFRESH, "#####################################\n"); 1359 for (i = 0; i < curscr->maxy; i++) { 1360 __CTRACE(__CTRACE_REFRESH, "C: %d:", i); 1361 __CTRACE(__CTRACE_REFRESH, " 0x%x \n", curscr->alines[i]->hash); 1362 for (j = 0; j < curscr->maxx; j++) 1363 __CTRACE(__CTRACE_REFRESH, "%c", 1364 curscr->alines[i]->line[j].ch); 1365 __CTRACE(__CTRACE_REFRESH, "\n"); 1366 __CTRACE(__CTRACE_REFRESH, " attr:"); 1367 for (j = 0; j < curscr->maxx; j++) 1368 __CTRACE(__CTRACE_REFRESH, " %x", 1369 curscr->alines[i]->line[j].attr); 1370 __CTRACE(__CTRACE_REFRESH, "\n"); 1371 __CTRACE(__CTRACE_REFRESH, "W: %d:", i); 1372 __CTRACE(__CTRACE_REFRESH, " 0x%x \n", 1373 __virtscr->alines[i]->hash); 1374 __CTRACE(__CTRACE_REFRESH, " 0x%x ", 1375 __virtscr->alines[i]->flags); 1376 for (j = 0; j < __virtscr->maxx; j++) 1377 __CTRACE(__CTRACE_REFRESH, "%c", 1378 __virtscr->alines[i]->line[j].ch); 1379 __CTRACE(__CTRACE_REFRESH, "\n"); 1380 __CTRACE(__CTRACE_REFRESH, " attr:"); 1381 for (j = 0; j < __virtscr->maxx; j++) 1382 __CTRACE(__CTRACE_REFRESH, " %x", 1383 __virtscr->alines[i]->line[j].attr); 1384 __CTRACE(__CTRACE_REFRESH, "\n"); 1385 } 1386 #endif 1387 1388 #ifndef HAVE_WCHAR 1389 if (buf[0].ch != ' ') { 1390 for (i = 0; i < BLANKSIZE; i++) { 1391 buf[i].ch = ' '; 1392 buf[i].attr = 0; 1393 } 1394 } 1395 #else 1396 if (buf[0].ch != ( wchar_t )btowc(( int ) curscr->bch )) { 1397 for (i = 0; i < BLANKSIZE; i++) { 1398 buf[i].ch = ( wchar_t )btowc(( int ) curscr->bch ); 1399 if (_cursesi_copy_nsp(curscr->bnsp, &buf[i]) == ERR) 1400 return; 1401 buf[i].attr = 0; 1402 SET_WCOL( buf[ i ], 1 ); 1403 } 1404 } 1405 #endif /* HAVE_WCHAR */ 1406 1407 if (__virtscr->maxx != last_hash_len) { 1408 blank_hash = 0; 1409 for (i = __virtscr->maxx; i > BLANKSIZE; i -= BLANKSIZE) { 1410 blank_hash = __hash_more(buf, sizeof(buf), blank_hash); 1411 } 1412 blank_hash = __hash_more((char *)(void *)buf, 1413 i * sizeof(buf[0]), blank_hash); 1414 /* cache result in static data - screen width doesn't change often */ 1415 last_hash_len = __virtscr->maxx; 1416 last_hash = blank_hash; 1417 } else 1418 blank_hash = last_hash; 1419 1420 /* 1421 * Perform the rotation to maintain the consistency of curscr. 1422 * This is hairy since we are doing an *in place* rotation. 1423 * Invariants of the loop: 1424 * - I is the index of the current line. 1425 * - Target is the index of the target of line i. 1426 * - Tmp1 points to current line (i). 1427 * - Tmp2 and points to target line (target); 1428 * - Cur_period is the index of the end of the current period. 1429 * (see below). 1430 * 1431 * There are 2 major issues here that make this rotation non-trivial: 1432 * 1. Scrolling in a scrolling region bounded by the top 1433 * and bottom regions determined (whose size is sc_region). 1434 * 2. As a result of the use of the mod function, there may be a 1435 * period introduced, i.e., 2 maps to 4, 4 to 6, n-2 to 0, and 1436 * 0 to 2, which then causes all odd lines not to be rotated. 1437 * To remedy this, an index of the end ( = beginning) of the 1438 * current 'period' is kept, cur_period, and when it is reached, 1439 * the next period is started from cur_period + 1 which is 1440 * guaranteed not to have been reached since that would mean that 1441 * all records would have been reached. (think about it...). 1442 * 1443 * Lines in the rotation can have 3 attributes which are marked on the 1444 * line so that curscr is consistent with the visual screen. 1445 * 1. Not dirty -- lines inside the scrolled block, top region or 1446 * bottom region. 1447 * 2. Blank lines -- lines in the differential of the scrolling 1448 * region adjacent to top and bot regions 1449 * depending on scrolling direction. 1450 * 3. Dirty line -- all other lines are marked dirty. 1451 */ 1452 sc_region = bot - top + 1; 1453 i = top; 1454 tmp1 = curscr->alines[top]; 1455 cur_period = top; 1456 for (j = top; j <= bot; j++) { 1457 target = (i - top + n + sc_region) % sc_region + top; 1458 tmp2 = curscr->alines[target]; 1459 curscr->alines[target] = tmp1; 1460 /* Mark block as clean and blank out scrolled lines. */ 1461 clp = curscr->alines[target]; 1462 #ifdef DEBUG 1463 __CTRACE(__CTRACE_REFRESH, 1464 "quickch: n=%d startw=%d curw=%d i = %d target=%d ", 1465 n, startw, curw, i, target); 1466 #endif 1467 if ((target >= startw && target < curw) || target < top 1468 || target > bot) { 1469 #ifdef DEBUG 1470 __CTRACE(__CTRACE_REFRESH, " notdirty\n"); 1471 #endif 1472 __virtscr->alines[target]->flags &= ~__ISDIRTY; 1473 } else 1474 if ((n > 0 && target >= top && target < top + n) || 1475 (n < 0 && target <= bot && target > bot + n)) { 1476 #ifndef HAVE_WCHAR 1477 if (clp->hash != blank_hash || 1478 memcmp(clp->line, clp->line + 1, 1479 (__virtscr->maxx - 1) 1480 * __LDATASIZE) || 1481 memcmp(clp->line, buf, __LDATASIZE)) { 1482 #else 1483 if (clp->hash != blank_hash 1484 || linecmp(clp->line, clp->line + 1, 1485 (unsigned int) (__virtscr->maxx - 1)) 1486 || cellcmp(clp->line, buf)) { 1487 #endif /* HAVE_WCHAR */ 1488 for (i = __virtscr->maxx; 1489 i > BLANKSIZE; 1490 i -= BLANKSIZE) { 1491 (void) memcpy(clp->line + i - 1492 BLANKSIZE, buf, sizeof(buf)); 1493 } 1494 (void) memcpy(clp->line , buf, i * 1495 sizeof(buf[0])); 1496 #ifdef DEBUG 1497 __CTRACE(__CTRACE_REFRESH, 1498 " blanked out: dirty\n"); 1499 #endif 1500 clp->hash = blank_hash; 1501 __touchline(__virtscr, target, 0, (int) __virtscr->maxx - 1); 1502 } else { 1503 #ifdef DEBUG 1504 __CTRACE(__CTRACE_REFRESH, 1505 " -- blank line already: dirty\n"); 1506 #endif 1507 __touchline(__virtscr, target, 0, (int) __virtscr->maxx - 1); 1508 } 1509 } else { 1510 #ifdef DEBUG 1511 __CTRACE(__CTRACE_REFRESH, " -- dirty\n"); 1512 #endif 1513 __touchline(__virtscr, target, 0, (int) __virtscr->maxx - 1); 1514 } 1515 if (target == cur_period) { 1516 i = target + 1; 1517 tmp1 = curscr->alines[i]; 1518 cur_period = i; 1519 } else { 1520 tmp1 = tmp2; 1521 i = target; 1522 } 1523 } 1524 #ifdef DEBUG 1525 __CTRACE(__CTRACE_REFRESH, "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n"); 1526 for (i = 0; i < curscr->maxy; i++) { 1527 __CTRACE(__CTRACE_REFRESH, "C: %d:", i); 1528 for (j = 0; j < curscr->maxx; j++) 1529 __CTRACE(__CTRACE_REFRESH, "%c", 1530 curscr->alines[i]->line[j].ch); 1531 __CTRACE(__CTRACE_REFRESH, "\n"); 1532 __CTRACE(__CTRACE_REFRESH, "W: %d:", i); 1533 for (j = 0; j < __virtscr->maxx; j++) 1534 __CTRACE(__CTRACE_REFRESH, "%c", 1535 __virtscr->alines[i]->line[j].ch); 1536 __CTRACE(__CTRACE_REFRESH, "\n"); 1537 } 1538 #endif 1539 if (n != 0) 1540 scrolln(starts, startw, curs, bot, top); 1541 } 1542 1543 /* 1544 * scrolln -- 1545 * Scroll n lines, where n is starts - startw. 1546 */ 1547 static void /* ARGSUSED */ 1548 scrolln(starts, startw, curs, bot, top) 1549 int starts, startw, curs, bot, top; 1550 { 1551 int i, oy, ox, n; 1552 1553 oy = curscr->cury; 1554 ox = curscr->curx; 1555 n = starts - startw; 1556 1557 /* 1558 * XXX 1559 * The initial tests that set __noqch don't let us reach here unless 1560 * we have either cs + ho + SF/sf/SR/sr, or AL + DL. SF/sf and SR/sr 1561 * scrolling can only shift the entire scrolling region, not just a 1562 * part of it, which means that the quickch() routine is going to be 1563 * sadly disappointed in us if we don't have cs as well. 1564 * 1565 * If cs, ho and SF/sf are set, can use the scrolling region. Because 1566 * the cursor position after cs is undefined, we need ho which gives us 1567 * the ability to move to somewhere without knowledge of the current 1568 * location of the cursor. Still call __mvcur() anyway, to update its 1569 * idea of where the cursor is. 1570 * 1571 * When the scrolling region has been set, the cursor has to be at the 1572 * last line of the region to make the scroll happen. 1573 * 1574 * Doing SF/SR or AL/DL appears faster on the screen than either sf/sr 1575 * or AL/DL, and, some terminals have AL/DL, sf/sr, and cs, but not 1576 * SF/SR. So, if we're scrolling almost all of the screen, try and use 1577 * AL/DL, otherwise use the scrolling region. The "almost all" is a 1578 * shameless hack for vi. 1579 */ 1580 if (n > 0) { 1581 if (change_scroll_region != NULL && cursor_home != NULL && 1582 (parm_index != NULL || 1583 ((parm_insert_line == NULL || parm_delete_line == NULL || 1584 top > 3 || bot + 3 < __virtscr->maxy) && 1585 scroll_forward != NULL))) 1586 { 1587 tputs(tiparm(change_scroll_region, top, bot), 1588 0, __cputchar); 1589 __mvcur(oy, ox, 0, 0, 1); 1590 tputs(cursor_home, 0, __cputchar); 1591 __mvcur(0, 0, bot, 0, 1); 1592 if (parm_index != NULL) 1593 tputs(tiparm(parm_index, n), 1594 0, __cputchar); 1595 else 1596 for (i = 0; i < n; i++) 1597 tputs(scroll_forward, 0, __cputchar); 1598 tputs(tiparm(change_scroll_region, 1599 0, (int) __virtscr->maxy - 1), 0, __cputchar); 1600 __mvcur(bot, 0, 0, 0, 1); 1601 tputs(cursor_home, 0, __cputchar); 1602 __mvcur(0, 0, oy, ox, 1); 1603 return; 1604 } 1605 1606 /* Scroll up the block. */ 1607 if (parm_index != NULL && top == 0) { 1608 __mvcur(oy, ox, bot, 0, 1); 1609 tputs(tiparm(parm_index, n), 0, __cputchar); 1610 } else 1611 if (parm_delete_line != NULL) { 1612 __mvcur(oy, ox, top, 0, 1); 1613 tputs(tiparm(parm_delete_line, n), 1614 0, __cputchar); 1615 } else 1616 if (delete_line != NULL) { 1617 __mvcur(oy, ox, top, 0, 1); 1618 for (i = 0; i < n; i++) 1619 tputs(delete_line, 1620 0, __cputchar); 1621 } else 1622 if (scroll_forward != NULL && top == 0) { 1623 __mvcur(oy, ox, bot, 0, 1); 1624 for (i = 0; i < n; i++) 1625 tputs(scroll_forward, 0, 1626 __cputchar); 1627 } else 1628 abort(); 1629 1630 /* Push down the bottom region. */ 1631 __mvcur(top, 0, bot - n + 1, 0, 1); 1632 if (parm_insert_line != NULL) 1633 tputs(tiparm(parm_insert_line, n), 0, __cputchar); 1634 else 1635 if (insert_line != NULL) 1636 for (i = 0; i < n; i++) 1637 tputs(insert_line, 0, __cputchar); 1638 else 1639 abort(); 1640 __mvcur(bot - n + 1, 0, oy, ox, 1); 1641 } else { 1642 /* 1643 * !!! 1644 * n < 0 1645 * 1646 * If cs, ho and SR/sr are set, can use the scrolling region. 1647 * See the above comments for details. 1648 */ 1649 if (change_scroll_region != NULL && cursor_home != NULL && 1650 (parm_rindex != NULL || 1651 ((parm_insert_line == NULL || parm_delete_line == NULL || 1652 top > 3 || 1653 bot + 3 < __virtscr->maxy) && scroll_reverse != NULL))) 1654 { 1655 tputs(tiparm(change_scroll_region, top, bot), 1656 0, __cputchar); 1657 __mvcur(oy, ox, 0, 0, 1); 1658 tputs(cursor_home, 0, __cputchar); 1659 __mvcur(0, 0, top, 0, 1); 1660 1661 if (parm_rindex != NULL) 1662 tputs(tiparm(parm_rindex, -n), 1663 0, __cputchar); 1664 else 1665 for (i = n; i < 0; i++) 1666 tputs(scroll_reverse, 0, __cputchar); 1667 tputs(tiparm(change_scroll_region, 1668 0, (int) __virtscr->maxy - 1), 0, __cputchar); 1669 __mvcur(top, 0, 0, 0, 1); 1670 tputs(cursor_home, 0, __cputchar); 1671 __mvcur(0, 0, oy, ox, 1); 1672 return; 1673 } 1674 1675 /* Preserve the bottom lines. */ 1676 __mvcur(oy, ox, bot + n + 1, 0, 1); 1677 if (parm_rindex != NULL && bot == __virtscr->maxy) 1678 tputs(tiparm(parm_rindex, -n), 0, __cputchar); 1679 else 1680 if (parm_delete_line != NULL) 1681 tputs(tiparm(parm_delete_line, -n), 1682 0, __cputchar); 1683 else 1684 if (delete_line != NULL) 1685 for (i = n; i < 0; i++) 1686 tputs(delete_line, 1687 0, __cputchar); 1688 else 1689 if (scroll_reverse != NULL && 1690 bot == __virtscr->maxy) 1691 for (i = n; i < 0; i++) 1692 tputs(scroll_reverse, 0, 1693 __cputchar); 1694 else 1695 abort(); 1696 1697 /* Scroll the block down. */ 1698 __mvcur(bot + n + 1, 0, top, 0, 1); 1699 if (parm_insert_line != NULL) 1700 tputs(tiparm(parm_insert_line, -n), 0, __cputchar); 1701 else 1702 if (insert_line != NULL) 1703 for (i = n; i < 0; i++) 1704 tputs(insert_line, 0, __cputchar); 1705 else 1706 abort(); 1707 __mvcur(top, 0, oy, ox, 1); 1708 } 1709 } 1710 1711 /* 1712 * __unsetattr -- 1713 * Unset attributes on curscr. Leave standout, attribute and colour 1714 * modes if necessary (!ms). Always leave altcharset (xterm at least 1715 * ignores a cursor move if we don't). 1716 */ 1717 void /* ARGSUSED */ 1718 __unsetattr(int checkms) 1719 { 1720 int isms; 1721 1722 if (checkms) 1723 if (!move_standout_mode) { 1724 isms = 1; 1725 } else { 1726 isms = 0; 1727 } 1728 else 1729 isms = 1; 1730 #ifdef DEBUG 1731 __CTRACE(__CTRACE_REFRESH, 1732 "__unsetattr: checkms = %d, ms = %s, wattr = %08x\n", 1733 checkms, move_standout_mode ? "TRUE" : "FALSE", curscr->wattr); 1734 #endif 1735 1736 /* 1737 * Don't leave the screen in standout mode (check against ms). Check 1738 * to see if we also turn off underscore, attributes and colour. 1739 */ 1740 if (curscr->wattr & __STANDOUT && isms) { 1741 tputs(exit_standout_mode, 0, __cputchar); 1742 curscr->wattr &= __mask_se; 1743 } 1744 /* 1745 * Don't leave the screen in underscore mode (check against ms). 1746 * Check to see if we also turn off attributes. Assume that we 1747 * also turn off colour. 1748 */ 1749 if (curscr->wattr & __UNDERSCORE && isms) { 1750 tputs(exit_underline_mode, 0, __cputchar); 1751 curscr->wattr &= __mask_ue; 1752 } 1753 /* 1754 * Don't leave the screen with attributes set (check against ms). 1755 * Assume that also turn off colour. 1756 */ 1757 if (curscr->wattr & __TERMATTR && isms) { 1758 tputs(exit_attribute_mode, 0, __cputchar); 1759 curscr->wattr &= __mask_me; 1760 } 1761 /* Don't leave the screen with altcharset set (don't check ms). */ 1762 if (curscr->wattr & __ALTCHARSET) { 1763 tputs(exit_alt_charset_mode, 0, __cputchar); 1764 curscr->wattr &= ~__ALTCHARSET; 1765 } 1766 /* Don't leave the screen with colour set (check against ms). */ 1767 if (__using_color && isms) 1768 __unset_color(curscr); 1769 } 1770 1771 #ifdef HAVE_WCHAR 1772 /* compare two cells on screen, must have the same forground/background, 1773 * and the same sequence of non-spacing characters */ 1774 int 1775 cellcmp( __LDATA *x, __LDATA *y ) 1776 { 1777 nschar_t *xnp = x->nsp, *ynp = y->nsp; 1778 int ret = ( x->ch == y->ch ) & ( x->attr == y->attr ); 1779 1780 if ( !ret ) 1781 return 0; 1782 if ( !xnp && !ynp ) 1783 return 1; 1784 if (( xnp && !ynp ) || ( !xnp && ynp )) 1785 return 0; 1786 1787 while ( xnp && ynp ) { 1788 if ( xnp->ch != ynp->ch ) 1789 return 0; 1790 xnp = xnp->next; 1791 ynp = ynp->next; 1792 } 1793 return ( !xnp && !ynp ); 1794 } 1795 1796 /* compare two line segments */ 1797 int 1798 linecmp( __LDATA *xl, __LDATA *yl, size_t len ) 1799 { 1800 int i = 0; 1801 __LDATA *xp = xl, *yp = yl; 1802 1803 for ( i = 0; i < len; i++, xp++, yp++ ) { 1804 if ( !cellcmp( xp, yp )) 1805 return 0; 1806 } 1807 return 1; 1808 } 1809 1810 /* 1811 * Output the non-spacing characters associated with the given character 1812 * cell to the screen. 1813 */ 1814 1815 void 1816 __cursesi_putnsp(nschar_t *nsp, const int wy, const int wx) 1817 { 1818 nschar_t *p; 1819 1820 /* this shuts up gcc warnings about wx and wy not being used */ 1821 if (wx > wy) { 1822 } 1823 1824 p = nsp; 1825 while (p != NULL) { 1826 __cputwchar((int) p->ch); 1827 #ifdef DEBUG 1828 __CTRACE(__CTRACE_REFRESH, 1829 "_cursesi_putnsp: (%d,%d) non-spacing putwchar(0x%x)\n", 1830 wy, wx - 1, p->ch); 1831 #endif 1832 p = p->next; 1833 } 1834 } 1835 1836 #endif /* HAVE_WCHAR */ 1837