/*@z21.c:Galley Maker:SizeGalley()@*******************************************/
/* */
/* THE LOUT DOCUMENT FORMATTING SYSTEM (VERSION 3.24) */
/* COPYRIGHT (C) 1991, 2000 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: z21.c */
/* MODULE: Galley Maker */
/* EXTERNS: SizeGalley() */
/* */
/*****************************************************************************/
#include "externs.h"
/*****************************************************************************/
/* */
/* SizeGalley(hd, env, rows, joined, nonblock, trig, style, c, target, */
/* dest_index, recs, inners, enclose) */
/* */
/* Convert unsized galley hd into sized format. The input parameters are: */
/* */
/* hd the galley to be converted */
/* env its environment (needs to be "held" while manifesting) */
/* rows TRUE if the resulting galley may have more than one row */
/* joined TRUE if the resulting galley must be simply joined */
/* nonblock Set the non_blocking() field of RECEPTIVEs to this value */
/* trig TRUE if indefinites of hd may trigger external galleys */
/* *style The initial style */
/* *c the width constraint hd should conform to */
/* target if non-nilobj, expand indefinite objects to reveal a */
/* @Galley within this symbol */
/* enclose If non-nilobj, enclose any @Galley symbol encountered */
/* during manifesting by this symbol. */
/* */
/* The output parameters, in addition to the converted hd, are: */
/* */
/* dest_index the index of the @Galley found within target, if any */
/* recs list of all RECURSIVE indexes found (or nilobj if none) */
/* inners list of all UNATTACHED indexes found (or nilobj if none), */
/* not including any that come after the target or InputSym. */
/* */
/*****************************************************************************/
void SizeGalley(OBJECT hd, OBJECT env, BOOLEAN rows, BOOLEAN joined,
BOOLEAN nonblock, BOOLEAN trig, STYLE *style, CONSTRAINT *c, OBJECT target,
OBJECT *dest_index, OBJECT *recs, OBJECT *inners, OBJECT enclose)
{ OBJECT y, link, z, crs, t, tlink, zlink, tmp, why;
OBJECT extras, tmp1, tmp2, bt[2], ft[2], hold_env;
BOOLEAN after_target;
assert( type(hd) == HEAD && Down(hd) != hd, "SizeGalley: precondition!" );
assert( !sized(hd), "SizeGalley: already sized!" );
debug6(DGM, D, "SizeGalley(%s, -, %s, %s, %s, %s, -, %s, -, -, -), hd =",
SymName(actual(hd)), bool(rows), bool(joined), bool(nonblock),
bool(trig), EchoConstraint(c));
debug1(DGM, DD, " env = %s", EchoObject(env));
ifdebug(DGM, D, DebugObject(hd));
/* manifest the child of hd, making sure it is simply joined if required */
Child(y, Down(hd));
tmp1 = target;
tmp2 = enclose;
crs = nilobj;
bt[COLM] = ft[COLM] = bt[ROWM] = ft[ROWM] = nilobj;
New(hold_env, ACAT); Link(hold_env, env);
if( AllowCrossDb && type(y) == CLOSURE && has_optimize(actual(y))
&& FindOptimize(y, env) )
{
SetOptimize(hd, style);
}
debug2(DOM, D, "[ calling Manifest(%s) from SizeGalley(%s)",
Image(type(y)), SymName(actual(hd)));
debug2(DOB, D, "[ calling Manifest(%s) from SizeGalley(%s)",
Image(type(y)), SymName(actual(hd)));
if( joined )
{ New(bt[COLM], THREAD); New(ft[COLM], THREAD);
debug0(DGM, DD, "SizeGalley calling Manifest (joined)");
y = Manifest(y, env, style, bt, ft, &tmp1, &crs, TRUE, must_expand(hd),
&tmp2, FALSE);
assert( Down(bt[COLM]) != bt[COLM] && Down(ft[COLM]) != ft[COLM],
"SizeGalley: threads!" );
Child(tmp1, Down(bt[COLM])); Child(tmp2, Down(ft[COLM]));
if( Down(bt[COLM]) != LastDown(bt[COLM]) ||
Down(ft[COLM]) != LastDown(ft[COLM]) || tmp1 != tmp2 )
Error(21, 1, "galley %s must have just one column mark",
FATAL, &fpos(y), SymName(actual(hd)) );
DisposeObject(bt[COLM]); DisposeObject(ft[COLM]);
}
else
{ debug0(DGM, DD, "SizeGalley calling Manifest (not joined)");
y = Manifest(y, env, style, bt, ft, &tmp1, &crs, TRUE, must_expand(hd),
&tmp2, FALSE);
}
debug2(DOM, D, "] returning Manifest(%s) from SizeGalley(%s)",
Image(type(y)), SymName(actual(hd)));
debug2(DOB, D, "] returning Manifest(%s) from SizeGalley(%s)",
Image(type(y)), SymName(actual(hd)));
DisposeObject(hold_env);
debug0(DGM, DD, "SizeGalley: after manifesting, hd =");
ifdebug(DGM, DD, DebugObject(hd));
/* horizontally size hd */
debug0(DGM, DD, "SizeGalley horizontally sizing hd:");
New(extras, ACAT);
debug2(DSF, D, "[ calling MinSize(%s) from SizeGalley(%s)",
Image(type(y)), SymName(actual(hd)));
y = MinSize(y, COLM, &extras);
debug2(DSF, D, "] returning MinSize(%s) from SizeGalley(%s)",
Image(type(y)), SymName(actual(hd)));
/* break hd if vertical galley */
if( gall_dir(hd) == ROWM )
{
CopyConstraint(constraint(hd), *c);
debug0(DGM, DD, "SizeGalley calling BreakObject:");
debug2(DOB, D, "[ calling BreakObject(%s) from SizeGalley(%s)",
Image(type(y)), SymName(actual(hd)));
y = BreakObject(y, c);
debug2(DOB, D, "] returning BreakObject(%s) from SizeGalley(%s)",
Image(type(y)), SymName(actual(hd)));
if( !FitsConstraint(back(y, COLM), fwd(y, COLM), *c) )
Error(21, 13, "%s,%s object too wide for available space",
FATAL, &fpos(y), EchoLength(back(y, COLM)), EchoLength(fwd(y, COLM)));
back(hd, COLM) = back(y, COLM);
fwd(hd, COLM) = fwd(y, COLM);
assert( FitsConstraint(back(hd, COLM), fwd(hd, COLM), *c),
"SizeGalley: BreakObject failed to fit!" );
debug2(DSF, D, "MinSize(hd, COLM) = %s,%s",
EchoLength(back(hd, COLM)), EchoLength(fwd(hd, COLM)) );
}
/* hyphenate hd if horizontal optimal galley says so */
else if( opt_components(hd) != nilobj && opt_hyph(hd) && type(y) == ACAT )
{ debug0(DOG, D, "SizeGalley calling Hyphenate()");
y = Hyphenate(y);
}
/* get the rows of hd to the top level, if required */
seen_nojoin(hd) = FALSE;
if( rows )
{ /* OBJECT prev_gap = nilobj; */
debug0(DGM, DD, "SizeGalley cleaning up rows of hd:");
for( link = hd; NextDown(link) != hd; link = NextDown(link) )
{ Child(y, NextDown(link));
debug2(DGM, DD, " cleaning %s: %s", Image(type(y)), EchoObject(y));
switch( type(y) )
{
case GAP_OBJ:
/* prev_gap = y; */
if( !join(gap(y)) ) seen_nojoin(hd) = TRUE;
break;
case VCAT:
if( gall_dir(hd) == ROWM )
{ TransferLinks(Down(y), y, Up(y));
DisposeChild(Up(y));
link = PrevDown(link);
}
break;
case ACAT:
if( gall_dir(hd) == COLM )
{ TransferLinks(Down(y), y, Up(y));
DisposeChild(Up(y));
link = PrevDown(link);
}
break;
case SPLIT:
assert(Up(y)==LastUp(y), "SizeGalley COL_THR: Up(y)!=LastUp(y)!");
Child(z, DownDim(y, ROWM));
if( is_indefinite(type(z)) )
{
debug1(DGT, D, "SizeGalley setting external_ver(%s) to TRUE (a)",
EchoObject(z));
external_ver(z) = TRUE;
}
else if( type(z) == VCAT )
{ OBJECT hor, thor, clink, dlink;
Child(hor, DownDim(y, COLM));
assert( type(hor) == COL_THR, "SizeGalley: missing COL_THR!" );
Parent(thor, UpDim(z, COLM));
assert( hor == thor, "SizeGalley/SPLIT: hor != thor!" );
clink = DownDim(y, COLM);
dlink = UpDim(z, COLM);
for( tlink = LastDown(z); tlink != z; tlink = PrevDown(tlink) )
{ Child(t, tlink);
if( type(t) == GAP_OBJ )
{ Link(NextDown(link), t);
}
else
{ New(tmp, SPLIT);
back(tmp, COLM) = back(hor, COLM);
fwd(tmp, COLM) = fwd(hor, COLM);
Link(NextDown(link), tmp);
Link(tmp, NextUp(clink));
Link(NextDown(dlink), t);
Link(tmp, t);
}
}
DeleteLink(dlink);
assert(Up(y)==LastUp(y), "SizeGalley COL_THR: Up(y) != LastUp(y)!");
DisposeChild(Up(y));
link = PrevDown(link);
}
break;
case CLOSURE:
case HEAD:
if( gall_dir(hd) == COLM )
external_hor(y) = TRUE;
else
{
debug1(DGT, D, "SizeGalley setting external_ver(%s) to TRUE (b)",
EchoObject(y));
external_ver(y) = TRUE;
}
break;
default:
break;
}
}
}
/* determine a scale factor for {} @Scale objects */
/* NB AdjustSize cannot be done correctly until after seen_nojoin is set */
for( link = Down(extras); link != extras; link = NextDown(link) )
{ Child(y, link);
if( type(y) == SCALE_IND )
{
/* check that all is in order */
CONSTRAINT zc; OBJECT t; FULL_LENGTH b, f;
z = actual(y);
assert( type(z) == SCALE, "SizeObject: type(z) != SCALE!" );
assert( bc(constraint(z)) == 0, "SizeObject: bc(constraint(z)) != 0" );
assert( Down(z) != z, "SizeObject SCALE: Down(z) == z!" );
Child(t, Down(z));
/* use @Scale COLM size constraint to determine a suitable scale factor */
/* check that @Scale is not in a horizontal galley */
if( gall_dir(hd) == COLM )
{ Error(21, 2, "%s with unspecified scale factor in horizontal galley",
FATAL, &fpos(z), KW_SCALE);
}
Constrained(z, &zc, COLM, &why);
debug2(DGM, DD, "Constrained(%s, -, COLM) = %s", EchoObject(z),
EchoConstraint(&zc));
if( !constrained(zc) )
{ Error(21, 3, "replacing infinite scale factor (unconstrained width) by 1.0",
WARN, &fpos(z));
bc(constraint(z)) = fc(constraint(z)) = 1 * SF;
}
else if( size(t, COLM) == 0 )
{ Error(21, 4, "replacing infinite scale factor (zero width object) by 1.0",
WARN, &fpos(z));
bc(constraint(z)) = fc(constraint(z)) = 1 * SF;
}
else if( (float) bfc(zc) / size(t, COLM) > 100.0 )
{ Error(21, 5, "replacing very large scale factor (over 100) by 1.0",
WARN, &fpos(z));
bc(constraint(z)) = fc(constraint(z)) = 1 * SF;
}
else if( (float) bfc(zc) / size(t, COLM) < 0.01 )
{ if( bfc(zc) == 0 )
Error(21, 6, "object deleted (scale factor is zero)",
WARN, &fpos(z));
else
Error(21, 7, "object deleted (scale factor is smaller than 0.01)",
WARN, &fpos(z));
bc(constraint(z)) = fc(constraint(z)) = 1 * SF;
tmp = MakeWord(WORD, STR_EMPTY, &fpos(t));
back(tmp, COLM) = fwd(tmp, COLM) = 0;
back(tmp, ROWM) = fwd(tmp, ROWM) = 0;
word_font(tmp) = word_colour(tmp) = word_language(tmp) = 0;
word_outline(tmp) = FALSE;
word_hyph(tmp) = FALSE;
ReplaceNode(tmp, t);
DisposeObject(t);
t = tmp;
}
else bc(constraint(z)) = fc(constraint(z)) = (bfc(zc) * SF)/size(t, COLM);
/* calculate scaled size and adjust */
b = (back(t, COLM) * fc(constraint(z))) / SF;
f = (fwd(t, COLM) * fc(constraint(z))) / SF;
debug3(DGM, DD, "AdjustSize(%s, %s, %s, COLM)", EchoObject(z),
EchoLength(b), EchoLength(f));
AdjustSize(z, b, f, COLM);
/* if already vertically sized (because inside @Rotate) adjust that */
if( vert_sized(z) )
{ b = (back(t, ROWM) * fc(constraint(z))) / SF;
f = (fwd(t, ROWM) * fc(constraint(z))) / SF;
debug4(DGM, DD, "AdjustSize(%s, %s, %s, %s)", EchoObject(z),
EchoLength(b), EchoLength(f), dimen(ROWM));
AdjustSize(z, b, f, ROWM);
}
}
}
DisposeObject(extras);
/* size the rows of hd and attach indices where needed */
debug0(DGM, DD, " SizeGalley calling MinSize(ROWM):");
debug0(DGM, DD, "SizeGalley sizing rows of hd =");
ifdebug(DGM, DD, DebugObject(hd));
*recs = *inners = *dest_index = nilobj;
after_target = FALSE;
for( link = Down(hd); link != hd; link = NextDown(link) )
{ Child(y, link);
if( type(y) == GAP_OBJ || is_index(type(y)) ) continue;
debug0(DGM, DDD, " ROWM sizing:");
ifdebug(DGM, DDD, DebugObject(y));
New(extras, ACAT);
y = MinSize(y, ROWM, &extras);
debug3(DSF, DD, "MinSize( %s , ROWM ) = %s,%s", EchoObject(y),
EchoLength(back(y, ROWM)), EchoLength(fwd(y, ROWM)) );
debug0(DGM, DDD, " ROWM result:");
ifdebug(DGM, DDD, DebugObject(y));
/* now attach indexes in front of y */
for( zlink = Down(extras); zlink != extras; zlink = NextDown(zlink) )
{ Child(z, zlink);
blocked(z) = FALSE;
/* debug1(DCR, DD, " extra: %s", EchoObject(z)); */
debug2(DGM, DD, " extra%s: %s",
after_target ? " after_target" : "", EchoObject(z));
switch( type(z) )
{
case RECEPTIVE:
/* debug2(DCR, DD, " ... uses_ext = %s, trig = %s",
bool(uses_extern_target(actual(actual(z)))), bool(trig)); */
trigger_externs(z) = uses_extern_target(actual(actual(z))) && trig;
non_blocking(z) = nonblock;
if( actual(actual(z)) == GalleySym || actual(actual(z)) == ForceGalleySym )
*dest_index = z;
if( actual(actual(z)) == GalleySym || actual(actual(z)) == ForceGalleySym
|| actual(actual(z)) == InputSym )
after_target = TRUE;
break;
case RECURSIVE:
if( *recs == nilobj ) New(*recs, ACAT);
Link(*recs, z);
break;
case UNATTACHED:
if( !after_target ) /* *** new semantics *** */
{ if( *inners == nilobj ) New(*inners, ACAT);
Link(*inners, z);
}
break;
case SCALE_IND:
case EXPAND_IND:
case GALL_PREC:
case GALL_FOLL:
case GALL_FOLL_OR_PREC:
case GALL_TARG:
case CROSS_PREC:
case CROSS_FOLL:
case CROSS_FOLL_OR_PREC:
case CROSS_TARG:
case PAGE_LABEL_IND:
debug1(DCR, DD, " SizeGalley: %s", EchoObject(z));
break;
case COVER_IND:
/* adjust size of the COVER object, change it to @Scale etc. */
{ OBJECT cover, prnt, chld; int dirn, thr_type, ok1, ok2, sf,subst, esubst;
float sf1, sf2; CONSTRAINT c; FULL_LENGTH b, f;
cover = actual(z);
if( type(cover) == HCOVER )
{ dirn = COLM;
thr_type = COL_THR;
ok1 = VCAT;
ok2 = VCAT;
subst = HSCALE;
esubst = ONE_COL;
}
else
{ dirn = ROWM;
thr_type = ROW_THR;
ok1 = ACAT;
ok2 = HCAT;
subst = VSCALE;
esubst = ONE_ROW;
}
Parent(prnt, UpDim(cover, dirn));
while( type(prnt) == SPLIT || type(prnt) == thr_type )
Parent(prnt, UpDim(prnt, dirn));
Child(chld, Down(cover));
if( type(prnt) != ok1 && type(prnt) != ok2 )
{
Error(21, 8, "%s replaced by %s (mark not shared)",
WARN, &fpos(cover), Image(type(cover)), Image(subst));
debug2(DGM, DDD, " cover = %s %s", Image(type(cover)),
EchoObject(cover));
debug1(DGM, DDD, " prnt = %s:", Image(type(prnt)));
ifdebug(DGM, DDD, DebugObject(prnt));
type(cover) = subst;
}
else if( back(chld, dirn) == 0 && fwd(chld, dirn) == 0 )
{
/* empty object, this is treated as a no-op */
type(cover) = esubst;
}
else if( back(chld, dirn) == 0 || fwd(chld, dirn) == 0 )
{ Error(21, 9, "%s replaced by %s (infinite scale factor)",
WARN, &fpos(cover), Image(type(cover)), Image(subst));
type(cover) = subst;
}
else if( size(prnt, dirn) == 0 )
{ Error(21, 10, "%s replaced by %s (zero scale factor)",
WARN, &fpos(cover), Image(type(cover)), Image(subst));
type(cover) = subst;
}
else /* sensible scale factor exists */
{
/* work out proposed scale factor and sizes for cover */
sf1 = (float) back(prnt, dirn) / back(chld, dirn);
sf2 = (float) fwd(prnt, dirn) / fwd(chld, dirn);
sf = find_max(sf1, sf2) * SF;
b = (back(chld, dirn) * sf) / SF;
f = (fwd(chld, dirn) * sf) / SF;
/* check whether new object fits */
Constrained(cover, &c, dirn, &why);
if( FitsConstraint(b, f, c) )
{
/* it fits, so make cover a SCALE object with this size */
type(cover) = SCALE;
if( dirn == COLM )
{ bc(constraint(cover)) = sf;
fc(constraint(cover)) = SF;
}
else
{ bc(constraint(cover)) = SF;
fc(constraint(cover)) = sf;
}
AdjustSize(cover, b, f, dirn);
}
else
{ Error(21, 11, "%s replaced by %s (insufficient space)",
WARN, &fpos(cover), Image(type(cover)), Image(subst));
type(cover) = subst;
}
}
}
break;
default:
assert1(FALSE, "SizeGalley:", Image(type(z)));
break;
}
}
TransferLinks(Down(extras), extras, link);
assert( Down(extras) == extras && Up(extras) == extras, "SizeG: extras!");
Dispose(extras);
}
/* insinuate cross references */
if( crs != nilobj )
{
debug1(DCR, DD, "SizeGalley insinuating %s", EchoObject(crs));
TransferLinks(Down(crs), crs, Down(hd));
DisposeObject(crs);
}
/* check that *dest_index was found if it was required, and exit */
if( target != nilobj && *dest_index == nilobj )
Error(21, 12, "unexpected absence of %s from the body of %s",
FATAL, &fpos(hd), SymName(target), SymName(actual(hd)));
debug3(DGM, D, "SizeGalley returning %s,%s %s; hd =",
EchoLength(back(hd, COLM)), EchoLength(fwd(hd, COLM)),
EchoConstraint(&constraint(hd)));
ifdebug(DGM, D, DebugGalley(hd, nilobj, 4));
sized(hd) = TRUE;
} /* end SizeGalley */
