1 /* display.c -- How to display Info windows. 2 $Id: display.c,v 1.4 2006/07/17 16:12:36 espie Exp $ 3 4 Copyright (C) 1993, 1997, 2003, 2004 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 20 Originally written by Brian Fox (bfox@ai.mit.edu). */ 21 22 #include "info.h" 23 #include "display.h" 24 25 extern int info_any_buffered_input_p (void); /* Found in session.c. */ 26 27 static void free_display (DISPLAY_LINE **display); 28 static DISPLAY_LINE **make_display (int width, int height); 29 30 void handle_tag (char *tag); 31 void handle_tag_start (char *tag); 32 void handle_tag_end (char *tag); 33 34 /* An array of display lines which tell us what is currently visible on 35 the display. */ 36 DISPLAY_LINE **the_display = (DISPLAY_LINE **)NULL; 37 38 /* Non-zero means do no output. */ 39 int display_inhibited = 0; 40 41 /* Initialize THE_DISPLAY to WIDTH and HEIGHT, with nothing in it. */ 42 void 43 display_initialize_display (int width, int height) 44 { 45 free_display (the_display); 46 the_display = make_display (width, height); 47 display_clear_display (the_display); 48 } 49 50 /* Clear all of the lines in DISPLAY making the screen blank. */ 51 void 52 display_clear_display (DISPLAY_LINE **display) 53 { 54 register int i; 55 56 for (i = 0; display[i]; i++) 57 { 58 display[i]->text[0] = '\0'; 59 display[i]->textlen = 0; 60 display[i]->inverse = 0; 61 } 62 } 63 64 /* Non-zero if we didn't completely redisplay a window. */ 65 int display_was_interrupted_p = 0; 66 67 /* Update the windows pointed to by WINDOW in the_display. This actually 68 writes the text on the screen. */ 69 void 70 display_update_display (WINDOW *window) 71 { 72 register WINDOW *win; 73 74 display_was_interrupted_p = 0; 75 76 /* For every window in the list, check contents against the display. */ 77 for (win = window; win; win = win->next) 78 { 79 /* Only re-display visible windows which need updating. */ 80 if (((win->flags & W_WindowVisible) == 0) || 81 ((win->flags & W_UpdateWindow) == 0) || 82 (win->height == 0)) 83 continue; 84 85 display_update_one_window (win); 86 if (display_was_interrupted_p) 87 break; 88 } 89 90 /* Always update the echo area. */ 91 display_update_one_window (the_echo_area); 92 } 93 94 void 95 handle_tag_start (char *tag) 96 { 97 /* TODO really handle this tag. */ 98 return; 99 } 100 101 void 102 handle_tag_end (char *tag) 103 { 104 /* TODO really handle this tag. */ 105 return; 106 } 107 108 void 109 handle_tag (char *tag) 110 { 111 if (tag[0] == '/') 112 { 113 tag++; 114 handle_tag_end (tag); 115 } 116 else 117 handle_tag_start (tag); 118 } 119 120 /* Display WIN on the_display. Unlike display_update_display (), this 121 function only does one window. */ 122 void 123 display_update_one_window (WINDOW *win) 124 { 125 register char *nodetext; /* Current character to display. */ 126 register char *last_node_char; /* Position of the last character in node. */ 127 register int i; /* General use index. */ 128 char *printed_line; /* Buffer for a printed line. */ 129 int pl_index = 0; /* Index into PRINTED_LINE. */ 130 int line_index = 0; /* Number of lines done so far. */ 131 int pl_ignore = 0; /* How many chars use zero width on screen. */ 132 int allocated_win_width; 133 DISPLAY_LINE **display = the_display; 134 135 /* If display is inhibited, that counts as an interrupted display. */ 136 if (display_inhibited) 137 display_was_interrupted_p = 1; 138 139 /* If the window has no height, or display is inhibited, quit now. */ 140 if (!win->height || display_inhibited) 141 return; 142 143 /* If the window's first row doesn't appear in the_screen, then it 144 cannot be displayed. This can happen when the_echo_area is the 145 window to be displayed, and the screen has shrunk to less than one 146 line. */ 147 if ((win->first_row < 0) || (win->first_row > the_screen->height)) 148 return; 149 150 /* Print each line in the window into our local buffer, and then 151 check the contents of that buffer against the display. If they 152 differ, update the display. */ 153 allocated_win_width = win->width + 1; 154 printed_line = (char *)xmalloc (allocated_win_width); 155 156 if (!win->node || !win->line_starts) 157 goto done_with_node_display; 158 159 nodetext = win->line_starts[win->pagetop]; 160 last_node_char = win->node->contents + win->node->nodelen; 161 162 for (; nodetext < last_node_char; nodetext++) 163 { 164 char *rep = NULL, *rep_carried_over, rep_temp[2]; 165 int replen; 166 167 if (isprint (*nodetext)) 168 { 169 rep_temp[0] = *nodetext; 170 replen = 1; 171 rep_temp[1] = '\0'; 172 rep = rep_temp; 173 } 174 else 175 { 176 if (*nodetext == '\r' || *nodetext == '\n') 177 { 178 replen = win->width - pl_index + pl_ignore; 179 } 180 else if (*nodetext == '\0' 181 && (nodetext + 2) < last_node_char 182 && *(nodetext + 1) == '\b' 183 && *(nodetext + 2) == '[') 184 { 185 /* Found new style tag/cookie \0\b[ 186 Read until the closing tag \0\b] */ 187 int element_len = 0; 188 char *element; 189 190 /* Skip the escapes. */ 191 nodetext += 3; 192 193 while (!(*nodetext == '\0' 194 && *(nodetext + 1) == '\b' 195 && *(nodetext + 2) == ']')) 196 { 197 nodetext++; 198 element_len++; 199 } 200 201 element = (char *) malloc (element_len + 1); 202 strncpy (element, nodetext - element_len, element_len); 203 204 /* Skip the escapes. */ 205 nodetext += 2; 206 pl_ignore += element_len + 5; 207 /* Append string terminator. */ 208 element[element_len] = '\0'; 209 210 handle_tag (element); 211 212 /* Over and out */ 213 free (element); 214 215 continue; 216 } 217 else 218 { 219 rep = printed_representation (*nodetext, pl_index); 220 replen = strlen (rep); 221 } 222 } 223 224 /* Support ANSI escape sequences under -R. */ 225 if (raw_escapes_p 226 && *nodetext == '\033' 227 && nodetext[1] == '[' 228 && isdigit (nodetext[2])) 229 { 230 if (nodetext[3] == 'm') 231 pl_ignore += 4; 232 else if (isdigit (nodetext[3]) && nodetext[4] == 'm') 233 pl_ignore += 5; 234 } 235 while (pl_index + 2 >= allocated_win_width - 1) 236 { 237 allocated_win_width *= 2; 238 printed_line = (char *)xrealloc (printed_line, allocated_win_width); 239 } 240 241 /* If this character can be printed without passing the width of 242 the line, then stuff it into the line. */ 243 if (replen + pl_index < win->width + pl_ignore) 244 { 245 /* Optimize if possible. */ 246 if (replen == 1) 247 { 248 printed_line[pl_index++] = *rep; 249 } 250 else 251 { 252 for (i = 0; i < replen; i++) 253 printed_line[pl_index++] = rep[i]; 254 } 255 } 256 else 257 { 258 DISPLAY_LINE *entry; 259 260 /* If this character cannot be printed in this line, we have 261 found the end of this line as it would appear on the screen. 262 Carefully print the end of the line, and then compare. */ 263 if (*nodetext == '\n' || *nodetext == '\r' || *nodetext == '\t') 264 { 265 printed_line[pl_index] = '\0'; 266 rep_carried_over = (char *)NULL; 267 } 268 else 269 { 270 /* The printed representation of this character extends into 271 the next line. Remember the offset of the last character 272 printed out of REP so that we can carry the character over 273 to the next line. */ 274 for (i = 0; pl_index < (win->width + pl_ignore - 1);) 275 printed_line[pl_index++] = rep[i++]; 276 277 rep_carried_over = rep + i; 278 279 /* If printing the last character in this window couldn't 280 possibly cause the screen to scroll, place a backslash 281 in the rightmost column. */ 282 if (1 + line_index + win->first_row < the_screen->height) 283 { 284 if (win->flags & W_NoWrap) 285 printed_line[pl_index++] = '$'; 286 else 287 printed_line[pl_index++] = '\\'; 288 } 289 printed_line[pl_index] = '\0'; 290 } 291 292 /* We have the exact line as it should appear on the screen. 293 Check to see if this line matches the one already appearing 294 on the screen. */ 295 entry = display[line_index + win->first_row]; 296 297 /* If the screen line is inversed, then we have to clear 298 the line from the screen first. Why, I don't know. 299 (But don't do this if we have no visible entries, as can 300 happen if the window is shrunk very small.) */ 301 if ((entry && entry->inverse) 302 /* Need to erase the line if it has escape sequences. */ 303 || (raw_escapes_p && strchr (entry->text, '\033') != 0)) 304 { 305 terminal_goto_xy (0, line_index + win->first_row); 306 terminal_clear_to_eol (); 307 entry->inverse = 0; 308 entry->text[0] = '\0'; 309 entry->textlen = 0; 310 } 311 312 /* Find the offset where these lines differ. */ 313 for (i = 0; i < pl_index; i++) 314 if (printed_line[i] != entry->text[i]) 315 break; 316 317 /* If the lines are not the same length, or if they differed 318 at all, we must do some redrawing. */ 319 if ((i != pl_index) || (pl_index != entry->textlen)) 320 { 321 /* Move to the proper point on the terminal. */ 322 terminal_goto_xy (i, line_index + win->first_row); 323 324 /* If there is any text to print, print it. */ 325 if (i != pl_index) 326 terminal_put_text (printed_line + i); 327 328 /* If the printed text didn't extend all the way to the edge 329 of the window, and text was appearing between here and the 330 edge of the window, clear from here to the end of the line. */ 331 if ((pl_index < win->width + pl_ignore 332 && pl_index < entry->textlen) 333 || (entry->inverse)) 334 terminal_clear_to_eol (); 335 336 fflush (stdout); 337 338 /* Update the display text buffer. */ 339 if (strlen (printed_line) > (unsigned int) screenwidth) 340 /* printed_line[] can include more than screenwidth 341 characters if we are under -R and there are escape 342 sequences in it. However, entry->text was 343 allocated (in display_initialize_display) for 344 screenwidth characters only. */ 345 entry->text = xrealloc (entry->text, strlen (printed_line)+1); 346 strcpy (entry->text + i, printed_line + i); 347 entry->textlen = pl_index; 348 349 /* Lines showing node text are not in inverse. Only modelines 350 have that distinction. */ 351 entry->inverse = 0; 352 } 353 354 /* We have done at least one line. Increment our screen line 355 index, and check against the bottom of the window. */ 356 if (++line_index == win->height) 357 break; 358 359 /* A line has been displayed, and the screen reflects that state. 360 If there is typeahead pending, then let that typeahead be read 361 now, instead of continuing with the display. */ 362 if (info_any_buffered_input_p ()) 363 { 364 free (printed_line); 365 display_was_interrupted_p = 1; 366 return; 367 } 368 369 /* Reset PL_INDEX to the start of the line. */ 370 pl_index = 0; 371 pl_ignore = 0; /* this is computed per line */ 372 373 /* If there are characters from REP left to print, stuff them 374 into the buffer now. */ 375 if (rep_carried_over) 376 for (; rep[pl_index]; pl_index++) 377 printed_line[pl_index] = rep[pl_index]; 378 379 /* If this window has chosen not to wrap lines, skip to the end 380 of the physical line in the buffer, and start a new line here. */ 381 if (pl_index && (win->flags & W_NoWrap)) 382 { 383 char *begin; 384 385 pl_index = 0; 386 printed_line[0] = '\0'; 387 388 begin = nodetext; 389 390 while ((nodetext < last_node_char) && (*nodetext != '\n')) 391 nodetext++; 392 } 393 } 394 } 395 396 done_with_node_display: 397 /* We have reached the end of the node or the end of the window. If it 398 is the end of the node, then clear the lines of the window from here 399 to the end of the window. */ 400 for (; line_index < win->height; line_index++) 401 { 402 DISPLAY_LINE *entry = display[line_index + win->first_row]; 403 404 /* If this line has text on it then make it go away. */ 405 if (entry && entry->textlen) 406 { 407 entry->textlen = 0; 408 entry->text[0] = '\0'; 409 410 terminal_goto_xy (0, line_index + win->first_row); 411 terminal_clear_to_eol (); 412 } 413 } 414 415 /* Finally, if this window has a modeline it might need to be redisplayed. 416 Check the window's modeline against the one in the display, and update 417 if necessary. */ 418 if ((win->flags & W_InhibitMode) == 0) 419 { 420 window_make_modeline (win); 421 line_index = win->first_row + win->height; 422 423 /* This display line must both be in inverse, and have the same 424 contents. */ 425 if ((!display[line_index]->inverse) || 426 (strcmp (display[line_index]->text, win->modeline) != 0)) 427 { 428 terminal_goto_xy (0, line_index); 429 terminal_begin_inverse (); 430 terminal_put_text (win->modeline); 431 terminal_end_inverse (); 432 strcpy (display[line_index]->text, win->modeline); 433 display[line_index]->inverse = 1; 434 display[line_index]->textlen = strlen (win->modeline); 435 fflush (stdout); 436 } 437 } 438 439 /* Okay, this window doesn't need updating anymore. */ 440 win->flags &= ~W_UpdateWindow; 441 free (printed_line); 442 fflush (stdout); 443 } 444 445 /* Scroll the region of the_display starting at START, ending at END, and 446 moving the lines AMOUNT lines. If AMOUNT is less than zero, the lines 447 are moved up in the screen, otherwise down. Actually, it is possible 448 for no scrolling to take place in the case that the terminal doesn't 449 support it. This doesn't matter to us. */ 450 void 451 display_scroll_display (int start, int end, int amount) 452 { 453 register int i, last; 454 DISPLAY_LINE *temp; 455 456 /* If this terminal cannot do scrolling, give up now. */ 457 if (!terminal_can_scroll) 458 return; 459 460 /* If there isn't anything displayed on the screen because it is too 461 small, quit now. */ 462 if (!the_display[0]) 463 return; 464 465 /* If there is typeahead pending, then don't actually do any scrolling. */ 466 if (info_any_buffered_input_p ()) 467 return; 468 469 /* Do it on the screen. */ 470 terminal_scroll_terminal (start, end, amount); 471 472 /* Now do it in the display buffer so our contents match the screen. */ 473 if (amount > 0) 474 { 475 last = end + amount; 476 477 /* Shift the lines to scroll right into place. */ 478 for (i = 0; i < (end - start); i++) 479 { 480 temp = the_display[last - i]; 481 the_display[last - i] = the_display[end - i]; 482 the_display[end - i] = temp; 483 } 484 485 /* The lines have been shifted down in the buffer. Clear all of the 486 lines that were vacated. */ 487 for (i = start; i != (start + amount); i++) 488 { 489 the_display[i]->text[0] = '\0'; 490 the_display[i]->textlen = 0; 491 the_display[i]->inverse = 0; 492 } 493 } 494 495 if (amount < 0) 496 { 497 last = start + amount; 498 for (i = 0; i < (end - start); i++) 499 { 500 temp = the_display[last + i]; 501 the_display[last + i] = the_display[start + i]; 502 the_display[start + i] = temp; 503 } 504 505 /* The lines have been shifted up in the buffer. Clear all of the 506 lines that are left over. */ 507 for (i = end + amount; i != end; i++) 508 { 509 the_display[i]->text[0] = '\0'; 510 the_display[i]->textlen = 0; 511 the_display[i]->inverse = 0; 512 } 513 } 514 } 515 516 /* Try to scroll lines in WINDOW. OLD_PAGETOP is the pagetop of WINDOW before 517 having had its line starts recalculated. OLD_STARTS is the list of line 518 starts that used to appear in this window. OLD_COUNT is the number of lines 519 that appear in the OLD_STARTS array. */ 520 void 521 display_scroll_line_starts (WINDOW *window, int old_pagetop, 522 char **old_starts, int old_count) 523 { 524 register int i, old, new; /* Indices into the line starts arrays. */ 525 int last_new, last_old; /* Index of the last visible line. */ 526 int old_first, new_first; /* Index of the first changed line. */ 527 int unchanged_at_top = 0; 528 int already_scrolled = 0; 529 530 /* Locate the first line which was displayed on the old window. */ 531 old_first = old_pagetop; 532 new_first = window->pagetop; 533 534 /* Find the last line currently visible in this window. */ 535 last_new = window->pagetop + (window->height - 1); 536 if (last_new > window->line_count) 537 last_new = window->line_count - 1; 538 539 /* Find the last line which used to be currently visible in this window. */ 540 last_old = old_pagetop + (window->height - 1); 541 if (last_old > old_count) 542 last_old = old_count - 1; 543 544 for (old = old_first, new = new_first; 545 old < last_old && new < last_new; 546 old++, new++) 547 if (old_starts[old] != window->line_starts[new]) 548 break; 549 else 550 unchanged_at_top++; 551 552 /* Loop through the old lines looking for a match in the new lines. */ 553 for (old = old_first + unchanged_at_top; old < last_old; old++) 554 { 555 for (new = new_first; new < last_new; new++) 556 if (old_starts[old] == window->line_starts[new]) 557 { 558 /* Find the extent of the matching lines. */ 559 for (i = 0; (old + i) < last_old; i++) 560 if (old_starts[old + i] != window->line_starts[new + i]) 561 break; 562 563 /* Scroll these lines if there are enough of them. */ 564 { 565 int start, end, amount; 566 567 start = (window->first_row 568 + ((old + already_scrolled) - old_pagetop)); 569 amount = new - (old + already_scrolled); 570 end = window->first_row + window->height; 571 572 /* If we are shifting the block of lines down, then the last 573 AMOUNT lines will become invisible. Thus, don't bother 574 scrolling them. */ 575 if (amount > 0) 576 end -= amount; 577 578 if ((end - start) > 0) 579 { 580 display_scroll_display (start, end, amount); 581 582 /* Some lines have been scrolled. Simulate the scrolling 583 by offsetting the value of the old index. */ 584 old += i; 585 already_scrolled += amount; 586 } 587 } 588 } 589 } 590 } 591 592 /* Move the screen cursor to directly over the current character in WINDOW. */ 593 void 594 display_cursor_at_point (WINDOW *window) 595 { 596 int vpos, hpos; 597 598 vpos = window_line_of_point (window) - window->pagetop + window->first_row; 599 hpos = window_get_cursor_column (window); 600 terminal_goto_xy (hpos, vpos); 601 fflush (stdout); 602 } 603 604 /* **************************************************************** */ 605 /* */ 606 /* Functions Static to this File */ 607 /* */ 608 /* **************************************************************** */ 609 610 /* Make a DISPLAY_LINE ** with width and height. */ 611 static DISPLAY_LINE ** 612 make_display (int width, int height) 613 { 614 register int i; 615 DISPLAY_LINE **display; 616 617 display = (DISPLAY_LINE **)xmalloc ((1 + height) * sizeof (DISPLAY_LINE *)); 618 619 for (i = 0; i < height; i++) 620 { 621 display[i] = (DISPLAY_LINE *)xmalloc (sizeof (DISPLAY_LINE)); 622 display[i]->text = (char *)xmalloc (1 + width); 623 display[i]->textlen = 0; 624 display[i]->inverse = 0; 625 } 626 display[i] = (DISPLAY_LINE *)NULL; 627 return (display); 628 } 629 630 /* Free the storage allocated to DISPLAY. */ 631 static void 632 free_display (DISPLAY_LINE **display) 633 { 634 register int i; 635 register DISPLAY_LINE *display_line; 636 637 if (!display) 638 return; 639 640 for (i = 0; (display_line = display[i]); i++) 641 { 642 free (display_line->text); 643 free (display_line); 644 } 645 free (display); 646 } 647