![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ll_refresh.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / ncurses / screen|
Return to ll_refresh.c CVS log | Up to [Research Unix] / researchv10no / ncurses / screen |
1.1 ! root 1: /* @(#)ll_refresh.c 1.1 (1.22) */ ! 2: #include "curses.ext" ! 3: ! 4: extern int InputPending; ! 5: extern int outchcount; ! 6: ! 7: extern int *context; ! 8: ! 9: int didntdobotright; /* writechars didn't output char in bot right corner */ ! 10: ! 11: /* ! 12: * Optimally make the screen (which currently looks like SP->cur_body) ! 13: * look like SP->std_body. If use_idl is 1, this routine will call ! 14: * out all its horses, including some code to figure out ! 15: * how to use insert/delete line. If use_idl is 0, or if the terminal ! 16: * does not have insert/delete line, a simpler scheme will ! 17: * be used, and the insert/delete line features of the terminal will not ! 18: * be used. ! 19: * ! 20: * While the original intent of this parameter was speed (insert/delete ! 21: * line was slow) the parameter currently is there to avoid annoying ! 22: * the user with unnecessary insert/delete lines. ! 23: */ ! 24: int ! 25: _ll_refresh (use_idl) ! 26: int use_idl; ! 27: { ! 28: register int n, i, j; ! 29: register struct line *dln, *pln; ! 30: struct line *_line_alloc(); ! 31: ! 32: #ifdef DEBUG ! 33: if(outf) fprintf(outf, "_ll_refresh(%d)\n", use_idl); ! 34: if(outf) fprintf(outf, "phys cursor at (%d,%d), want cursor at (%d,%d)\n", ! 35: SP->phys_y, SP->phys_x, SP->virt_y, SP->virt_x); ! 36: #endif DEBUG ! 37: outchcount = 0; ! 38: #ifdef FIONREAD ! 39: if( SP->check_fd >= 0 ) ! 40: { ! 41: ioctl (SP->check_fd, FIONREAD, &InputPending); ! 42: } ! 43: else ! 44: { ! 45: InputPending = 0; ! 46: } ! 47: if( InputPending ) ! 48: { ! 49: #ifdef DEBUG ! 50: if (outf) fprintf(outf, "InputPending %d, aborted ll_refresh at start\n", InputPending); ! 51: #endif DEBUG ! 52: return 0; ! 53: } ! 54: #endif FIONREAD ! 55: #ifdef NONSTANDARD ! 56: input_wait(); ! 57: #endif NONSTANDARD ! 58: #ifdef DEBUG ! 59: if (outf) fprintf(outf, "virt cursor at y=%d, x=%d, length %d, length-1 %d\n", ! 60: SP->virt_y, SP->virt_x, SP->std_body[SP->virt_y+1]->length, ! 61: SP->std_body[SP->virt_y]->length); ! 62: #endif DEBUG ! 63: if( SP->virt_y >= 0 && SP->std_body[SP->virt_y+1]->length < SP->virt_x ) ! 64: { ! 65: SP->std_body[SP->virt_y+1]->length = ! 66: SP->virt_x >= columns ? columns : SP->virt_x; ! 67: } ! 68: /* Get rid of trailing blanks on all lines */ ! 69: for( n = 1; n <= lines; n++ ) ! 70: { ! 71: dln = SP->std_body[n]; ! 72: pln = SP->cur_body[n]; ! 73: if( dln && dln != pln ) ! 74: { ! 75: register chtype *p; ! 76: ! 77: if( i = dln->length ) ! 78: { ! 79: p = dln->body + i; ! 80: while( *--p == ' ' && --i > 0 ) ! 81: ; ! 82: dln->length = i; ! 83: } ! 84: } ! 85: ! 86: if( pln ) ! 87: { ! 88: register chtype *p; ! 89: ! 90: if( i = pln->length ) ! 91: { ! 92: p = pln->body + i; ! 93: while( *--p == ' ' && --i > 0 ) ! 94: ; ! 95: pln->length = i; ! 96: } ! 97: } ! 98: } ! 99: if( magic_cookie_glitch > 0 ) ! 100: _toss_cookies(); ! 101: #ifdef DEBUG ! 102: if(outf) fprintf(outf, "what we have:\n"); ! 103: for( i=1; i<=lines; i++ ) ! 104: { ! 105: if(outf) fprintf(outf, "%8x: ", SP->cur_body[i]); ! 106: if( SP->cur_body[i] == NULL ) ! 107: { ! 108: if(outf) fprintf(outf, "()\n"); ! 109: } ! 110: else ! 111: { ! 112: if(outf) fprintf(outf, "%4d ", SP->cur_body[i]->length); ! 113: for( j=0; j<SP->cur_body[i]->length; j++ ) ! 114: { ! 115: n = SP->cur_body[i]->body[j]; ! 116: if( n & A_ATTRIBUTES ) ! 117: { ! 118: putc('\'', outf); ! 119: } ! 120: n &= 0177; ! 121: if(outf) fprintf(outf, "%c", n>=' ' ? n : '.'); ! 122: } ! 123: if(outf) fprintf(outf, "\n"); ! 124: } ! 125: } ! 126: if(outf) fprintf(outf, "what we want:\n"); ! 127: for (i=1; i<=lines; i++) ! 128: { ! 129: if(outf) fprintf(outf, "%8x: ", SP->std_body[i]); ! 130: if (SP->std_body[i] == NULL) ! 131: { ! 132: if(outf) fprintf(outf, "()\n"); ! 133: } ! 134: else ! 135: { ! 136: if(outf) fprintf(outf, "%4d ", SP->std_body[i]->length); ! 137: for (j=0; j<SP->std_body[i]->length; j++) ! 138: { ! 139: n = SP->std_body[i]->body[j]; ! 140: if (n & A_ATTRIBUTES) ! 141: { ! 142: putc('\'', outf); ! 143: } ! 144: n &= 0177; ! 145: if(outf) fprintf(outf, "%c", n>=' ' ? n : '.'); ! 146: } ! 147: if(outf) fprintf(outf, "\n"); ! 148: } ! 149: } ! 150: if(outf) fprintf(outf, "----\n"); ! 151: if(outf) fflush(outf); ! 152: #endif DEBUG ! 153: SP->check_input = SP->baud / 2400; ! 154: if (SP->doclear) ! 155: { ! 156: #ifdef DEBUG ! 157: if(outf) fprintf(outf, "SP->doclear, clearing screen\n"); ! 158: #endif ! 159: _reset(); ! 160: SP->doclear = 0; ! 161: for( n = 0; n <= lines; n++ ) ! 162: { ! 163: if( SP->cur_body[n] != SP->std_body[n] ) ! 164: { ! 165: _line_free( SP->cur_body[n] ); ! 166: } ! 167: SP->cur_body[n] = 0; ! 168: } ! 169: } ! 170: ! 171: /* Choose between two updating algorithms. */ ! 172: if( use_idl && _cost(ilfixed) < INFINITY ) ! 173: { ! 174: #ifdef DEBUG ! 175: if(outf) fprintf(outf, "use_idl\n"); ! 176: #endif ! 177: for( n = 1; n <= lines; n++ ) ! 178: { ! 179: if( SP->cur_body[n] == 0 ) ! 180: { ! 181: SP->cur_body[n] = _line_alloc(); ! 182: } ! 183: if( SP->std_body[n] == 0 ) ! 184: { ! 185: SP->std_body[n] = SP->cur_body[n]; ! 186: } ! 187: else ! 188: { ! 189: _comphash( SP->std_body[n] ); ! 190: } ! 191: _comphash( SP->cur_body[n] ); ! 192: } ! 193: /* ! 194: * Count number of matches if we scroll 1 line and if we ! 195: * don't scroll at all. This is primarily useful for the ! 196: * case where we scroll the whole screen. Scrolling a portion ! 197: * of the screen will be handled by the ins/del line routines, ! 198: * although a special case here might buy some CPU speed. ! 199: */ ! 200: for( i=1,n=0,j=0; i<lines; i++ ) ! 201: { ! 202: if( SP->cur_body[i+1]->hash == SP->std_body[i]->hash ) ! 203: n++; ! 204: if( SP->cur_body[i]->hash == SP->std_body[i]->hash ) ! 205: j++; ! 206: } ! 207: if( n > lines-3 && n > j ) ! 208: { ! 209: _window(0, lines-1, 0, columns-1); ! 210: _scrollf(1); ! 211: _line_free(SP->cur_body[1]); ! 212: for( i=1; i<lines; i++ ) ! 213: { ! 214: /* Copy line with two references since they ! 215: * are no longer the same row on screen. */ ! 216: if( SP->cur_body[i+1] == SP->std_body[i+1] ) ! 217: { ! 218: struct line *p; ! 219: int l; ! 220: chtype *b1, *b2; ! 221: p = _line_alloc (); ! 222: p->length=l=SP->cur_body[i+1]->length; ! 223: p->hash = SP->cur_body[i+1]->hash; ! 224: b1 = &(p->body[0]); ! 225: b2 = &(SP->cur_body[i+1]->body[0]); ! 226: for( ; l>0; l-- ) ! 227: { ! 228: *b1++ = *b2++; ! 229: } ! 230: SP->std_body[i+1] = p; ! 231: } ! 232: SP->cur_body[i] = SP->cur_body[i+1]; ! 233: } ! 234: SP->cur_body[lines] = _line_alloc(); ! 235: } ! 236: i = 1; ! 237: /* ! 238: * Break the screen (from 1 to lines) into clumps of ! 239: * lines that are different. Thus we ignore the ones that ! 240: * are identical. ! 241: */ ! 242: for( ;; ) ! 243: { ! 244: while( i<=lines && SP->cur_body[i]==SP->std_body[i] ) ! 245: { ! 246: i++; ! 247: } ! 248: if( i > lines ) ! 249: { ! 250: break; ! 251: } ! 252: for( j=i; j <= lines && ! 253: SP->cur_body[j] != SP->std_body[j]; j++) ! 254: ; ! 255: j--; ! 256: #ifdef DEBUG ! 257: if(outf) fprintf(outf, "window from %d to %d\n", i, j); ! 258: #endif ! 259: /* i thru j is a window of different lines. */ ! 260: if( i == j ) ! 261: { ! 262: _id_char(SP->cur_body[i], SP->std_body[i], i-1); ! 263: if( SP->cur_body[i] != SP->std_body[i] ) ! 264: { ! 265: _line_free (SP->cur_body[i]); ! 266: } ! 267: SP->cur_body[i] = SP->std_body[i]; ! 268: } ! 269: else ! 270: { ! 271: _window(i-1, j-1, 0, columns-1); ! 272: _setwind(); /* Force action for moves, etc */ ! 273: _id_line(i, j); ! 274: } ! 275: i = j+1; ! 276: } ! 277: } ! 278: else /* fast update */ ! 279: { ! 280: #ifdef DEBUG ! 281: if(outf) fprintf(outf, "Fast Update, lines %d\n", lines); ! 282: #endif ! 283: _window(0, lines-1, 0, columns-1); ! 284: _setwind(); /* Force action for moves, etc */ ! 285: for( n = 1; n <= lines; n++ ) ! 286: if( SP->std_body[n] != SP->cur_body[n] ) ! 287: { ! 288: _id_char( SP->cur_body[n],SP->std_body[n],n-1 ); ! 289: if( SP->cur_body[n] != SP->std_body[n] ) ! 290: { ! 291: _line_free (SP->cur_body[n]); ! 292: } ! 293: SP->cur_body[n] = SP->std_body[n]; ! 294: } ! 295: } ! 296: ! 297: /* ! 298: * Didn't output char in bottom right corner of screen. ! 299: * Remember this fact so that next time when it's higher ! 300: * on the screen, we'll fix it up. ! 301: */ ! 302: if( didntdobotright ) ! 303: { ! 304: int holdvx, holdvy; ! 305: #ifdef DEBUG ! 306: if (outf) fprintf(outf, "didntdobotright so setting SP->cur_body[%d]->body[%d] from '%c' to space.\n", lines, columns-1, SP->cur_body[lines]->body[columns-1]); ! 307: #endif ! 308: holdvx = SP->virt_x; ! 309: holdvy = SP->virt_y; ! 310: /* ! 311: * This code in effect marks the last line dirty ! 312: * so that the next time it will get fixed. It also ! 313: * splits the line back into virt/phys so we don't ! 314: * clobber the virtual part too. ! 315: */ ! 316: _ll_move(lines-1, columns-1); ! 317: SP->cur_body[lines]->body[columns-1] = ' '; ! 318: didntdobotright = 0; ! 319: /* Now restore the cursor we clobbered. */ ! 320: _ll_move(holdvy, holdvx); ! 321: } ! 322: ! 323: _hlmode(0); _sethl(); ! 324: #ifdef DEBUG ! 325: if(outf) fprintf(outf, "at end, phys SP->curptr at (%d,%d), want SP->curptr at (%d,%d)\n", ! 326: SP->phys_y, SP->phys_x, SP->virt_y, SP->virt_x); ! 327: #endif DEBUG ! 328: #ifdef notdef ! 329: if(magic_cookie_glitch > 0) ! 330: _fixcursor(); ! 331: #endif notdef ! 332: if( !InputPending && SP->virt_x >= 0 && SP->virt_y >= 0 ) ! 333: { ! 334: _pos (SP->virt_y, SP->virt_x); ! 335: } ! 336: __cflush(); ! 337: #ifdef DEBUG ! 338: if(outf) fprintf(outf, "end of _ll_refresh, InputPending %d\n", InputPending); ! 339: if(outf) fflush(outf); ! 340: #endif DEBUG ! 341: return outchcount; ! 342: } ! 343: ! 344: /* ! 345: * This routine is only needed on terminals with the "magic cookie" ! 346: * effect. The problem is that the designers of ! 347: * these terminals didn't allocate 16 bits for ! 348: * each character (7 for the character and 9 for attributes) but instead ! 349: * created some reserved "magic cookie" characters to tell the scan ! 350: * routine "you should change attributes now". This would be fine except ! 351: * that these cookies take up a space in memory, and usually display as a ! 352: * blank. This makes it impossible to display what the user really ! 353: * wanted, if he is using attributes for underlining, bold, etc. Such ! 354: * terminals include the Teleray 1061, TVI 912 and 950, Teletype ! 355: * DataSpeed 40, and Adds Regent 40. ! 356: * ! 357: * One approach to this problem is to make everybody pay the price of ! 358: * this effect, forcing the programmer to allocate a blank space ! 359: * when attributes are changed. This works cleanly but I consider it ! 360: * unacceptable. ! 361: * ! 362: * My approach is to simulate what the programmer (who wasn't thinking ! 363: * about these terminals) wanted as closely as possible. If there ! 364: * is a desired blank in there, we use that slot. If not, we shove the ! 365: * rest of the line to the right one space. (When several attributes ! 366: * are changed on one line, this can result in losing several characters ! 367: * from the right of the line.) ! 368: * ! 369: * This routine looks for places in SP->std_body where shoving to the ! 370: * right is needed, and does the required shoving. ! 371: */ ! 372: static ! 373: _toss_cookies() ! 374: { ! 375: register int i, j, len; ! 376: register struct line *dsi; ! 377: register chtype *b; ! 378: ! 379: #ifdef DEBUG ! 380: if(outf) fprintf(outf, "_toss_cookies\n"); ! 381: #endif ! 382: for( i=1; i<=lines; i++ ) ! 383: { ! 384: dsi = SP->std_body[i]; ! 385: if( dsi && dsi != SP->cur_body[i] ) ! 386: { ! 387: len = dsi->length; ! 388: b = dsi->body; ! 389: for( j=0; j<len; j++ ) ! 390: { ! 391: if( b[j]&A_ATTRIBUTES ) ! 392: { ! 393: #ifdef DEBUG ! 394: if(outf) fprintf(outf, "_shove, line %d, char %d, val %o\n", i, j, b[j]); ! 395: #endif ! 396: dsi->length = _shove(b, len, i); ! 397: break; ! 398: } ! 399: } ! 400: } ! 401: } ! 402: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.