diff options
Diffstat (limited to 'z15.c')
| -rw-r--r-- | z15.c | 838 |
1 files changed, 838 insertions, 0 deletions
@@ -0,0 +1,838 @@ +/*@z15.c:Size Constraints:MinConstraint(), EnlargeToConstraint()@*************/ +/* */ +/* THE LOUT DOCUMENT FORMATTING SYSTEM (VERSION 3.17) */ +/* COPYRIGHT (C) 1991, 1999 Jeffrey H. Kingston */ +/* */ +/* Jeffrey H. Kingston (jeff@cs.usyd.edu.au) */ +/* Basser Department of Computer Science */ +/* The University of Sydney 2006 */ +/* AUSTRALIA */ +/* */ +/* This program is free software; you can redistribute it and/or modify */ +/* it under the terms of the GNU General Public License as published by */ +/* the Free Software Foundation; either Version 2, or (at your option) */ +/* any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place, Suite 330, Boston MA 02111-1307 USA */ +/* */ +/* FILE: z15.c */ +/* MODULE: Size Constraints */ +/* EXTERNS: MinConstraint(), EnlargeToConstraint(), */ +/* ReflectConstraint(), SemiRotateConstraint(), */ +/* RotateConstraint(), InvScaleConstraint(), Constrained(), */ +/* EchoConstraint(), DebugConstrained() */ +/* */ +/*****************************************************************************/ +#include <math.h> +#ifndef M_PI +#define M_PI 3.1415926535897931160E0 +#endif +#include "externs.h" + + +/*****************************************************************************/ +/* */ +/* MinConstraint(xc, yc) */ +/* */ +/* Replace *xc by the minimum of the two constraints *xc and *yc. */ +/* */ +/*****************************************************************************/ + +void MinConstraint(CONSTRAINT *xc, CONSTRAINT *yc) +{ bc(*xc) = find_min(bc(*xc), bc(*yc)); + bfc(*xc) = find_min(bfc(*xc), bfc(*yc)); + fc(*xc) = find_min(fc(*xc), fc(*yc)); +} /* end MinConstraint */ + + +/*****************************************************************************/ +/* */ +/* SetSizeToMaxForwardConstraint(b, f, c) */ +/* */ +/* Set *b, *f to their largest possible value within constraint *c, such */ +/* that *f is as large as possible. */ +/* */ +/*****************************************************************************/ + +void SetSizeToMaxForwardConstraint(FULL_LENGTH *b, FULL_LENGTH *f, CONSTRAINT *c) +{ + *f = find_min(bfc(*c), fc(*c)); + *b = find_min(bc(*c), bfc(*c) - *f); +} /* end EnlargeToConstraint */ + + +/*****************************************************************************/ +/* */ +/* EnlargeToConstraint(b, f, c) */ +/* */ +/* Enlarge *b,*f to its largest possible value within constraint *c. */ +/* */ +/*****************************************************************************/ + +void EnlargeToConstraint(FULL_LENGTH *b, FULL_LENGTH *f, CONSTRAINT *c) +{ + *f = find_min(bfc(*c) - *b, fc(*c)); +} /* end EnlargeToConstraint */ + + +/*****************************************************************************/ +/* */ +/* ReflectConstraint(xc, yc) */ +/* */ +/* Set xc to the constraint which is yc with its back and forward reversed. */ +/* */ +/*****************************************************************************/ + +#define ReflectConstraint(xc, yc) SetConstraint(xc, fc(yc), bfc(yc), bc(yc)) + + +/*@::ScaleToConstraint(), InvScaleConstraint(), etc@**************************/ +/* */ +/* int ScaleToConstraint(b, f, c) */ +/* */ +/* Return the scale factor needed to scale object of size b, f down so it */ +/* has a size which fits tightly into constraint c. */ +/* */ +/*****************************************************************************/ + +int ScaleToConstraint(FULL_LENGTH b, FULL_LENGTH f, CONSTRAINT *c) +{ float scale_factor; int res; + debug3(DSC, DD, "ScaleToConstraint(%s, %s, %s)", EchoLength(b), + EchoLength(f), EchoConstraint(c)); + scale_factor = 1.0; + if( b > 0 ) scale_factor = find_min(scale_factor, (float) bc(*c)/b ); + if( b + f > 0 ) scale_factor = find_min(scale_factor, (float) bfc(*c)/(b + f)); + if( f > 0 ) scale_factor = find_min(scale_factor, (float) fc(*c)/f ); + res = scale_factor * SF; + debug2(DSC, DD, "ScaleToConstraint returning %.2f (%d)", scale_factor, res); + return res; +} /* end ScaleToConstraint */ + + +/*****************************************************************************/ +/* */ +/* InvScaleConstraint(yc, sf, xc) */ +/* */ +/* Scale constraint xc to the inverse of the scale factor sf. */ +/* */ +/*****************************************************************************/ + +void InvScaleConstraint(CONSTRAINT *yc, FULL_LENGTH sf, CONSTRAINT *xc) +{ +#if DEBUG_ON + char buff[10]; +#endif + ifdebug(DSC, DD, sprintf(buff, "%.3f", (float) sf / SF)); + debug2(DSC, DD, "InvScaleConstraint(yc, %s, %s)", buff, EchoConstraint(xc)); + assert( sf > 0, "InvScaleConstraint: sf <= 0!" ); + bc(*yc) = bc(*xc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : + find_min(MAX_FULL_LENGTH, bc(*xc) * SF / sf); + bfc(*yc) = bfc(*xc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : + find_min(MAX_FULL_LENGTH, bfc(*xc)* SF / sf); + fc(*yc) = fc(*xc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : + find_min(MAX_FULL_LENGTH, fc(*xc) * SF / sf); + debug1(DSC, DD, "InvScaleConstraint returning %s", EchoConstraint(yc)); +} /* end InvScaleConstraint */ + + +/*****************************************************************************/ +/* */ +/* static SemiRotateConstraint(xc, u, v, angle, yc) */ +/* */ +/* Used by RotateConstraint to calculate one rotated constraint. */ +/* */ +/*****************************************************************************/ + +static void SemiRotateConstraint(CONSTRAINT *xc, FULL_LENGTH u, FULL_LENGTH v, +float angle, CONSTRAINT *yc) +{ float cs, sn; +#if DEBUG_ON + char buff[20]; +#endif + ifdebug(DSC, DD, sprintf(buff, "%.1f", angle * 360.0 / (2 * M_PI))); + debug4(DSC, DD, "SemiRotateConstraint(xc, %s, %s, %sd, %s", + EchoLength(u), EchoLength(v), buff, EchoConstraint(yc)); + cs = cos(angle); sn = sin(angle); + if( fabs(cs) < 1e-6 ) + SetConstraint(*xc, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); + else + SetConstraint(*xc, + find_min(MAX_FULL_LENGTH, (bc(*yc) - u * sn) / cs), + find_min(MAX_FULL_LENGTH, (bfc(*yc) - u * sn - v * sn) / cs), + find_min(MAX_FULL_LENGTH, (fc(*yc) - v * sn) / cs )); + debug1(DSC, DD, "SemiRotateConstraint returning %s", EchoConstraint(xc)); +} /* end SemiRotateConstraint */ + + +/*@::RotateConstraint()@******************************************************/ +/* */ +/* RotateConstraint(c, y, angle, hc, vc, dim) */ +/* */ +/* Take the object angle @Rotate y, which is supposed to be constrained */ +/* horizontally by hc and vertically by vc, and determine a constraint */ +/* (either horizontal or vertical, depending on dim) for y. */ +/* */ +/* The constraint returned is a trigonometric function of all these */ +/* parameters, including the present size of y in dimension 1-dim. */ +/* */ +/*****************************************************************************/ + +void RotateConstraint(CONSTRAINT *c, OBJECT y, FULL_LENGTH angle, +CONSTRAINT *hc, CONSTRAINT *vc, int dim) +{ CONSTRAINT c1, c2, c3, dc; float theta, psi; +#if DEBUG_ON + char buff[20]; +#endif + ifdebug(DSC, DD, sprintf(buff, "%.1f", (float) angle / DG )); + debug4(DSC, DD, "RotateConstraint(c, y, %sd, %s, %s, %s)", + buff, EchoConstraint(hc), EchoConstraint(vc), dimen(dim)); + + /* work out angle in radians between 0 and 2*PI */ + theta = (float) angle * 2 * M_PI / (float) (DG * 360); + while( theta < 0 ) theta += 2 * M_PI; + while( theta >= 2 * M_PI ) theta -= 2 * M_PI; + assert( 0 <= theta && theta <= 2 * M_PI, "RotateConstraint: theta!" ); + + /* determine theta, c1, and c2 depending on which quadrant we are in */ + if( theta <= M_PI / 2.0 ) /* first quadrant */ + { theta = theta; + CopyConstraint(c1, *hc); + CopyConstraint(c2, *vc); + } + else if ( theta <= M_PI ) /* second quadrant */ + { theta -= M_PI / 2.0; + ReflectConstraint(c1, *vc); + CopyConstraint(c2, *hc); + } + else if ( theta <= 3.0 * M_PI / 2.0 ) /* third quadrant */ + { theta -= M_PI; + ReflectConstraint(c1, *hc); + ReflectConstraint(c2, *vc); + } + else /* fourth quadrant */ + { theta -= 3.0 * M_PI / 2.0; + CopyConstraint(c1, *vc); + ReflectConstraint(c2, *hc); + } + psi = M_PI / 2.0 - theta; + debug2(DSC, DD, " c1: %s; c2: %s", EchoConstraint(&c1), EchoConstraint(&c2)); + + /* return the minimum of the two constraints, rotated */ + if( dim == COLM ) + { SemiRotateConstraint(c, back(y, ROWM), fwd(y, ROWM), theta, &c1); + ReflectConstraint(c3, c2); + SemiRotateConstraint(&dc, fwd(y, ROWM), back(y, ROWM), psi, &c3); + MinConstraint(c, &dc); + } + else + { SemiRotateConstraint(c, back(y, COLM), fwd(y, COLM), psi, &c1); + SemiRotateConstraint(&dc, fwd(y, COLM), back(y, COLM), theta, &c2); + MinConstraint(c, &dc); + } + + debug1(DSC, DD, "RotateConstraint returning %s", EchoConstraint(c)); +} /* end RotateConstraint */ + +/*@::InsertScale()@***********************************************************/ +/* */ +/* BOOLEAN InsertScale(x, c) */ +/* */ +/* Insert a @Scale object above x so that x is scaled horizontally to fit */ +/* constraint c. If this is not possible, owing to the necessary scale */ +/* factor being too small, then don't do it; return FALSE instead. */ +/* */ +/*****************************************************************************/ + +BOOLEAN InsertScale(OBJECT x, CONSTRAINT *c) +{ int scale_factor; OBJECT prnt; + scale_factor = ScaleToConstraint(back(x, COLM), fwd(x, COLM), c); + if( scale_factor >= 0.2 * SF ) + { + New(prnt, SCALE); + underline(prnt) = underline(x); + FposCopy(fpos(prnt), fpos(x)); + + /* set horizontal size and scale factor */ + bc(constraint(prnt)) = scale_factor; + back(prnt, COLM) = ( back(x, COLM) * scale_factor ) / SF; + + /* *** slightly too small? + fwd(prnt, COLM) = ( fwd(x, COLM) * scale_factor ) / SF; + *** */ + fwd(prnt, COLM) = find_min(bfc(*c) - back(prnt, COLM), fc(*c)); + + /* set vertical size and scale factor */ + fc(constraint(prnt)) = 1 * SF; + back(prnt, ROWM) = back(x, ROWM); + fwd(prnt, ROWM) = fwd(x, ROWM); + + /* link prnt above x and return */ + ReplaceNode(prnt, x); + Link(prnt, x); + return TRUE; + } + else return FALSE; +} /* end InsertScale */ + + +/*@::CatConstrained()@********************************************************/ +/* */ +/* static CatConstrained(x, xc, ratm, y, dim, OBJECT *why) */ +/* */ +/* Calculate the size constraint of object x, as for Constrained below. */ +/* y is the enclosing VCAT etc. object; ratm is TRUE if a ^ lies after */ +/* x anywhere. dim is COLM or ROWM. */ +/* */ +/* The meaning of the key variables is as follows: */ +/* */ +/* be The amount by which back(x, dim) can increase from zero */ +/* without having any impact on size(y, dim). Thereafter, */ +/* any increase causes an equal increase in size(y, dim). */ +/* */ +/* fe The amount by which fwd(x, dim) can increase from zero */ +/* without having any impact on size(y, dim). Thereafter, */ +/* any increase causes an equal increase in size(y, dim). */ +/* */ +/* backy, The value that back(y, dim) and fwd(y, dim) would have if x */ +/* fwdy was definite with size 0,0. They will in general be larger */ +/* than the present values if x is indefinite, and smaller */ +/* if x is definite, although it depends on marks and gaps. */ +/* */ +/*****************************************************************************/ + +static void CatConstrained(OBJECT x, CONSTRAINT *xc, BOOLEAN ratm, +OBJECT y, int dim, OBJECT *why) +{ int side; /* the size of y that x is on: BACK, ON, FWD */ + CONSTRAINT yc; /* constraints on y */ + FULL_LENGTH backy, fwdy; /* back(y), fwd(y) would be if x was (0, 0) */ + FULL_LENGTH be, fe; /* amount back(x), fwd(x) can be for free */ + FULL_LENGTH beffect, feffect; /* scratch variables for calculations */ + FULL_LENGTH seffect; /* scratch variables for calculations */ + OBJECT link, sg, pg; /* link to x, its successor and predecessor */ + OBJECT prec_def, sd; /* definite object preceding (succeeding) x */ + int tb, tbf, tf, tbc, tbfc, tfc, mxy, myz; + + Constrained(y, &yc, dim, why); + if( constrained(yc) ) + { + /* find the link of x, and its neighbours and their links */ + link = UpDim(x, dim); + SetNeighbours(link, ratm, &pg, &prec_def, &sg, &sd, &side); + + /* amount of space available at x without changing the size of y */ + be = pg == nilobj ? 0 : ExtraGap(fwd(prec_def, dim), 0, &gap(pg), BACK); + fe = sg == nilobj ? 0 : ExtraGap(0, back(sd, dim), &gap(sg), FWD); + + if( is_indefinite(type(x)) ) + { + /* insert two lengths and delete one */ + beffect = pg==nilobj ? 0 : MinGap(fwd(prec_def, dim), 0, 0, &gap(pg)); + feffect = sg==nilobj ? 0 : MinGap(0, back(sd,dim), fwd(sd,dim), &gap(sg)); + seffect = pg==nilobj ? + sg == nilobj ? 0 : back(sd, dim) : + sg == nilobj ? fwd(prec_def, dim) : + MinGap(fwd(prec_def, dim), back(sd, dim), fwd(sd, dim), &gap(sg)); + + switch( side ) + { + case BACK: backy = back(y, dim) + beffect + feffect - seffect; + fwdy = fwd(y, dim); + break; + + case ON: /* must be first, other cases prohibited */ + backy = 0; + fwdy = fwd(y, dim) + feffect; + break; + + case FWD: backy = back(y, dim); + fwdy = fwd(y, dim) + beffect + feffect - seffect; + break; + } + } + + else /* x is definite */ + + { beffect = pg == nilobj ? back(x, dim) : + MinGap(fwd(prec_def, dim), back(x,dim), fwd(x,dim), &gap(pg)) - + MinGap(fwd(prec_def, dim), 0, 0, &gap(pg)); + + feffect = sg == nilobj ? fwd(x, dim) : + MinGap(fwd(x, dim), back(sd, dim), fwd(sd, dim), &gap(sg)) - + MinGap(0, back(sd, dim), fwd(sd, dim), &gap(sg)); + + switch( side ) + { + case BACK: backy = back(y, dim) - beffect - feffect; + fwdy = fwd(y, dim); + break; + + case ON: backy = back(y, dim) - beffect; + fwdy = fwd(y, dim) - feffect; + break; + + case FWD: backy = back(y, dim); + fwdy = fwd(y, dim) - beffect - feffect; + break; + } + } + + debug5(DSC, DD, " side: %s, backy: %s, fwdy: %s, be: %s, fe: %s", + Image(side), EchoLength(backy), EchoLength(fwdy), + EchoLength(be), EchoLength(fe) ); + + if( !FitsConstraint(backy, fwdy, yc) ) + SetConstraint(*xc, -1, -1, -1); + else switch( side ) + { + + case BACK: + + tbc = bc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : bc(yc) - backy; + tbfc = bfc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : bfc(yc) - backy - fwdy; + mxy = find_min(tbc, tbfc); + tb = find_min(MAX_FULL_LENGTH, be + mxy); + tbf = find_min(MAX_FULL_LENGTH, be + fe + mxy); + tf = find_min(MAX_FULL_LENGTH, fe + mxy); + SetConstraint(*xc, tb, tbf, tf); + break; + + + case ON: + + tbc = bc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : bc(yc) - backy; + tbfc = bfc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : bfc(yc) - backy - fwdy; + tfc = fc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : fc(yc) - fwdy; + mxy = find_min(tbc, tbfc); + myz = find_min(tfc, tbfc); + tb = find_min(MAX_FULL_LENGTH, be + mxy); + tbf = find_min(MAX_FULL_LENGTH, be + fe + tbfc); + tf = find_min(MAX_FULL_LENGTH, fe + myz); + SetConstraint(*xc, tb, tbf, tf); + break; + + + case FWD: + + tfc = fc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : fc(yc) - fwdy; + tbfc = bfc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : bfc(yc) - backy - fwdy; + mxy = find_min(tfc, tbfc); + tb = find_min(MAX_FULL_LENGTH, be + mxy); + tbf = find_min(MAX_FULL_LENGTH, be + fe + mxy); + tf = find_min(MAX_FULL_LENGTH, fe + mxy); + SetConstraint(*xc, tb, tbf, tf); + break; + + } + } /* end if( constrained ) */ + else SetConstraint(*xc, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); +} /* end CatConstrained */ + + +/*@::Constrained()@***********************************************************/ +/* */ +/* Constrained(x, xc, dim, why) */ +/* */ +/* Calculate the size constraint of object x, and return it in *xc. */ +/* */ +/* If the resulting constraint is a hard one caused by coming up against */ +/* a HIGH (vertical) or WIDE (horizontal), set *why to this object; if */ +/* not, leave *why unchanged. */ +/* */ +/*****************************************************************************/ + +void Constrained(OBJECT x, CONSTRAINT *xc, int dim, OBJECT *why) +{ OBJECT y, link, lp, rp, z, tlink, g; CONSTRAINT yc, hc, vc; + BOOLEAN ratm; FULL_LENGTH xback, xfwd; int tb, tf, tbf, tbc, tfc; + SetLengthDim(dim); + debug2(DSC, DD, "[ Constrained(%s, xc, %s, why), x =", + Image(type(x)), dimen(dim)); + ifdebug(DSC, DD, DebugObject(x)); + assert( Up(x) != x, "Constrained: x has no parent!" ); + + /* a CLOSURE which is external_ver is unconstrained in the ROWM direction */ + /* a CLOSURE which is external_hor is unconstrained in both directions */ + if( type(x) == CLOSURE && ((dim==ROWM && external_ver(x)) || external_hor(x)) ) + { + SetConstraint(*xc, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); + debug1(DSC, DD, "] Constrained returning %s (external)",EchoConstraint(xc)); + return; + } + + /* find y, the parent of x */ + link = UpDim(x, dim); ratm = FALSE; + for( tlink = NextDown(link); type(tlink) == LINK; tlink = NextDown(tlink) ) + { Child(g, tlink); + if( type(g) == GAP_OBJ && mark(gap(g)) ) ratm = TRUE; + } + y = tlink; + debug1(DSC, DDD, "parent y = %s", Image(type(y))); + ifdebug(DSC, DDD, DebugObject(y)); + + switch( type(y) ) + { + case PLAIN_GRAPHIC: + case GRAPHIC: + case KERN_SHRINK: + case ONE_COL: + case ONE_ROW: + case HCONTRACT: + case VCONTRACT: + case HEXPAND: + case VEXPAND: + case START_HVSPAN: + case START_HSPAN: + case START_VSPAN: + case SPLIT: + case BACKGROUND: + + Constrained(y, xc, dim, why); + break; + + + case HSCALE: + case VSCALE: + + if( (dim == COLM) != (type(y) == HSCALE) ) Constrained(y, xc, dim, why); + else SetConstraint(*xc, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); + break; + + + case HCOVER: + case VCOVER: + + /* dubious, but not likely to arise anyway */ + if( (dim == COLM) != (type(y) == HCOVER) ) Constrained(y, xc, dim, why); + else SetConstraint(*xc, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); + break; + + + case SCALE: + + Constrained(y, &yc, dim, why); + if( dim == COLM && bc(constraint(y)) == 0 ) + { + /* Lout-supplied factor required later, could be tiny */ + SetConstraint(*xc, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); + } + else + { InvScaleConstraint(xc, + dim == COLM ? bc(constraint(y)) : fc(constraint(y)), &yc); + } + break; + + + case ROTATE: + + Constrained(y, &hc, COLM, why); Constrained(y, &vc, ROWM, why); + RotateConstraint(xc, x, sparec(constraint(y)), &hc, &vc, dim); + break; + + + case WIDE: + case HIGH: + + Constrained(y, xc, dim, why); + if( (type(y)==WIDE) == (dim==COLM) ) + { MinConstraint(xc, &constraint(y)); + *why = y; + } + break; + + + case HLIMITED: + case VLIMITED: + + if( (type(y) == HLIMITED) == (dim == COLM) ) + { + BOOLEAN still_searching = TRUE; + z = y; + SetConstraint(*xc, back(z, dim), size(z, dim), fwd(z, dim)); + debug2(DSC, D, " [ %s (%s)", Image(type(z)), EchoConstraint(xc)); + while( still_searching && Up(z) != z ) + { + Parent(z, UpDim(z, dim)); + switch( type(z) ) + { + case VLIMITED: + case HLIMITED: + case COL_THR: + case ROW_THR: + case ONE_COL: + case ONE_ROW: + case HCONTRACT: + case VCONTRACT: + case SPLIT: + case START_VSPAN: + case START_HSPAN: + + SetConstraint(*xc, back(z, dim), size(z, dim), fwd(z, dim)); + debug2(DSC, DD, " let s = %s (%s)", Image(type(z)), + EchoConstraint(xc)); + break; + + + case HSPANNER: + case VSPANNER: + + /* SpannerAvailableSpace(z, dim, &b, &f); */ + CopyConstraint(*xc, constraint(z)); + debug2(DSC, D, " ] let s = %s (%s) and stop", + Image(type(z)), EchoConstraint(&constraint(z))); + still_searching = FALSE; + break; + + + default: + + debug1(DSC, D, " ] stopping at %s", Image(type(z))); + still_searching = FALSE; + break; + } + } + *why = y; + } + else + { + Constrained(y, xc, dim, why); + } + break; + + + case VSPANNER: + case HSPANNER: + + /* we're saying that a spanner has a fixed constraint that is */ + /* determined just once in its life */ + CopyConstraint(*xc, constraint(y)); + debug2(DSC, DD, " Constrained(%s) = %s", Image(type(z)), EchoConstraint(xc)); + /* SetConstraint(*xc, back(y, dim), size(y, dim), fwd(y, dim)); */ + break; + + + case HSHIFT: + case VSHIFT: + + if( (type(y) == HSHIFT) == (dim == COLM) ) + { Constrained(y, &yc, dim, why); + tf = FindShift(y, x, dim); + SetConstraint(*xc, + find_min(bc(yc), bfc(yc)) - tf, bfc(yc), find_min(fc(yc), bfc(yc)) + tf); + } + else Constrained(y, xc, dim, why); + break; + + + case HEAD: + + if( dim == ROWM ) + SetConstraint(*xc, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); + else + { CopyConstraint(yc, constraint(y)); + debug1(DSC, DD, " head: %s; val is:", EchoConstraint(&yc)); + ifdebug(DSC, DD, DebugObject(y)); + goto REST_OF_HEAD; /* a few lines down */ + } + break; + + + case COL_THR: + case ROW_THR: + + assert( (type(y)==COL_THR) == (dim==COLM), "Constrained: COL_THR!" ); + Constrained(y, &yc, dim, why); + tb = bfc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : bfc(yc) - fwd(y, dim); + tb = find_min(bc(yc), tb); + tf = bfc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : bfc(yc) - back(y, dim); + tf = find_min(fc(yc), tf); + SetConstraint(*xc, tb, bfc(yc), tf); + break; + + + case VCAT: + case HCAT: + case ACAT: + + if( (type(y)==VCAT) == (dim==ROWM) ) + { CatConstrained(x, xc, ratm, y, dim, why); + break; + } + Constrained(y, &yc, dim, why); + if( !constrained(yc) ) + SetConstraint(*xc, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); + else + { + REST_OF_HEAD: + /* let lp and rp be the links of the gaps delimiting */ + /* the components joined to x (or parent if no such) */ + for( lp = PrevDown(link); lp != y; lp = PrevDown(lp) ) + { Child(z, lp); + if( type(z) == GAP_OBJ && !join(gap(z)) ) break; + } + for( rp = NextDown(link); rp != y; rp = NextDown(rp) ) + { Child(z, rp); + if( type(z) == GAP_OBJ && !join(gap(z)) ) break; + } + if( lp == y && rp == y && !(type(y) == HEAD && seen_nojoin(y)) ) + { + /* if whole object is joined, do this */ + tb = bfc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : bfc(yc) - fwd(y, dim); + tb = find_min(bc(yc), tb); + tf = bfc(yc) == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : bfc(yc) - back(y, dim); + tf = find_min(fc(yc), tf); + SetConstraint(*xc, tb, bfc(yc), tf); + } + else + { + /* if // or || is present, do this */ + xback = xfwd = 0; + for(link = NextDown(lp); link != rp; link = NextDown(link) ) + { Child(z, link); + if( type(z) == GAP_OBJ || is_index(type(z)) ) continue; + xback = find_max(xback, back(z, dim)); + xfwd = find_max(xfwd, fwd(z, dim)); + } + debug2(DSC, DD, " lp != rp; xback,xfwd = %s,%s", + EchoLength(xback), EchoLength(xfwd)); + tbf = find_min(bfc(yc), fc(yc)); + tbc = tbf == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : tbf - xfwd; + tfc = tbf == MAX_FULL_LENGTH ? MAX_FULL_LENGTH : tbf - xback; + SetConstraint(*xc, tbc, tbf, tfc); + } + } + break; + + + default: + + assert1(FALSE, "Constrained:", Image(type(y))); + break; + + } + debug2(DSC, DD, "] Constrained %s returning %s", Image(type(x)), + EchoConstraint(xc)); +} /* end Constrained */ + + +/*@::EchoConstraint(), DebugConstrained()@************************************/ +/* */ +/* FULL_CHAR *EchoConstraint(c) */ +/* */ +/* Returns a string showing constraint *c, in centimetres. */ +/* */ +/*****************************************************************************/ +#if DEBUG_ON + +FULL_CHAR *EchoConstraint(CONSTRAINT *c) +{ static char str[2][40]; + static int i = 0; + i = (i+1) % 2; + sprintf(str[i], "<%s, %s, %s>", EchoLength(bc(*c)), EchoLength(bfc(*c)), + EchoLength(fc(*c))); + return AsciiToFull(str[i]); +} /* end EchoConstraint */ + + +/*****************************************************************************/ +/* */ +/* DebugConstrained(x) */ +/* */ +/* Calculate and print the constraints of all closures lying within */ +/* sized object x. */ +/* */ +/*****************************************************************************/ + +void DebugConstrained(OBJECT x) +{ OBJECT y, link, why; + CONSTRAINT c; + debug1(DSC, DDD, "DebugConstrained( %s )", EchoObject(x) ); + switch( type(x) ) + { + + case CROSS: + case FORCE_CROSS: + case ROTATE: + case BACKGROUND: + case INCGRAPHIC: + case SINCGRAPHIC: + case PLAIN_GRAPHIC: + case GRAPHIC: + case KERN_SHRINK: + case WORD: + case QWORD: + case START_HVSPAN: + case START_HSPAN: + case START_VSPAN: + case HSPAN: + case VSPAN: + + break; + + + case CLOSURE: + + Constrained(x, &c, COLM, &why); + debug2(DSC, DD, "Constrained( %s, &c, COLM ) = %s", + EchoObject(x), EchoConstraint(&c)); + Constrained(x, &c, ROWM, &why); + debug2(DSC, DD, "Constrained( %s, &c, ROWM ) = %s", + EchoObject(x), EchoConstraint(&c)); + break; + + + case SPLIT: + + link = DownDim(x, COLM); Child(y, link); + DebugConstrained(y); + break; + + + case HEAD: + case ONE_COL: + case ONE_ROW: + case HCONTRACT: + case VCONTRACT: + case HLIMITED: + case VLIMITED: + case HEXPAND: + case VEXPAND: + case HSCALE: + case VSCALE: + case HCOVER: + case VCOVER: + case SCALE: + case WIDE: + case HIGH: + + link = Down(x); Child(y, link); + DebugConstrained(y); + break; + + + case COL_THR: + case VCAT: + case HCAT: + case ACAT: + + for( link = Down(x); link != x; link =NextDown(link) ) + { Child(y, link); + if( type(y) != GAP_OBJ && !is_index(type(y)) ) DebugConstrained(y); + } + break; + + + default: + + assert1(FALSE, "DebugConstrained:", Image(type(x))); + break; + + } + debug0(DSC, DDD, "DebugConstrained returning."); +} /* end DebugConstrained */ +#endif |