/*@z15.c:Size Constraints:MinConstraint(), EnlargeToConstraint()@*************/
/* */
/* THE LOUT DOCUMENT FORMATTING SYSTEM (VERSION 3.41) */
/* COPYRIGHT (C) 1991, 2023 Jeffrey H. Kingston */
/* */
/* Jeffrey H. Kingston (jeff@it.usyd.edu.au) */
/* School of Information Technologies */
/* 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 3, 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.14159265358979323846
#endif
#include "externs.h"
#include "parent.h"
#include "child.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*M_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=0, fwdy=0; /* 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 LINK_SOURCE:
case LINK_DEST:
case LINK_DEST_NULL:
case LINK_URL:
case KERN_SHRINK:
case BEGIN_HEADER:
case SET_HEADER:
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 HMIRROR:
case VMIRROR:
if( (dim == COLM) == (type(y) == HMIRROR) )
{
Constrained(y, &yc, dim, why);
FlipConstraint(*xc, yc);
}
else
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(y)), 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 LINK_SOURCE:
case LINK_DEST:
case LINK_DEST_NULL:
case LINK_URL:
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 HMIRROR:
case VMIRROR:
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
