1 /*- 2 * Copyright (c) 1993, 1994 3 * The Regents of the University of California. All rights reserved. 4 * Copyright (c) 1993, 1994, 1995, 1996 5 * Keith Bostic. All rights reserved. 6 * 7 * See the LICENSE file for redistribution information. 8 */ 9 10 #include "config.h" 11 12 #include <sys/types.h> 13 #include <sys/queue.h> 14 #include <sys/time.h> 15 16 #include <bitstring.h> 17 #include <errno.h> 18 #include <limits.h> 19 #include <stdio.h> 20 #include <stdlib.h> 21 #include <string.h> 22 23 #include "../common/common.h" 24 #include "vi.h" 25 26 typedef enum { HORIZ_FOLLOW, HORIZ_PRECEDE, VERT_FOLLOW, VERT_PRECEDE } jdir_t; 27 28 static SCR *vs_getbg(SCR *, char *); 29 static void vs_insert(SCR *sp, GS *gp); 30 static int vs_join(SCR *, SCR **, jdir_t *); 31 32 /* 33 * vs_split -- 34 * Create a new screen, horizontally. 35 * 36 * PUBLIC: int vs_split(SCR *, SCR *, int); 37 */ 38 int vs_split(SCR * sp,SCR * new,int ccl)39 vs_split( 40 SCR *sp, 41 SCR *new, 42 int ccl) /* Colon-command line split. */ 43 { 44 GS *gp; 45 SMAP *smp; 46 size_t half; 47 int issmallscreen, splitup; 48 49 gp = sp->gp; 50 51 /* Check to see if it's possible. */ 52 /* XXX: The IS_ONELINE fix will change this, too. */ 53 if (sp->rows < 4) { 54 msgq(sp, M_ERR, 55 "222|Screen must be larger than %d lines to split", 4 - 1); 56 return (1); 57 } 58 59 /* Wait for any messages in the screen. */ 60 vs_resolve(sp, NULL, 1); 61 62 /* Get a new screen map. */ 63 CALLOC(sp, _HMAP(new), SIZE_HMAP(sp), sizeof(SMAP)); 64 if (_HMAP(new) == NULL) 65 return (1); 66 _HMAP(new)->lno = sp->lno; 67 _HMAP(new)->coff = 0; 68 _HMAP(new)->soff = 1; 69 70 /* Split the screen in half. */ 71 half = sp->rows / 2; 72 if (ccl && half > 6) 73 half = 6; 74 75 /* 76 * Small screens: see vs_refresh.c section 6a. Set a flag so 77 * we know to fix the screen up later. 78 */ 79 issmallscreen = IS_SMALL(sp); 80 81 /* The columns in the screen don't change. */ 82 new->coff = sp->coff; 83 new->cols = sp->cols; 84 85 /* 86 * Split the screen, and link the screens together. If creating a 87 * screen to edit the colon command line or the cursor is in the top 88 * half of the current screen, the new screen goes under the current 89 * screen. Else, it goes above the current screen. 90 * 91 * Recalculate current cursor position based on sp->lno, we're called 92 * with the cursor on the colon command line. Then split the screen 93 * in half and update the shared information. 94 */ 95 splitup = 96 !ccl && (vs_sm_cursor(sp, &smp) ? 0 : (smp - HMAP) + 1) >= half; 97 if (splitup) { /* Old is bottom half. */ 98 new->rows = sp->rows - half; /* New. */ 99 new->roff = sp->roff; 100 sp->rows = half; /* Old. */ 101 sp->roff += new->rows; 102 103 /* 104 * If the parent is the bottom half of the screen, shift 105 * the map down to match on-screen text. 106 */ 107 memcpy(_HMAP(sp), _HMAP(sp) + new->rows, 108 (sp->t_maxrows - new->rows) * sizeof(SMAP)); 109 } else { /* Old is top half. */ 110 new->rows = half; /* New. */ 111 sp->rows -= half; /* Old. */ 112 new->roff = sp->roff + sp->rows; 113 } 114 115 /* Adjust maximum text count. */ 116 sp->t_maxrows = IS_ONELINE(sp) ? 1 : sp->rows - 1; 117 new->t_maxrows = IS_ONELINE(new) ? 1 : new->rows - 1; 118 119 /* 120 * Small screens: see vs_refresh.c, section 6a. 121 * 122 * The child may have different screen options sizes than the parent, 123 * so use them. Guarantee that text counts aren't larger than the 124 * new screen sizes. 125 */ 126 if (issmallscreen) { 127 /* Fix the text line count for the parent. */ 128 if (splitup) 129 sp->t_rows -= new->rows; 130 131 /* Fix the parent screen. */ 132 if (sp->t_rows > sp->t_maxrows) 133 sp->t_rows = sp->t_maxrows; 134 if (sp->t_minrows > sp->t_maxrows) 135 sp->t_minrows = sp->t_maxrows; 136 137 /* Fix the child screen. */ 138 new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW); 139 if (new->t_rows > new->t_maxrows) 140 new->t_rows = new->t_maxrows; 141 if (new->t_minrows > new->t_maxrows) 142 new->t_minrows = new->t_maxrows; 143 } else { 144 sp->t_minrows = sp->t_rows = IS_ONELINE(sp) ? 1 : sp->rows - 1; 145 146 /* 147 * The new screen may be a small screen, even if the parent 148 * was not. Don't complain if O_WINDOW is too large, we're 149 * splitting the screen so the screen is much smaller than 150 * normal. 151 */ 152 new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW); 153 if (new->t_rows > new->rows - 1) 154 new->t_minrows = new->t_rows = 155 IS_ONELINE(new) ? 1 : new->rows - 1; 156 } 157 158 /* Adjust the ends of the new and old maps. */ 159 _TMAP(sp) = IS_ONELINE(sp) ? 160 _HMAP(sp) : _HMAP(sp) + (sp->t_rows - 1); 161 _TMAP(new) = IS_ONELINE(new) ? 162 _HMAP(new) : _HMAP(new) + (new->t_rows - 1); 163 164 /* Reset the length of the default scroll. */ 165 if ((sp->defscroll = sp->t_maxrows / 2) == 0) 166 sp->defscroll = 1; 167 if ((new->defscroll = new->t_maxrows / 2) == 0) 168 new->defscroll = 1; 169 170 /* Fit the screen into the logical chain. */ 171 vs_insert(new, sp->gp); 172 173 /* Tell the display that we're splitting. */ 174 (void)gp->scr_split(sp, new); 175 176 /* 177 * Initialize the screen flags: 178 * 179 * If we're in vi mode in one screen, we don't have to reinitialize. 180 * This isn't just a cosmetic fix. The path goes like this: 181 * 182 * return into vi(), SC_SSWITCH set 183 * call vs_refresh() with SC_STATUS set 184 * call vs_resolve to display the status message 185 * call vs_refresh() because the SC_SCR_VI bit isn't set 186 * 187 * Things go downhill at this point. 188 * 189 * Draw the new screen from scratch, and add a status line. 190 */ 191 F_SET(new, 192 SC_SCR_REFORMAT | SC_STATUS | 193 F_ISSET(sp, SC_EX | SC_VI | SC_SCR_VI | SC_SCR_EX | SC_READONLY)); 194 return (0); 195 } 196 197 /* 198 * vs_vsplit -- 199 * Create a new screen, vertically. 200 * 201 * PUBLIC: int vs_vsplit(SCR *, SCR *); 202 */ 203 int vs_vsplit(SCR * sp,SCR * new)204 vs_vsplit(SCR *sp, SCR *new) 205 { 206 GS *gp; 207 size_t cols; 208 209 gp = sp->gp; 210 211 /* Check to see if it's possible. */ 212 if (sp->cols / 2 <= MINIMUM_SCREEN_COLS) { 213 msgq(sp, M_ERR, 214 "288|Screen must be larger than %d columns to split", 215 MINIMUM_SCREEN_COLS * 2); 216 return (1); 217 } 218 219 /* Wait for any messages in the screen. */ 220 vs_resolve(sp, NULL, 1); 221 222 /* Get a new screen map. */ 223 CALLOC(sp, _HMAP(new), SIZE_HMAP(sp), sizeof(SMAP)); 224 if (_HMAP(new) == NULL) 225 return (1); 226 _HMAP(new)->lno = sp->lno; 227 _HMAP(new)->coff = 0; 228 _HMAP(new)->soff = 1; 229 230 /* 231 * Split the screen in half; we have to sacrifice a column to delimit 232 * the screens. 233 * 234 * XXX 235 * We always split to the right... that makes more sense to me, and 236 * I don't want to play the stupid games that I play when splitting 237 * horizontally. 238 * 239 * XXX 240 * We reserve a column for the screen, "knowing" that curses needs 241 * one. This should be worked out with the display interface. 242 */ 243 cols = sp->cols / 2; 244 new->cols = sp->cols - cols - 1; 245 sp->cols = cols; 246 new->coff = sp->coff + cols + 1; 247 sp->cno = 0; 248 249 /* Nothing else changes. */ 250 new->rows = sp->rows; 251 new->t_rows = sp->t_rows; 252 new->t_maxrows = sp->t_maxrows; 253 new->t_minrows = sp->t_minrows; 254 new->roff = sp->roff; 255 new->defscroll = sp->defscroll; 256 _TMAP(new) = _HMAP(new) + (new->t_rows - 1); 257 258 /* Fit the screen into the logical chain. */ 259 vs_insert(new, sp->gp); 260 261 /* Tell the display that we're splitting. */ 262 (void)gp->scr_split(sp, new); 263 264 /* Redraw the old screen from scratch. */ 265 F_SET(sp, SC_SCR_REFORMAT | SC_STATUS); 266 267 /* 268 * Initialize the screen flags: 269 * 270 * If we're in vi mode in one screen, we don't have to reinitialize. 271 * This isn't just a cosmetic fix. The path goes like this: 272 * 273 * return into vi(), SC_SSWITCH set 274 * call vs_refresh() with SC_STATUS set 275 * call vs_resolve to display the status message 276 * call vs_refresh() because the SC_SCR_VI bit isn't set 277 * 278 * Things go downhill at this point. 279 * 280 * Draw the new screen from scratch, and add a status line. 281 */ 282 F_SET(new, 283 SC_SCR_REFORMAT | SC_STATUS | 284 F_ISSET(sp, SC_EX | SC_VI | SC_SCR_VI | SC_SCR_EX | SC_READONLY)); 285 return (0); 286 } 287 288 /* 289 * vs_insert -- 290 * Insert the new screen into the correct place in the logical 291 * chain. 292 */ 293 static void vs_insert(SCR * sp,GS * gp)294 vs_insert(SCR *sp, GS *gp) 295 { 296 SCR *tsp; 297 298 gp = sp->gp; 299 300 /* Move past all screens with lower row numbers. */ 301 TAILQ_FOREACH(tsp, gp->dq, q) 302 if (tsp->roff >= sp->roff) 303 break; 304 /* 305 * Move past all screens with the same row number and lower 306 * column numbers. 307 */ 308 for (; tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) 309 if (tsp->roff != sp->roff || tsp->coff > sp->coff) 310 break; 311 312 /* 313 * If we reached the end, this screen goes there. Otherwise, 314 * put it before or after the screen where we stopped. 315 */ 316 if (tsp == NULL) { 317 TAILQ_INSERT_TAIL(gp->dq, sp, q); 318 } else if (tsp->roff < sp->roff || 319 (tsp->roff == sp->roff && tsp->coff < sp->coff)) { 320 TAILQ_INSERT_AFTER(gp->dq, tsp, sp, q); 321 } else 322 TAILQ_INSERT_BEFORE(tsp, sp, q); 323 } 324 325 /* 326 * vs_discard -- 327 * Discard the screen, folding the real-estate into a related screen, 328 * if one exists, and return that screen. 329 * 330 * PUBLIC: int vs_discard(SCR *, SCR **); 331 */ 332 int vs_discard(SCR * sp,SCR ** spp)333 vs_discard(SCR *sp, SCR **spp) 334 { 335 GS *gp; 336 SCR *tsp, **lp, *list[100]; 337 jdir_t jdir; 338 339 gp = sp->gp; 340 341 /* 342 * Save the old screen's cursor information. 343 * 344 * XXX 345 * If called after file_end(), and the underlying file was a tmp 346 * file, it may have gone away. 347 */ 348 if (sp->frp != NULL) { 349 sp->frp->lno = sp->lno; 350 sp->frp->cno = sp->cno; 351 F_SET(sp->frp, FR_CURSORSET); 352 } 353 354 /* If no other screens to join, we're done. */ 355 if (!IS_SPLIT(sp)) { 356 (void)gp->scr_discard(sp, NULL); 357 358 if (spp != NULL) 359 *spp = NULL; 360 return (0); 361 } 362 363 /* 364 * Find a set of screens that cover one of the screen's borders. 365 * Check the vertical axis first, for no particular reason. 366 * 367 * XXX 368 * It's possible (I think?), to create a screen that shares no full 369 * border with any other set of screens, so we can't discard it. We 370 * just complain at the user until they clean it up. 371 */ 372 if (vs_join(sp, list, &jdir)) 373 return (1); 374 375 /* 376 * Modify the affected screens. Redraw the modified screen(s) from 377 * scratch, setting a status line. If this is ever a performance 378 * problem we could play games with the map, but I wrote that code 379 * before and it was never clean or easy. 380 * 381 * Don't clean up the discarded screen's information. If the screen 382 * isn't exiting, we'll do the work when the user redisplays it. 383 */ 384 switch (jdir) { 385 case HORIZ_FOLLOW: 386 case HORIZ_PRECEDE: 387 for (lp = &list[0]; (tsp = *lp) != NULL; ++lp) { 388 /* 389 * Small screens: see vs_refresh.c section 6a. Adjust 390 * text line info, unless it's a small screen. 391 * 392 * Reset the length of the default scroll. 393 * 394 * Reset the map references. 395 */ 396 tsp->rows += sp->rows; 397 if (!IS_SMALL(tsp)) 398 tsp->t_rows = tsp->t_minrows = tsp->rows - 1; 399 tsp->t_maxrows = tsp->rows - 1; 400 401 tsp->defscroll = tsp->t_maxrows / 2; 402 403 *(_HMAP(tsp) + (tsp->t_rows - 1)) = *_TMAP(tsp); 404 _TMAP(tsp) = _HMAP(tsp) + (tsp->t_rows - 1); 405 406 switch (jdir) { 407 case HORIZ_FOLLOW: 408 tsp->roff = sp->roff; 409 vs_sm_fill(tsp, OOBLNO, P_TOP); 410 break; 411 case HORIZ_PRECEDE: 412 vs_sm_fill(tsp, OOBLNO, P_BOTTOM); 413 break; 414 default: 415 abort(); 416 } 417 F_SET(tsp, SC_STATUS); 418 } 419 break; 420 case VERT_FOLLOW: 421 case VERT_PRECEDE: 422 for (lp = &list[0]; (tsp = *lp) != NULL; ++lp) { 423 if (jdir == VERT_FOLLOW) 424 tsp->coff = sp->coff; 425 tsp->cols += sp->cols + 1; /* XXX: DIVIDER */ 426 vs_sm_fill(tsp, OOBLNO, P_TOP); 427 F_SET(tsp, SC_STATUS); 428 } 429 break; 430 default: 431 abort(); 432 } 433 434 /* Find the closest screen that changed and move to it. */ 435 tsp = list[0]; 436 if (spp != NULL) 437 *spp = tsp; 438 439 /* Tell the display that we're discarding a screen. */ 440 (void)gp->scr_discard(sp, list); 441 442 return (0); 443 } 444 445 /* 446 * vs_join -- 447 * Find a set of screens that covers a screen's border. 448 */ 449 static int vs_join(SCR * sp,SCR ** listp,jdir_t * jdirp)450 vs_join(SCR *sp, SCR **listp, jdir_t *jdirp) 451 { 452 GS *gp; 453 SCR **lp, *tsp; 454 int first; 455 size_t tlen; 456 457 gp = sp->gp; 458 459 /* Check preceding vertical. */ 460 for (lp = listp, tlen = sp->rows, 461 tsp = TAILQ_FIRST(gp->dq); 462 tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) { 463 if (sp == tsp) 464 continue; 465 /* Test if precedes the screen vertically. */ 466 if (tsp->coff + tsp->cols + 1 != sp->coff) 467 continue; 468 /* 469 * Test if a subset on the vertical axis. If overlaps the 470 * beginning or end, we can't join on this axis at all. 471 */ 472 if (tsp->roff > sp->roff + sp->rows) 473 continue; 474 if (tsp->roff < sp->roff) { 475 if (tsp->roff + tsp->rows >= sp->roff) 476 break; 477 continue; 478 } 479 if (tsp->roff + tsp->rows > sp->roff + sp->rows) 480 break; 481 #ifdef DEBUG 482 if (tlen < tsp->rows) 483 abort(); 484 #endif 485 tlen -= tsp->rows; 486 *lp++ = tsp; 487 } 488 if (tlen == 0) { 489 *lp = NULL; 490 *jdirp = VERT_PRECEDE; 491 return (0); 492 } 493 494 /* Check following vertical. */ 495 for (lp = listp, tlen = sp->rows, 496 tsp = TAILQ_FIRST(gp->dq); 497 tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) { 498 if (sp == tsp) 499 continue; 500 /* Test if follows the screen vertically. */ 501 if (tsp->coff != sp->coff + sp->cols + 1) 502 continue; 503 /* 504 * Test if a subset on the vertical axis. If overlaps the 505 * beginning or end, we can't join on this axis at all. 506 */ 507 if (tsp->roff > sp->roff + sp->rows) 508 continue; 509 if (tsp->roff < sp->roff) { 510 if (tsp->roff + tsp->rows >= sp->roff) 511 break; 512 continue; 513 } 514 if (tsp->roff + tsp->rows > sp->roff + sp->rows) 515 break; 516 #ifdef DEBUG 517 if (tlen < tsp->rows) 518 abort(); 519 #endif 520 tlen -= tsp->rows; 521 *lp++ = tsp; 522 } 523 if (tlen == 0) { 524 *lp = NULL; 525 *jdirp = VERT_FOLLOW; 526 return (0); 527 } 528 529 /* Check preceding horizontal. */ 530 for (first = 0, lp = listp, tlen = sp->cols, 531 tsp = TAILQ_FIRST(gp->dq); 532 tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) { 533 if (sp == tsp) 534 continue; 535 /* Test if precedes the screen horizontally. */ 536 if (tsp->roff + tsp->rows != sp->roff) 537 continue; 538 /* 539 * Test if a subset on the horizontal axis. If overlaps the 540 * beginning or end, we can't join on this axis at all. 541 */ 542 if (tsp->coff > sp->coff + sp->cols) 543 continue; 544 if (tsp->coff < sp->coff) { 545 if (tsp->coff + tsp->cols >= sp->coff) 546 break; 547 continue; 548 } 549 if (tsp->coff + tsp->cols > sp->coff + sp->cols) 550 break; 551 #ifdef DEBUG 552 if (tlen < tsp->cols) 553 abort(); 554 #endif 555 tlen -= tsp->cols + first; 556 first = 1; 557 *lp++ = tsp; 558 } 559 if (tlen == 0) { 560 *lp = NULL; 561 *jdirp = HORIZ_PRECEDE; 562 return (0); 563 } 564 565 /* Check following horizontal. */ 566 for (first = 0, lp = listp, tlen = sp->cols, 567 tsp = TAILQ_FIRST(gp->dq); 568 tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) { 569 if (sp == tsp) 570 continue; 571 /* Test if precedes the screen horizontally. */ 572 if (tsp->roff != sp->roff + sp->rows) 573 continue; 574 /* 575 * Test if a subset on the horizontal axis. If overlaps the 576 * beginning or end, we can't join on this axis at all. 577 */ 578 if (tsp->coff > sp->coff + sp->cols) 579 continue; 580 if (tsp->coff < sp->coff) { 581 if (tsp->coff + tsp->cols >= sp->coff) 582 break; 583 continue; 584 } 585 if (tsp->coff + tsp->cols > sp->coff + sp->cols) 586 break; 587 #ifdef DEBUG 588 if (tlen < tsp->cols) 589 abort(); 590 #endif 591 tlen -= tsp->cols + first; 592 first = 1; 593 *lp++ = tsp; 594 } 595 if (tlen == 0) { 596 *lp = NULL; 597 *jdirp = HORIZ_FOLLOW; 598 return (0); 599 } 600 return (1); 601 } 602 603 /* 604 * vs_fg -- 605 * Background the current screen, and foreground a new one. 606 * 607 * PUBLIC: int vs_fg(SCR *, SCR **, CHAR_T *, int); 608 */ 609 int vs_fg(SCR * sp,SCR ** nspp,CHAR_T * name,int newscreen)610 vs_fg(SCR *sp, SCR **nspp, CHAR_T *name, int newscreen) 611 { 612 GS *gp; 613 SCR *nsp; 614 char *np; 615 size_t nlen; 616 617 gp = sp->gp; 618 619 if (name) 620 INT2CHAR(sp, name, STRLEN(name) + 1, np, nlen); 621 else 622 np = NULL; 623 if (newscreen) 624 /* Get the specified background screen. */ 625 nsp = vs_getbg(sp, np); 626 else 627 /* Swap screens. */ 628 if (vs_swap(sp, &nsp, np)) 629 return (1); 630 631 if ((*nspp = nsp) == NULL) { 632 msgq_wstr(sp, M_ERR, name, 633 name == NULL ? 634 "223|There are no background screens" : 635 "224|There's no background screen editing a file named %s"); 636 return (1); 637 } 638 639 if (newscreen) { 640 /* Remove the new screen from the background queue. */ 641 TAILQ_REMOVE(gp->hq, nsp, q); 642 643 /* Split the screen; if we fail, hook the screen back in. */ 644 if (vs_split(sp, nsp, 0)) { 645 TAILQ_INSERT_TAIL(gp->hq, nsp, q); 646 return (1); 647 } 648 } else { 649 /* Move the old screen to the background queue. */ 650 TAILQ_REMOVE(gp->dq, sp, q); 651 TAILQ_INSERT_TAIL(gp->hq, sp, q); 652 } 653 return (0); 654 } 655 656 /* 657 * vs_bg -- 658 * Background the screen, and switch to the next one. 659 * 660 * PUBLIC: int vs_bg(SCR *); 661 */ 662 int vs_bg(SCR * sp)663 vs_bg(SCR *sp) 664 { 665 GS *gp; 666 SCR *nsp; 667 668 gp = sp->gp; 669 670 /* Try and join with another screen. */ 671 if (vs_discard(sp, &nsp)) 672 return (1); 673 if (nsp == NULL) { 674 msgq(sp, M_ERR, 675 "225|You may not background your only displayed screen"); 676 return (1); 677 } 678 679 /* Move the old screen to the background queue. */ 680 TAILQ_REMOVE(gp->dq, sp, q); 681 TAILQ_INSERT_TAIL(gp->hq, sp, q); 682 683 /* Toss the screen map. */ 684 free(_HMAP(sp)); 685 _HMAP(sp) = NULL; 686 687 /* Switch screens. */ 688 sp->nextdisp = nsp; 689 F_SET(sp, SC_SSWITCH); 690 691 return (0); 692 } 693 694 /* 695 * vs_swap -- 696 * Swap the current screen with a backgrounded one. 697 * 698 * PUBLIC: int vs_swap(SCR *, SCR **, char *); 699 */ 700 int vs_swap(SCR * sp,SCR ** nspp,char * name)701 vs_swap(SCR *sp, SCR **nspp, char *name) 702 { 703 GS *gp; 704 SCR *nsp, *list[2]; 705 706 gp = sp->gp; 707 708 /* Get the specified background screen. */ 709 if ((*nspp = nsp = vs_getbg(sp, name)) == NULL) 710 return (0); 711 712 /* 713 * Save the old screen's cursor information. 714 * 715 * XXX 716 * If called after file_end(), and the underlying file was a tmp 717 * file, it may have gone away. 718 */ 719 if (sp->frp != NULL) { 720 sp->frp->lno = sp->lno; 721 sp->frp->cno = sp->cno; 722 F_SET(sp->frp, FR_CURSORSET); 723 } 724 725 /* Switch screens. */ 726 sp->nextdisp = nsp; 727 F_SET(sp, SC_SSWITCH); 728 729 /* Initialize terminal information. */ 730 VIP(nsp)->srows = VIP(sp)->srows; 731 732 /* Initialize screen information. */ 733 nsp->cols = sp->cols; 734 nsp->rows = sp->rows; /* XXX: Only place in vi that sets rows. */ 735 nsp->roff = sp->roff; 736 737 /* 738 * Small screens: see vs_refresh.c, section 6a. 739 * 740 * The new screens may have different screen options sizes than the 741 * old one, so use them. Make sure that text counts aren't larger 742 * than the new screen sizes. 743 */ 744 if (IS_SMALL(nsp)) { 745 nsp->t_minrows = nsp->t_rows = O_VAL(nsp, O_WINDOW); 746 if (nsp->t_rows > sp->t_maxrows) 747 nsp->t_rows = nsp->t_maxrows; 748 if (nsp->t_minrows > sp->t_maxrows) 749 nsp->t_minrows = nsp->t_maxrows; 750 } else 751 nsp->t_rows = nsp->t_maxrows = nsp->t_minrows = nsp->rows - 1; 752 753 /* Reset the length of the default scroll. */ 754 nsp->defscroll = nsp->t_maxrows / 2; 755 756 /* Allocate a new screen map. */ 757 CALLOC_RET(nsp, _HMAP(nsp), SIZE_HMAP(nsp), sizeof(SMAP)); 758 _TMAP(nsp) = _HMAP(nsp) + (nsp->t_rows - 1); 759 760 /* Fill the map. */ 761 nsp->gp = sp->gp; 762 if (vs_sm_fill(nsp, nsp->lno, P_FILL)) 763 return (1); 764 765 /* 766 * The new screen replaces the old screen in the parent/child list. 767 * We insert the new screen after the old one. If we're exiting, 768 * the exit will delete the old one, if we're foregrounding, the fg 769 * code will move the old one to the background queue. 770 */ 771 TAILQ_REMOVE(gp->hq, nsp, q); 772 TAILQ_INSERT_AFTER(gp->dq, sp, nsp, q); 773 774 /* 775 * Don't change the screen's cursor information other than to 776 * note that the cursor is wrong. 777 */ 778 F_SET(VIP(nsp), VIP_CUR_INVALID); 779 780 /* Draw the new screen from scratch, and add a status line. */ 781 F_SET(nsp, SC_SCR_REDRAW | SC_STATUS); 782 783 list[0] = nsp; list[1] = NULL; 784 (void)gp->scr_discard(sp, list); 785 786 return (0); 787 } 788 789 /* 790 * vs_resize -- 791 * Change the absolute size of the current screen. 792 * 793 * PUBLIC: int vs_resize(SCR *, long, adj_t); 794 */ 795 int vs_resize(SCR * sp,long int count,adj_t adj)796 vs_resize(SCR *sp, long int count, adj_t adj) 797 { 798 GS *gp; 799 SCR *g, *s, *prev, *next, *list[3] = {NULL, NULL, NULL}; 800 size_t g_off, s_off; 801 802 gp = sp->gp; 803 804 /* 805 * Figure out which screens will grow, which will shrink, and 806 * make sure it's possible. 807 */ 808 if (count == 0) 809 return (0); 810 if (adj == A_SET) { 811 if (sp->t_maxrows == count) 812 return (0); 813 if (sp->t_maxrows > count) { 814 adj = A_DECREASE; 815 count = sp->t_maxrows - count; 816 } else { 817 adj = A_INCREASE; 818 count = count - sp->t_maxrows; 819 } 820 } 821 822 /* Find first overlapping screen */ 823 for (next = TAILQ_NEXT(sp, q); next != NULL && 824 (next->coff >= sp->coff + sp->cols || 825 next->coff + next->cols <= sp->coff); 826 next = TAILQ_NEXT(next, q)); 827 /* See if we can use it */ 828 if (next != NULL && 829 (sp->coff != next->coff || sp->cols != next->cols)) 830 next = NULL; 831 for (prev = TAILQ_PREV(sp, _dqh, q); prev != NULL && 832 (prev->coff >= sp->coff + sp->cols || 833 prev->coff + prev->cols <= sp->coff); 834 prev = TAILQ_PREV(prev, _dqh, q)); 835 if (prev != NULL && 836 (sp->coff != prev->coff || sp->cols != prev->cols)) 837 prev = NULL; 838 839 g_off = s_off = 0; 840 if (adj == A_DECREASE) { 841 if (count < 0) 842 count = -count; 843 s = sp; 844 if (s->t_maxrows < MINIMUM_SCREEN_ROWS + count) 845 goto toosmall; 846 if ((g = prev) == NULL) { 847 if ((g = next) == NULL) 848 goto toobig; 849 g_off = -count; 850 } else 851 s_off = count; 852 } else { 853 g = sp; 854 if ((s = next) != NULL && 855 s->t_maxrows >= MINIMUM_SCREEN_ROWS + count) 856 s_off = count; 857 else 858 s = NULL; 859 if (s == NULL) { 860 if ((s = prev) == NULL) { 861 toobig: msgq(sp, M_BERR, adj == A_DECREASE ? 862 "227|The screen cannot shrink" : 863 "228|The screen cannot grow"); 864 return (1); 865 } 866 if (s->t_maxrows < MINIMUM_SCREEN_ROWS + count) { 867 toosmall: msgq(sp, M_BERR, 868 "226|The screen can only shrink to %d rows", 869 MINIMUM_SCREEN_ROWS); 870 return (1); 871 } 872 g_off = -count; 873 } 874 } 875 876 /* 877 * Fix up the screens; we could optimize the reformatting of the 878 * screen, but this isn't likely to be a common enough operation 879 * to make it worthwhile. 880 */ 881 s->rows += -count; 882 s->roff += s_off; 883 g->rows += count; 884 g->roff += g_off; 885 886 g->t_rows += count; 887 if (g->t_minrows == g->t_maxrows) 888 g->t_minrows += count; 889 g->t_maxrows += count; 890 _TMAP(g) += count; 891 F_SET(g, SC_SCR_REFORMAT | SC_STATUS); 892 893 s->t_rows -= count; 894 s->t_maxrows -= count; 895 if (s->t_minrows > s->t_maxrows) 896 s->t_minrows = s->t_maxrows; 897 _TMAP(s) -= count; 898 F_SET(s, SC_SCR_REFORMAT | SC_STATUS); 899 900 /* XXXX */ 901 list[0] = g; list[1] = s; 902 gp->scr_discard(0, list); 903 904 return (0); 905 } 906 907 /* 908 * vs_getbg -- 909 * Get the specified background screen, or, if name is NULL, the first 910 * background screen. 911 */ 912 static SCR * vs_getbg(SCR * sp,char * name)913 vs_getbg(SCR *sp, char *name) 914 { 915 GS *gp; 916 SCR *nsp; 917 char *p; 918 919 gp = sp->gp; 920 921 /* If name is NULL, return the first background screen on the list. */ 922 if (name == NULL) 923 return (TAILQ_FIRST(gp->hq)); 924 925 /* Search for a full match. */ 926 TAILQ_FOREACH(nsp, gp->hq, q) 927 if (!strcmp(nsp->frp->name, name)) 928 break; 929 if (nsp != NULL) 930 return (nsp); 931 932 /* Search for a last-component match. */ 933 TAILQ_FOREACH(nsp, gp->hq, q) { 934 if ((p = strrchr(nsp->frp->name, '/')) == NULL) 935 p = nsp->frp->name; 936 else 937 ++p; 938 if (!strcmp(p, name)) 939 break; 940 } 941 if (nsp != NULL) 942 return (nsp); 943 944 return (NULL); 945 } 946