Attachment #162849 for bug #234687

View | Details | Raw Unified | Return to bug 234687
Collapse All | Expand All

Lines 309-314 struct comm comms[RC_LAST + 1] = Link Here

(-)old/comm.c (+1 lines)
309	{ "vbellwait", ARGS_1 },	309	{ "vbellwait", ARGS_1 },
310	{ "verbose", ARGS_01 },	310	{ "verbose", ARGS_01 },
311	{ "version", ARGS_0 },	311	{ "version", ARGS_0 },
		312	{ "vert_split", NEED_DISPLAY\|ARGS_0 },
312	{ "wall", NEED_DISPLAY\|ARGS_1},	313	{ "wall", NEED_DISPLAY\|ARGS_1},
313	{ "width", ARGS_0123 },	314	{ "width", ARGS_0123 },
314	{ "windowlist", NEED_DISPLAY\|ARGS_012 },	315	{ "windowlist", NEED_DISPLAY\|ARGS_012 },




  free(cv);
}

struct canvas *
get_new_canvas(target)
struct canvas *target;
{   /** Allocate a new canvas, and assign it characteristics
    equal to those of target. */
    struct canvas *cv;

    if ((cv = (struct canvas *) calloc(1, sizeof *cv)) == 0)
        return NULL;

    cv -> c_xs               = target -> c_xs;
    cv -> c_xe               = target -> c_xe;
    cv -> c_ys               = target -> c_ys;
    cv -> c_ye               = target -> c_ye;
    cv -> c_xoff             = target -> c_xoff;
    cv -> c_yoff             = target -> c_yoff;
    cv -> c_display          = target -> c_display;
    cv -> c_vplist           = 0;
    cv -> c_captev.type      = EV_TIMEOUT;
    cv -> c_captev.data      = (char *) cv;
    cv -> c_captev.handler   = cv_winid_fn;

    cv -> c_blank.l_cvlist   = cv;
    cv -> c_blank.l_width    = cv->c_xe - cv->c_xs + 1;
    cv -> c_blank.l_height   = cv->c_ye - cv->c_ys + 1;
    cv -> c_blank.l_x        = cv->c_blank.l_y = 0;
    cv -> c_blank.l_layfn    = &BlankLf;
    cv -> c_blank.l_data     = 0;
    cv -> c_blank.l_next     = 0;
    cv -> c_blank.l_bottom   = &cv->c_blank;
    cv -> c_blank.l_blocking = 0;
    cv -> c_layer            = &cv->c_blank;
    cv -> c_lnext            = 0;

    cv -> c_left  = target -> c_left;
    cv -> c_right = target -> c_right;
    cv -> c_above = target -> c_above;
    cv -> c_below = target -> c_below;

    return cv;
}

int
share_limits( type, cv0, cv1)
int type;       /* HORIZONTAL or VERTICAL */
struct canvas *cv0;  /* canvas to compare against. */
struct canvas *cv1;  /* canvas to compare against. */
{   /** Return non-zero if the two canvasses share limits. 
    (ie, their horizontal or veritcal boundaries are the same)
    */
    switch (type) {
    case HORIZONTAL:
        return cv0 -> c_xs == cv1 -> c_xs && cv0->c_xe == cv1 -> c_xe;
    case VERTICAL:
        return cv0 -> c_ys == cv1 -> c_ys && cv0->c_ye == cv1 -> c_ye;
    }
    ASSERT(0);
    return 0;
}

int
compute_region(type, a, focus, list)
int type;  /* 0 - horizontal, 1 - vertical */
struct screen_region *a;  /* Return value. */
struct canvas *focus;  /* Canvas to compute around. */
struct canvas *list;   /* List of all canvasses. */
{   /** Find the start and end of the screen region.*/
    /*
    I'm using the term 'region' here differently
    than elsewhere.  Elsewhere, 'region' is synonymous
    with 'canvas', but I am using it to denote
    a collection of related canvasses.

    Suppose the screen currently looks
    like this:
    ---------------------------
    |  0   |   1    |    2    |
    ---------------------------
    |  3   |   4    |    5    |
    ---------------------------
    |          6              |
    ---------------------------
    |   7  |   8    |    9    |
    ---------------------------
    Where there are 10 entries in D_cvlist.
    Canvasses 0,1,2 are in the same region, as
    are cavasses 1 and 4.  We need to be careful not to
    lump 1 and 4 together w/8.  The
    type of the region containing 0,1,2 is
    VERTICAL, since each canvas is created
    via a vertical split.

    Throughout, I'm assuming that canvasses
    are created so that any region will
    be contiguous in D_cvlist.

    Note: this was written before the screen 
    orientation members (c_left, c_above, c_below,
    c_right) were added to the struct canvas.
    Might want to rewrite this to use those.

    Written by Bill Pursell, 23/12/2005
    */

    struct canvas *cv;  /* Entry in list. */
    int seen_focus;     /* Flag used when walking the list. */

    seen_focus = 0;
    a->count = 0;
    a->type  = type;

    if (type == HORIZONTAL) {
        a->xs = focus -> c_xs;
        a->xe = focus -> c_xe;
        a->ys = -1;
    }
    if (type == VERTICAL) {
        a->ys = focus -> c_ys;
        a->ye = focus -> c_ye;
        a->xs = -1;
    }
    /* Count the canvasses in the same region as the
    canvas with the focus, and find the limits of the region. */
    for (cv = list; cv; cv = cv->c_next) {
        if (cv == focus)
            seen_focus = 1;
        if (share_limits( type, cv, focus)) {
            debug2("cv = %x  %s\n", cv, (cv == focus)? "FORE":"");
            debug2("x range: %d - %d\n", cv->c_xs, cv->c_xe);
            debug2("y range: %d - %d\n", cv->c_ys, cv->c_ye);
            switch (type) {
            case HORIZONTAL  : 
                if (a->ys == -1) {
                    a->ys = cv -> c_ys; 
                    a->start = cv;
                }
                a->ye = cv -> c_ye;
      break;
            case VERTICAL:
                if (a->xs == -1) {
                    a->xs = cv -> c_xs; 
                    a->start = cv;
                }
                a->xe = cv -> c_xe;
                break;
            }

            a->end = cv;
            a->count++;
        }
        if (!share_limits(type, cv, focus) || cv -> c_next == NULL) {
            if (seen_focus) {
                debug2("x range of Region: %d-%d\n", a->xs, a->xe);
                debug2("y range of Region: %d-%d\n", a->ys, a->ye);
                break;
            }
            else {
                switch(type) {
                case HORIZONTAL: a->ys = -1; break;
                case VERTICAL  : a->xs = -1; break;
                }
                a->count = 0;
            }
        }
    }

    switch (type) {
    case HORIZONTAL: 
        a->expanse  = a->ye - a->ys + 1;  
        ASSERT(a->expanse <=  D_height - (D_has_hstatus == HSTATUS_LASTLINE));
        break;
    case VERTICAL:   
        a->expanse  = a->xe - a->xs + 1;  
        ASSERT(a->expanse <=  D_width);
        break;
    }
    ASSERT(seen_focus);
}

void
reset_region_types(region, type)
struct screen_region *region;
int type;
{   /** Set c_type of all the canvasses in the region to type. */
  cv->c_blank.l_data = 0;
  cv->c_blank.l_next = 0;
  cv->c_blank.l_bottom = &cv->c_blank;
  cv->c_blank.l_blocking = 0;
  cv->c_layer = &cv->c_blank;
  cv->c_lnext = 0;

    struct canvas *cv;
  *cvpp = cv;

    for (cv = region->start; cv != region->end->c_next; cv = cv->c_next) {
        #ifdef DEBUG
        switch(type) {
        case HORIZONTAL: 
            ASSERT (cv->c_xs == region -> xs && cv->c_xe == region -> xe);
            break;
        case VERTICAL:
            ASSERT (cv->c_ys == region -> ys && cv->c_ye == region -> ye);
            break;
        default:
            ASSERT(0);
    }
        #endif
        cv -> c_type = type;
    }
}

void
debug_print_canvas(cv)
struct canvas *cv;
{   /** Print cv to the debug file. */
#ifdef DEBUG
    debug2("%x %s\n", cv, (cv == D_forecv)?"  HAS FOCUS":"");
    debug2("    above: %x    below: %x\n", cv->c_above, cv->c_below);
    debug2("    left: %x     right: %x\n", cv->c_left,  cv->c_right);
    debug3("    x range: %2d-%2d, xoff = %d\n", 
        cv->c_xs, cv->c_xe, cv->c_xoff);
    debug3("    y range: %2d-%2d yoff = %d\n", 
        cv->c_ys, cv->c_ye, cv->c_yoff);
    debug2("    next: %x   type: %d\n", cv->c_next, cv->c_type);
#endif
}

void
debug_print_all_canvasses(header)
char *header;
{   /** Print the dimensions of all the canvasses
    in the current display to the debug file.  Precede
    with a line containing the header message. */
    #ifdef DEBUG
    struct canvas *cv;
    char message[BUFSIZ];

    sprintf(message,  "%10s %5d: ",__FILE__ , __LINE__);
    strcat (message, header);
    fprintf(dfp, message);
    fflush(dfp);
    for (cv = D_cvlist; cv; cv = cv->c_next) {
        debug_print_canvas(cv);
    }
    #endif
    return;
}

set_internal_orientation(region)
struct screen_region *region;
{   /** Set the orientation for canvasses inside the region. */

    struct canvas *cv;

    for (cv = region -> start; cv != region -> end; cv = cv->c_next) {
        ASSERT (cv -> c_type == region -> type);
        switch (region->type) {
        case VERTICAL:
            cv -> c_right           = cv -> c_next;
            cv -> c_next -> c_left  = cv;
            break;
        case HORIZONTAL:
            cv -> c_below           = cv -> c_next;
            cv -> c_next -> c_above = cv;
            break;
        }
    }
}


int
AddCanvas(type)
int type;  /* Horizontal or Vertical. */
{   /** Add a new canvas, via a split. */

    struct canvas  *cv;        /* Index into D_cvlist. */
    struct screen_region  vr;  /* Canvasses in the same row/column as the 
                                  canvas with the focus.   */

    compute_region(type, &vr, D_forecv, D_cvlist);

    /* Return if the region isn't big enough to split. */
    if (vr.expanse / vr.count <= 1)
        return -1; 

    /* Allocate a new canvas. */
    if ( (cv = get_new_canvas(D_forecv)) == NULL)
        return -1;

    /* Set the type. */
    cv -> c_type = D_forecv -> c_type = type;

    /* Increment the canvas count to account for the one we will add. */
    vr.count++;

    debug_print_all_canvasses("AddCanvas start.\n");

    /* Insert the new canvas after the current foreground. */
    cv -> c_next = D_forecv->c_next;
    D_forecv -> c_next = cv;
    if (vr.end == D_forecv)
        vr.end = cv;

    set_internal_orientation(&vr);
    equalize_canvas_dimensions(&vr);

    debug_print_all_canvasses("AddCanvas end.\n");

  RethinkDisplayViewports();
  ResizeLayersToCanvases();

}

void
get_endpoints(cv, start, end, off)
struct canvas *cv;
int **start;
int **end;
int **off;
{   /** Set *start, *end, and *off appropriate with cv->c_type. */
    switch (cv->c_type) {
    case HORIZONTAL:
        if (start) *start = &cv -> c_ys;
        if (end)   *end   = &cv -> c_ye;
        if (off)   *off   = &cv -> c_yoff;
        break;
    case VERTICAL:
        if (start) *start = &cv -> c_xs;
        if (end)   *end   = &cv -> c_xe;
        if (off)   *off   = &cv -> c_xoff;
        break;
    default: ASSERT(0);
    }
}

#define MIN_HEIGHT 1
#define MIN_WIDTH 5

int
adjust_canvas_dimensions(vr, target, amount)
struct screen_region *vr;
struct canvas *target;
int amount;
{   /** Modify the size of target by amount. */
    
    /* Other canvasses in the region will gain or lose
    space to accomodate the change.  Return
    the number of rows/columns by which the size 
    of target is succesfully enlarged. (if amount <= 0,
    return 0) */

    struct canvas *this;    /* for walking the list. */
    struct canvas *prev;    /* for walking the list backwards. */
    int adjusted;           /* Amount already re-allocated. */
    int *start, *end, *off; /* c->c_{x,y}s, c->c_{x,y}e, and c->c_{x,y}off */
    int minimum, space;

    debug1("adjust: amount = %d\n", amount);
    debug_print_all_canvasses("ADJUST \n");

    ASSERT(vr->count > 1);

    if (amount == 0)
        return 0;

    switch(vr->type) {
    case HORIZONTAL:  minimum = MIN_HEIGHT; space = 2; break;
    case VERTICAL:    minimum = MIN_WIDTH; space = 1; break;
    default: ASSERT(0);
    }

    if (amount < 0) {
        debug_print_all_canvasses("PREADJUST\n");

        get_endpoints(target, &start, &end, &off);
        if (target == vr -> start) {
            *end += amount;

            if (*end < *start + minimum)
                *end = *start + minimum;

            get_endpoints(target->c_next, &start, 0, &off);
            *start = *off = *end + space;

        debug_print_all_canvasses("POSTADJUST\n\n");
        }
        else {
            for (prev = vr->start; prev->c_next != target; prev = prev->c_next)
                ;
            ASSERT(prev && prev -> c_next == target);

            *start -= amount;
            if (*start > *end - minimum)
                *start = *end - minimum;
            get_endpoints(prev, 0, &end, 0);
            *end = *start - space;
        }
        return 0;
    }

    ASSERT (amount > 0);

    /* Reallocate space from canvasses below target. */
    this = vr -> end;
    adjusted = 0;
    while ( adjusted < amount) {
        int this_amount;   /* amount this canvas can yield. */
        struct canvas *cv; /* For walking lists. */

        if (this == target)
            break;

        get_endpoints(this, &start, &end, 0);
        switch (vr->type) {
        case HORIZONTAL: this_amount = *end - *start - MIN_HEIGHT; break;
        case VERTICAL:   this_amount = *end - *start - MIN_WIDTH;  break;
        default: ASSERT(0);
        }

        if (this_amount > amount - adjusted)
            this_amount = amount - adjusted;

        debug("target:\n");
        debug_print_canvas(target);

        debug("this:\n");
        debug_print_canvas(this);

        /* Move all canvasses between target and this by this_amount. */
        for (cv = target; cv != this; cv = cv -> c_next) {
            debug1("this_amount = %d\n", this_amount);
            debug_print_canvas(cv);

            get_endpoints(cv, &start, &end, 0);
            *end += this_amount;
            get_endpoints(cv->c_next, &start, &end, &off);
            *start += this_amount;
            *off = *start;
        }
        adjusted += this_amount;
        debug1("adjusted: %d\n", adjusted);

        debug("target:\n");
        debug_print_canvas(target);

        debug("this:\n");
        debug_print_canvas(this);


        /* Get the previous canvas.  TODO: include back pointers
        in struct canvas(?). */
        for (prev = vr->start; prev->c_next != this; prev = prev->c_next)
            ASSERT(prev);
        this = prev;
    }
    debug1("adjusted = %d\n", adjusted);
    if (adjusted == amount || target == vr->start)
        return adjusted;

    /* Re-allocate space from canvasses above target. */
    ASSERT(this == target);
    for (prev = vr->start; prev->c_next != this; prev = prev->c_next)
        ASSERT(prev);
    this = prev;

    while (adjusted < amount) {
        int this_amount;   /* amount this canvas can yield. */
        struct canvas *cv; /* For walking lists. */

        get_endpoints(this, &start, &end, 0);
        switch (vr->type) {
        case HORIZONTAL: this_amount = *end - *start - MIN_HEIGHT; break;
        case VERTICAL:   this_amount = *end - *start - MIN_WIDTH;  break;
        default: ASSERT(0);
        }

        if (this_amount > amount - adjusted)
            this_amount = amount - adjusted;

        /* Move all canvasses between this and target by this_amount. */
        for (cv = this; cv != target; cv = cv -> c_next) {
            ASSERT(cv);
            debug1("this_amount = %d\n", this_amount);
            debug_print_canvas(cv);
            debug("NEXT:\n");
            debug_print_canvas(cv->c_next);

            debug("getend:\n");
            get_endpoints(cv, &start, &end, 0);
            ASSERT(end && start );
            ASSERT(start);
            ASSERT(*end >= this_amount);
            *end -= this_amount;
            ASSERT(*end > *start);

            debug("getend:\n");
            ASSERT(cv->c_next);
            get_endpoints(cv->c_next, &start, &end, &off);
            ASSERT(start && off);
            ASSERT(*start >= this_amount);
            ASSERT(*start == *off);
            *start -= this_amount;
            *off = *start;

            debug("adjusted\n");
            debug_print_canvas(cv);
            debug("NEXT:\n");
            debug_print_canvas(cv->c_next);
            debug("\n");
        }
        adjusted += this_amount;

        if (this == vr->start)
            break;

        for (prev = vr->start; prev->c_next != this; prev = prev->c_next)
            ASSERT(prev);
        this = prev;
    }
    debug1("returning: %d\n", adjusted);
    return adjusted;
}

void
equalize_canvas_dimensions(vr)
struct screen_region *vr;
{   /** Reset the size of each canvas in the region. */

    struct canvas *cv;  /* for walking the list. */
    int this_size; /* new size of cv */
    int this_start;  /* Start coordinate for current canvas. */

    debug("equalize\n");

    debug2("vr start = %#x, vr end = %#x\n", vr->start, vr->end);

    switch(vr->type) {
    case VERTICAL:   this_start = vr->xs; break;
    case HORIZONTAL: this_start = vr->ys; break;
    }

    for (cv = vr->start ; ; cv = cv->c_next) {
        ASSERT(cv);

        /* For the horizontal split, leave space for a status line. */
        this_size = vr->expanse / vr->count - (vr->type == HORIZONTAL);

        /* Give any additional available rows/columns to the foreground. */
        if (cv == D_forecv)
            this_size += vr->expanse % vr->count;

        debug_print_canvas(cv);
        debug2("cv type = %d, vr type = %d\n", cv->c_type, vr->type);
        ASSERT(cv -> c_type == vr->type);

        switch(vr->type) {
        case VERTICAL:
            cv -> c_xs = cv -> c_xoff = this_start;
            cv -> c_xe = this_start + this_size - 1;
            this_start += this_size;
            break;
        case HORIZONTAL:
            if (cv == vr->end && cv->c_ye == D_height-1-
                (D_has_hstatus == HSTATUS_LASTLINE))
                this_size += 1;  /* Don't make space for status line 
                    in the bottom region (it already has one). */

            cv -> c_ys = cv -> c_yoff = this_start;
            cv -> c_ye = this_start + this_size - 1;
            this_start += this_size + 1;  /* add one for status line. */
            break;
        }
        if (cv == vr->end)
            break;
    }
}

void
remove_canvas_from_list(list, cv)
struct canvas **list;
struct canvas *cv;
{   /** Prune cv from the list.  Does not free cv.*/

    struct canvas *pred;  /* Predecssor of cv in list. */

    if (cv == *list ) {
        *list = cv -> c_next;
    }
    else {
        /* Find the predecessor of cv. */
        for (pred = *list; pred->c_next != cv; pred = pred->c_next)
            ASSERT(pred);

        pred -> c_next = cv -> c_next;
    }
}

void
redirect_pointers(list, old, new)
struct canvas *list;
struct canvas *old;
struct canvas *new;
{  /** For each canvas in the list, change any
    of its screen orientation pointers from old to new. 
    Canvasses are not allowed to be self-referential,
    so set such pointers to NULL.
    */
    struct canvas *cv;
    for (cv=list; cv; cv = cv->c_next) {
        if (cv -> c_left == old)
            cv -> c_left = (cv==new)?NULL:new;
        if (cv -> c_above == old)
            cv -> c_above = (cv==new)?NULL:new;
        if (cv -> c_right == old)
            cv -> c_right = (cv==new)?NULL:new;
        if (cv -> c_below == old)
            cv -> c_below = (cv==new)?NULL:new;
    }
}

struct canvas *
squeeze(list, target, direction, distance)
struct canvas *list;    /* List of canvasses to resize. */
struct canvas *target;  /* Canvas in the list being removed. */
enum directions direction;          
int  distance;  /* Amount to squeeze. */
{   /** Resize canvasses in the list so that target 
    is shrunk by distance and other canvasses are grown in the 
    specified direction.  If distance is 0, target
    is destroyed, and the value returned is
    the earliest canvas in the list that is grown.

    If distance > 0, the value returned is an int,
    giving the amount actually sqeezed.  (This needs
    re-writing!)
    (This becomes the new region head for the region
    orphaned by target.)

    TODO: this currently only implements distance == 0;
    */

    struct canvas *ret;  /* The return value.*/
    struct canvas *cv;   /* For walking the list.*/

    ret = NULL;

    if (distance == 0) {
        for (cv = list; cv; cv = cv->c_next) {
            int *cv_coord, *cv_off, targ_coord; 
            struct canvas **cv_orient, *targ_orient;

            switch (direction) {
            case RIGHT:
                cv_orient   = &cv->c_right;
                cv_coord    = &cv->c_xe;
                cv_off      = 0;
                targ_coord  = target->c_xe;
                targ_orient = target->c_right;
                break;
            case LEFT:
                cv_orient   = &cv->c_left;
                cv_coord    = &cv->c_xs;
                cv_off      = &cv->c_xoff;
                targ_coord  = target->c_xs;
                targ_orient = target->c_left;
                break;
            case UP:
                cv_orient   = &cv->c_above;
                cv_coord    = &cv->c_ys;
                cv_off      = &cv->c_yoff;
                targ_coord  = target->c_ys;
                targ_orient = target->c_above;
                break;
            case DOWN:
                cv_orient   = &cv->c_below;
                cv_coord    = &cv->c_ye;
                cv_off      = 0;
                targ_coord  = target->c_ye;
                targ_orient = target->c_below;
                break;
            }
            if (*cv_orient == target) {
                *cv_coord = targ_coord;
                if(cv_off)
                    *cv_off = targ_coord;
                *cv_orient = targ_orient;
                ret = (ret) ? ret : cv;
            }
        }
    }
    else {
        ASSERT(distance > 0);
        switch (direction) {
        /* adjust target first. */
        case RIGHT:
            if (target->c_xe - target->c_xs + distance < MIN_WIDTH)
                distance = target->c_xe - target->c_xs - MIN_WIDTH;
            target->c_xs += distance;
            target->c_xoff = target -> c_xs;
            break;
        case LEFT:
            if (target->c_xe - target->c_xs + distance < MIN_WIDTH)
                distance = target->c_xe - target->c_xs - MIN_WIDTH;
            target->c_xe -= distance;
            break;
        case UP:
            if (target->c_ye - target->c_ys + distance < MIN_HEIGHT)
                distance = target->c_ye - target->c_ys - MIN_HEIGHT;
            target->c_ye -= distance;
            break;
        case DOWN:
            if (target->c_ye - target->c_ys + distance < MIN_HEIGHT)
                distance = target->c_ye - target->c_ys - MIN_HEIGHT;
            target->c_ys += distance;
            target->c_yoff = target -> c_ys;
            break;
        }
        for (cv = list; cv; cv = cv->c_next) {
            int *cv_coord, *cv_off, new_coord; 
            struct canvas **cv_orient;

            debug("SQUEEZE\n");
            debug_print_canvas(cv);

            if (cv == target)
                continue;

            switch (direction) {
            case RIGHT:
                cv_orient   = &cv->c_right;
                cv_coord    = &cv->c_xe;
                cv_off      = 0;
                new_coord   = cv->c_xe + distance;
                break;
            case LEFT:
                cv_orient   = &cv->c_left;
                cv_coord    = &cv->c_xs;
                cv_off      = &cv->c_xoff;
                new_coord   = cv->c_xs - distance;
                break;
            case UP:
                cv_orient   = &cv->c_above;
                cv_coord    = &cv->c_ys;
                cv_off      = &cv->c_yoff;
                new_coord   = cv->c_ys - distance;
                break;
            case DOWN:
                cv_orient   = &cv->c_below;
                cv_coord    = &cv->c_ye;
                cv_off      = 0;
                new_coord   = cv->c_ye + distance;
                break;
            }
            if (*cv_orient == target) {
                *cv_coord = new_coord;
                if(cv_off)
                    *cv_off = new_coord;
            }
        }
        ret = (struct canvas *) distance;
    }


    debug2("squeeze: target = %#x, ret = %#x\n", target, ret);
    return ret;
}


struct canvas *
grow_surrounding_regions(list, fore, amount)
    struct canvas *list;
    struct canvas *fore;
    int amount;
{
    /* Grow all the regions in the list that border
    fore appropriately.  */
    struct canvas *cv;        /* For walking the list. */
    struct canvas *new_fore;  /* Replacement for fore. */

    debug("grow_surrounding_regions\n");

    new_fore = NULL;
    if (amount == 0) {
        if (fore != list) {
            /* Grow the regions from above (the left). */
            switch (fore -> c_type) {
            case HORIZONTAL: 
                if ( !(new_fore = squeeze(list, fore, DOWN, 0))) 
                    new_fore = squeeze(list, fore, RIGHT, 0);
                break;
            case VERTICAL:   
                if ( !(new_fore = squeeze(list, fore, RIGHT, 0)))
                    new_fore = squeeze(list, fore, DOWN, 0);
	  D_forecv = cv ? cv : D_cvlist;
	  D_fore = Layer2Window(D_forecv->c_layer);
	  flayer = D_forecv->c_layer;
	  if (cv == 0)
	    break;
	  did = 1;
	}
      hh = h / j-- - 1;
      if (!captionalways && i == 0 && j == 0)
	hh++;
      cv->c_ys = i;
      cv->c_ye = i + hh - 1;
      cv->c_yoff = i;
      i += hh + 1;
      h -= hh + 1;
    }
        else {  /* Grow the regions from below (the right). */
            switch (fore -> c_type) {
            case HORIZONTAL: 
                if ( !(new_fore = squeeze(list, fore, UP, 0)))
                    new_fore = squeeze(list, fore, LEFT, 0); 
                break;
            case VERTICAL:   
                if ( !(new_fore = squeeze(list, fore, LEFT, 0)))
                    new_fore = squeeze(list, fore, UP, 0);
	    break;
	}
    }
        ASSERT (new_fore);
        return new_fore;
    }
}


void
RemCanvas()
{   /** Remove the foreground canvas. */

    struct screen_region  vr; /*Canvasses in the same row/column as D_forecv.*/
    struct canvas *new_fore;  /* Canvas which will replace D_forecv. */

    /* Do nothing if the foreground is the only canvas. */
    if (D_cvlist->c_next == NULL)
        return;

    compute_region(D_forecv->c_type, &vr, D_forecv, D_cvlist);

    debug1("RemCanvas. count = %d\n",vr.count);
    debug_print_all_canvasses("RemCanvas() start\n");

    if (vr.count > 1) {  /* Resize the neighboring canvas in region. */
        debug2("D_forecv = %x  vr.start = %x\n",D_forecv, vr.start);
        /* If there is a canvas before D_forecv, then
        grow that canvas to take up the space. */
        if (D_forecv != vr.start) {
            struct canvas *pred;  /* Predecssor of D_forecv. */
            for (pred = vr.start; pred->c_next != D_forecv; )
                pred = pred->c_next;

            new_fore         = pred;
            new_fore -> c_ye = D_forecv->c_ye;
            new_fore -> c_xe = D_forecv->c_xe;

        } 
        else {
            new_fore           = D_forecv -> c_next;
            new_fore -> c_ys   = D_forecv -> c_ys;
            new_fore -> c_xs   = D_forecv -> c_xs;
            new_fore -> c_yoff = new_fore -> c_ys;
            new_fore -> c_xoff = new_fore -> c_xs;
        }
    }
    else { /* Resize all bordering regions. */
        new_fore = grow_surrounding_regions( D_cvlist, D_forecv,0);
    }
    debug_print_canvas(new_fore);

    /* Redirect all pointers in the list. */
    redirect_pointers(D_cvlist, D_forecv, new_fore);

    remove_canvas_from_list(&D_cvlist, D_forecv);
    FreeCanvas(D_forecv);
    D_forecv = new_fore;
    D_fore   = Layer2Window(D_forecv->c_layer);
    flayer   = D_forecv->c_layer;

    debug2("RemCanvas. forecv = %#x  new_fore = %#x\n", D_forecv, new_fore);
    debug_print_all_canvasses("RemCanvas() end.\n");

  RethinkDisplayViewports();
  ResizeLayersToCanvases();
}

void
OneCanvas(list, target)
struct canvas **list;
struct canvas  *target;
{   /* Free all canvasses in the list except for
    target.  Make *list reference target. */
    struct canvas  *cv;
    struct canvas *next;

    debug_print_all_canvasses("OneCanvas start.\n");
    for (cv = *list; cv; cv = next) {
        next = cv -> c_next;
        if (cv == target) {
            cv -> c_xoff  = 0;
            cv -> c_xs    = 0;
            cv -> c_xe    = D_width-1;
            cv -> c_yoff  = 0;
            cv -> c_ys    = 0;
            cv -> c_ye    = D_height - 1 - (D_has_hstatus ==
                HSTATUS_LASTLINE) - captionalways;
            cv -> c_left  = cv->c_right = NULL;
            cv -> c_above = cv->c_below = NULL;
            cv -> c_next    = NULL;
        } else {
	  FreeCanvas(cv);
        }
    }
    *list = target;
    debug_print_all_canvasses("OneCanvas end.\n");

  RethinkDisplayViewports();
  ResizeLayersToCanvases();
}

Lines 58-63 struct canvas Link Here

(-)old/display.h (+5 lines)
58	int c_ys;	58	int c_ys;
59	int c_ye;	59	int c_ye;
60	struct event c_captev; /* caption changed event */	60	struct event c_captev; /* caption changed event */
		61	int c_type; /* which type of split created the canvas. */
		62	struct canvas c_right; / canvas to the right. */
		63	struct canvas c_left; / canvas to the left. */
		64	struct canvas c_above; / canvas above. */
		65	struct canvas c_below; / canvas below. */
61	};	66	};
62		67
63	struct viewport	68	struct viewport




#endif
extern void  SetCanvasWindow __P((struct canvas *, struct win *));
extern int   MakeDefaultCanvas __P((void));
extern int   AddCanvas __P((int));
extern void  RemCanvas __P((void));
extern void  OneCanvas __P((struct canvas **, struct canvas *));
extern int   RethinkDisplayViewports __P((void));
extern void  RethinkViewportOffsets __P((struct canvas *));
#ifdef RXVT_OSC

# endif
#endif
extern int   EncodeChar __P((char *, int, int, int *));
extern int   compute_region __P((int,struct screen_region *, struct canvas *, struct canvas *));
extern void  reset_region_types __P((struct screen_region *, int));
extern void  equalize_canvas_dimensions __P((struct screen_region *));
extern int   adjust_canvas_dimensions __P((struct screen_region *, struct canvas *, int));
enum directions {
    LEFT,
    RIGHT,
    UP,
    DOWN
};

extern struct canvas * squeeze __P(( struct canvas *, struct canvas *,
    enum directions, int  distance));

Lines 548-553 InitKeytab() Link Here

(-)old/process.c (-90 / +42 lines)
548	ktab['B'].nr = RC_POW_BREAK;	548	ktab['B'].nr = RC_POW_BREAK;
549	ktab['_'].nr = RC_SILENCE;	549	ktab['_'].nr = RC_SILENCE;
550	ktab['S'].nr = RC_SPLIT;	550	ktab['S'].nr = RC_SPLIT;
		551	ktab['V'].nr = RC_VERT_SPLIT;
551	ktab['Q'].nr = RC_ONLY;	552	ktab['Q'].nr = RC_ONLY;
552	ktab['X'].nr = RC_REMOVE;	553	ktab['X'].nr = RC_REMOVE;
553	ktab['F'].nr = RC_FIT;	554	ktab['F'].nr = RC_FIT;
Lines 3649-3655 int key; Link Here
3649	break;	3650	break;
3650	#endif /* MULTIUSER */	3651	#endif /* MULTIUSER */
3651	case RC_SPLIT:	3652	case RC_SPLIT:
3652	AddCanvas();	3653	AddCanvas(HORIZONTAL);
		3654	Activate(-1);
		3655	break;
		3656	case RC_VERT_SPLIT:
		3657	AddCanvas(VERTICAL);
3653	Activate(-1);	3658	Activate(-1);
3654	break;	3659	break;
3655	case RC_REMOVE:	3660	case RC_REMOVE:
Lines 3657-3663 int key; Link Here
3657	Activate(-1);	3662	Activate(-1);
3658	break;	3663	break;
3659	case RC_ONLY:	3664	case RC_ONLY:
3660	OneCanvas();	3665	OneCanvas(&D_cvlist, D_forecv);
3661	Activate(-1);	3666	Activate(-1);
3662	break;	3667	break;
3663	case RC_FIT:	3668	case RC_FIT:
Lines 5877-5980 static void Link Here
5877	ResizeRegions(arg)	5882	ResizeRegions(arg)
5878	char *arg;	5883	char *arg;
5879	{	5884	{
5880	struct canvas *cv;	5885	struct screen_region region; /* Region in which D_forecv resides. */
5881	int nreg, dsize, diff, siz;	5886	int adjusted;
		5887
		5888	/* Note: there's a nomenclature problem here. I'm using 'region'
		5889	to mean a set of canvasses that are related geographically
		5890	in the display. The documentation uses 'region' to refer to
		5891	a single canvas (that's the usage in the error message
		5892	below). */
5882		5893
5883	ASSERT(display);	5894	ASSERT(display);
5884	for (nreg = 0, cv = D_cvlist; cv; cv = cv->c_next)	5895	if (D_cvlist -> c_next == NULL) {
5885	nreg++;	5896	Msg(0, "More than one region required.");
5886	if (nreg < 2)
5887	{
5888	Msg(0, "resize: need more than one region");
5889	return;
5890	}
5891	dsize = D_height - (D_has_hstatus == HSTATUS_LASTLINE);
5892	if (*arg == '=')
5893	{
5894	/* make all regions the same height */
5895	int h = dsize;
5896	int hh, i = 0;
5897	for (cv = D_cvlist; cv; cv = cv->c_next)
5898	{
5899	hh = h / nreg-- - 1;
5900	cv->c_ys = i;
5901	cv->c_ye = i + hh - 1;
5902	cv->c_yoff = i;
5903	i += hh + 1;
5904	h -= hh + 1;
5905	}
5906	RethinkDisplayViewports();
5907	ResizeLayersToCanvases();
5908	return;	5897	return;
5909	}	5898	}
5910	siz = D_forecv->c_ye - D_forecv->c_ys + 1;
5911	if (*arg == '+')
5912	diff = atoi(arg + 1);
5913	else if (*arg == '-')
5914	diff = -atoi(arg + 1);
5915	else if (!strcmp(arg, "min"))
5916	diff = 1 - siz;
5917	else if (!strcmp(arg, "max"))
5918	diff = dsize - (nreg - 1) * 2 - 1 - siz;
5919	else
5920	diff = atoi(arg) - siz;
5921	if (diff == 0)
5922	return;
5923	if (siz + diff < 1)
5924	diff = 1 - siz;
5925	if (siz + diff > dsize - (nreg - 1) * 2 - 1)
5926	diff = dsize - (nreg - 1) * 2 - 1 - siz;
5927	if (diff == 0 \|\| siz + diff < 1)
5928	return;
5929		5899
5930	if (diff < 0)	5900	compute_region(D_forecv->c_type, &region, D_forecv, D_cvlist);
5931	{	5901	reset_region_types(&region, D_forecv->c_type);
5932	if (D_forecv->c_next)	5902
5933	{	5903	if (region.count > 1) {
5934	D_forecv->c_ye += diff;	5904	switch (*arg) {
5935	D_forecv->c_next->c_ys += diff;	5905	case '=': equalize_canvas_dimensions(&region); break;
5936	D_forecv->c_next->c_yoff += diff;	5906	case '-': adjust_canvas_dimensions(&region, D_forecv, -atoi(arg+1)); break;
5937	}	5907	case '+':
5938	else	5908	adjusted = adjust_canvas_dimensions(&region, D_forecv, atoi(arg+1));
5939	{
5940	for (cv = D_cvlist; cv; cv = cv->c_next)
5941	if (cv->c_next == D_forecv)
5942	break;	5909	break;
5943	ASSERT(cv);	5910	case 'm':
5944	cv->c_ye -= diff;	5911	if (!strcmp(arg, "min"))
5945	D_forecv->c_ys -= diff;	5912	adjust_canvas_dimensions(&region, D_forecv, -region.expanse);
5946	D_forecv->c_yoff -= diff;	5913	else if (!strcmp(arg, "max"))
5947	}	5914	adjust_canvas_dimensions(&region, D_forecv, region.expanse);
5948	}	5915	break;
5949	else	5916	default:
5950	{	5917	Msg(0, "resize: arguments munged");
5951	int s, i = 0, found = 0, di = diff, d2;
5952	s = dsize - (nreg - 1) * 2 - 1 - siz;
5953	for (cv = D_cvlist; cv; i = cv->c_ye + 2, cv = cv->c_next)
5954	{
5955	if (cv == D_forecv)
5956	{
5957	cv->c_ye = i + (cv->c_ye - cv->c_ys) + diff;
5958	cv->c_yoff -= cv->c_ys - i;
5959	cv->c_ys = i;
5960	found = 1;
5961	continue;
5962	}	5918	}
5963	s -= cv->c_ye - cv->c_ys;
5964	if (!found)
5965	{
5966	if (s >= di)
5967	continue;
5968	d2 = di - s;
5969	}	5919	}
5970	else	5920	else {
5971	d2 = di > cv->c_ye - cv->c_ys ? cv->c_ye - cv->c_ys : di;	5921	/TODO Need to expand this canvas into surrounding regions.../
5972	di -= d2;	5922	switch(*arg) {
5973	cv->c_ye = i + (cv->c_ye - cv->c_ys) - d2;	5923	case '=': Msg(0, "More than one region required."); return;
5974	cv->c_yoff -= cv->c_ys - i;	5924	// http://lists.gnu.org/archive/html/screen-users/2006-06/msg00012.html
5975	cv->c_ys = i;	5925	// case '-': squeeze(D_cvlist, D_forecv, RIGHT, atoi(arg+1)); break;
		5926	default : Msg(0, "More than one region required."); return;
5976	}	5927	}
5977	}	5928	}
		5929
5978	RethinkDisplayViewports();	5930	RethinkDisplayViewports();
5979	ResizeLayersToCanvases();	5931	ResizeLayersToCanvases();
5980	}	5932	}




  int sym;	/* symbol defined in ttydev.h */
};

struct screen_region {
    /* This is a group of canvasses that are all in 
    the same column or row. */
    struct canvas *start;   /* First canvas in the region. */
    struct canvas *end;     /* Last canvas in the region. */
    int            expanse; /* Range in the appropriate direction. */
    int            count;   /* Number of canvasses in the region. */
    int            type;    /* HORIZONTAL or VERTICAL. */
    int            xs;      /* starting x coordinate */
    int            xe;      /* ending   x coordinate */
    int            ys;      /* starting y coordinate */
    int            ye;      /* ending   y coordinate */
};

/*
 * windowlist orders
 */
#define WLIST_NUM 0
#define WLIST_MRU 1

#define HORIZONTAL 0
#define VERTICAL 1

Return to bug 234687

Lines 289-297 extern void NukePending __P((void)); Link Here

(-)old/extern.h (-2 / +15 lines)
289	#endif	289	#endif
290	extern void SetCanvasWindow __P((struct canvas , struct win ));	290	extern void SetCanvasWindow __P((struct canvas , struct win ));
291	extern int MakeDefaultCanvas __P((void));	291	extern int MakeDefaultCanvas __P((void));
292	extern int AddCanvas __P((void));	292	extern int AddCanvas __P((int));
293	extern void RemCanvas __P((void));	293	extern void RemCanvas __P((void));
294	extern void OneCanvas __P((void));	294	extern void OneCanvas __P((struct canvas *, struct canvas ));
295	extern int RethinkDisplayViewports __P((void));	295	extern int RethinkDisplayViewports __P((void));
296	extern void RethinkViewportOffsets __P((struct canvas *));	296	extern void RethinkViewportOffsets __P((struct canvas *));
297	#ifdef RXVT_OSC	297	#ifdef RXVT_OSC
Lines 490-492 extern int PrepareEncodedChar __P((int Link Here
490	# endif	490	# endif
491	#endif	491	#endif
492	extern int EncodeChar __P((char , int, int, int ));	492	extern int EncodeChar __P((char , int, int, int ));
		493	extern int compute_region __P((int,struct screen_region , struct canvas , struct canvas *));
		494	extern void reset_region_types __P((struct screen_region *, int));
		495	extern void equalize_canvas_dimensions __P((struct screen_region *));
		496	extern int adjust_canvas_dimensions __P((struct screen_region , struct canvas , int));
		497	enum directions {
		498	LEFT,
		499	RIGHT,
		500	UP,
		501	DOWN
		502	};
		503
		504	extern struct canvas * squeeze __P(( struct canvas , struct canvas ,
		505	enum directions, int distance));

Lines 288-295 struct baud_values Link Here

(-)old/screen.h (+17 lines)
288	int sym; /* symbol defined in ttydev.h */	288	int sym; /* symbol defined in ttydev.h */
289	};	289	};
290		290
		291	struct screen_region {
		292	/* This is a group of canvasses that are all in
		293	the same column or row. */
		294	struct canvas start; / First canvas in the region. */
		295	struct canvas end; / Last canvas in the region. */
		296	int expanse; /* Range in the appropriate direction. */
		297	int count; /* Number of canvasses in the region. */
		298	int type; /* HORIZONTAL or VERTICAL. */
		299	int xs; /* starting x coordinate */
		300	int xe; /* ending x coordinate */
		301	int ys; /* starting y coordinate */
		302	int ye; /* ending y coordinate */
		303	};
		304
291	/*	305	/*
292	* windowlist orders	306	* windowlist orders
293	*/	307	*/
294	#define WLIST_NUM 0	308	#define WLIST_NUM 0
295	#define WLIST_MRU 1	309	#define WLIST_MRU 1
		310
		311	#define HORIZONTAL 0
		312	#define VERTICAL 1