[Indigo]<Cedar5.3>TSetter>TSJaMPageBuilderImpl.mesa!1

TSJaMPageBuilderImpl.mesa

Edited by: Maxwell, January 25, 1983 2:39 pm

Michael Plass, January 10, 1984 9:32 am

Last Edited by: Beach, May 7, 1984 4:13:18 pm PDT

DIRECTORY

Atom,

TSTypes,

TSObject,

TSOps,

TSDumper,

TSFont,

TSGlue,

TSOutput,

NodeStyle,

NodeStyleExtra,

TSAList,

JaMBasic,

JaMOps,

Rope,

TSJaMPageBuilder,

TSWrecker

;

TSJaMPageBuilderImpl: CEDAR PROGRAM

IMPORTS

Atom, TSTypes, TSObject, TSOps, TSDumper, TSFont, TSOutput, NodeStyle, NodeStyleExtra, TSAList, JaMOps, Rope, TSWrecker

EXPORTS TSJaMPageBuilder =

BEGIN OPEN TSTypes;

ROPE: TYPE = Rope.ROPE;

Frame: TYPE = NodeStyleExtra.Frame;

Handle: TYPE = REF TPStateRec;

TPStateRec: TYPE = RECORD [

pageReader: TSObject.ListReader,

currentMarks: TSObject.MarkList,

topMargin, leftMargin, pageHeight, paperHeight, paperWidth: Dimn,

columns: NAT,

output: TSOutput.Handle,

curFont: TSFont.Ref,

styleName: NodeStyle.Name,

documentName: ROPE,

abortCheckProc: TSJaMPageBuilder.AbortCheckProc,

stack: LIST OF REF ANY ← NIL,

aborted: BOOLEAN ← FALSE

];

RunPageBuilder: PUBLIC PROCEDURE [

galley: TSObject.ItemList,

style: NodeStyle.Ref,

output: TSOutput.Handle,

abortCheckProc: TSJaMPageBuilder.AbortCheckProc ← NIL,

documentName: Rope.ROPE ← NIL -- only a hint

]

RETURNS [aborted: BOOLEAN] = TRUSTED {

frame: Frame ← NodeStyleExtra.GetFrame[style: style, styleName: style.GetStyleName[], kind: print];

handle: Handle ← NEW[TPStateRec];

leadedGalley: TSObject.ItemList ← TSOps.InsertLeading[galley];

wreckList: LIST OF REF ANY ← LIST[galley, leadedGalley];

TSWrecker.toDestroyAtEndOfFile ← wreckList;

handle.styleName ← style.GetStyleName[];

RegisterJaMProcs[frame];

handle.paperHeight ← Pt[style.GetPageLength[]];

handle.paperWidth ← Pt[style.GetPageWidth[]];

handle.pageHeight ← Pt[style.GetPageLength[]-style.GetTopMargin[]-style.GetHeaderMargin[]-style.GetFooterMargin[]-style.GetBottomMargin[]];

handle.topMargin ← Pt[style.GetTopMargin[]];

handle.leftMargin ← Pt[style.GetLeftMargin[]];

handle.columns ← style.GetColumns[];

handle.documentName ← documentName;

handle.abortCheckProc ← abortCheckProc;

handle.pageReader ← TSOps.BreakUp[

list: TSOps.InsertLeading[galley],

direction: down,

size: handle.pageHeight

].CreateReader[];

handle.output ← output;

TSAList.Define[LOOPHOLE[frame], handle];

JaMOps.Execute[frame, NodeStyleExtra.CVX[

NodeStyleExtra.NameToObject[pageBuilderName]

]];

TSAList.UnDefine[LOOPHOLE[frame]];

NodeStyleExtra.FreeFrame[frame: frame, name: handle.styleName, kind: print];

aborted ← handle.aborted;

};

GoodByeScript: PROCEDURE [f: Frame] = {

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

IF handle = NIL THEN {

NodeStyleExtra.FreeFrame[frame: f, name: handle.styleName, kind: print];

};

pageBuilderName: NodeStyle.Name = NodeStyleExtra.MakeName["PageBuilder"];

PushItem: PROCEDURE [handle: Handle, item: REF ANY] =

BEGIN

handle.stack ← CONS[item, handle.stack];

END;

PopItem: PROCEDURE [handle: Handle] RETURNS [item: REF ANY] =

BEGIN

IF handle.stack = NIL THEN item ← NIL

ELSE {

t: LIST OF REF ANY ← handle.stack;

handle.stack ← t.rest;

item ← t.first;

t.first ← NIL;

t.rest ← NIL;

}

END;

PopList: PROCEDURE [handle: Handle, count: NAT]

RETURNS [itemList: TSObject.ItemList] =

BEGIN

list: LIST OF REF ANY ← NIL;

THROUGH [0..count) DO

item: REF ANY ← PopItem[handle];

IF item # NIL THEN list ← CONS[item, list];

ENDLOOP;

itemList ← TSObject.ItemListFromExplicitList[list];

END;

PopRope: PROCEDURE [f: Frame] RETURNS [rope: ROPE] = TRUSTED

BEGIN

s: string JaMBasic.Object ← JaMOps.PopString[f.opstk];

C: PROC[c: CHAR] RETURNS [BOOLEAN] = TRUSTED

{t[t.length]𡤌 t.length ← t.length+1; RETURN[FALSE]};

t: REF TEXT ← NEW[TEXT[s.length]];

t.length ← 0;

JaMOps.StringForAll[s, C];

rope ← Rope.FromRefText[t];

END;

PushRope: PROCEDURE [f: Frame, rope: ROPE] = TRUSTED

BEGIN

JaMOps.Push[

f.opstk,

JaMOps.MakeString[LOOPHOLE[rope.ToRefText[], LONG STRING]]

];

END;

Page: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN -- Pushes the next page box onto the stack

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

IF handle.abortCheckProc # NIL THEN handle.aborted ← handle.abortCheckProc[];

DO -- until we find a page box or empty the page list

IF handle.aborted OR handle.pageReader = NIL OR handle.pageReader.End[] THEN {

JaMOps.PushBoolean[f.opstk, FALSE];

IF handle.pageReader # NIL THEN handle.pageReader.DestroyReader[];

handle.pageReader ← NIL;

EXIT

}

ELSE {

IF ISTYPE[handle.pageReader.CurrentItem[], TSObject.MarkList] THEN {

thisPageMarks: TSObject.MarkList ← NARROW[handle.pageReader.CurrentItem[], TSObject.MarkList];

handle.currentMarks ← MergeMarkLists[thisPageMarks, handle.currentMarks];

handle.pageReader.Next[];

LOOP;

};

PushItem[handle, handle.pageReader.CurrentItem[]];

handle.pageReader.Next[];

JaMOps.PushBoolean[f.opstk, TRUE];

EXIT

};

ENDLOOP;

END;

ShipOut: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN -- Sends a constructed page to the outside world

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

item: REF ANY ← PopItem[handle];

handle.output.newPageProc[handle.output];

WITH item SELECT FROM

box: TSObject.Box => {

IF handle.output.pageSizeProc # NIL THEN

handle.output.pageSizeProc[

handle.output, handle.paperHeight, handle.paperWidth

];

handle.output.BoxOut[

xRef: handle.leftMargin,

yRef: SubDimn[handle.paperHeight, handle.topMargin],

box: box^

];

TSWrecker.DestroyRef[box, handle.stack];

};

ENDCASE => NULL;

END;

BoxFromHList: PROCEDURE [list: TSObject.ItemList] RETURNS [box: TSObject.Box] = {

source: TSObject.ListReader ← list.CreateReader[];

box ← TSOps.Package[source: source, direction: right, desired: [zeroDimn,nilDimn,nilDimn,nilDimn]].box;

source.DestroyReader[];

};

Columns: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

JaMOps.PushInteger[f.opstk, handle.columns];

END;

DocumentName: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

PushRope[f, handle.documentName];

END;

TextBox: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

rope: ROPE ← PopRope[f];

IF handle.curFont = NIL THEN handle.curFont ← TSFont.Lookup["Helvetica"];

PushItem[handle, BoxFromHList[TSOps.ItemListFromRope[handle.curFont, rope]]];

END;

TextFont: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

fontSize: Dimn ← RealDimn[JaMOps.PopReal[f.opstk], pt];

fontName: ROPE ← PopRope[f];

handle.curFont ← TSFont.Lookup[fontName, fontSize];

END;

Vbox: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

source: TSObject.ListReader ← PopList[handle, JaMOps.PopCardinal[f.opstk]].CreateReader[];

box: TSObject.Box ← TSOps.Package[

source: source,

direction: down,

desired: [nilDimn, nilDimn, zeroDimn, nilDimn]

].box;

PushItem[handle, box];

source.DestroyReader[];

END;

Hbox: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

PushItem[handle, BoxFromHList[

PopList[handle, JaMOps.PopCardinal[f.opstk]]

]];

END;

VboxTo: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

size: Dimn ← RealDimn[JaMOps.PopReal[f.opstk], pt];

source: TSObject.ListReader ← PopList[handle, JaMOps.PopCardinal[f.opstk]].CreateReader[];

PushItem[handle, TSOps.Package[

source: source,

direction: down,

desired: [nilDimn, nilDimn, zeroDimn, size]

].box];

source.DestroyReader[];

END;

HboxTo: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

size: Dimn ← RealDimn[JaMOps.PopReal[f.opstk], pt];

source: TSObject.ListReader ← PopList[handle, JaMOps.PopCardinal[f.opstk]].CreateReader[];

PushItem[handle, TSOps.Package[

source: source,

direction: right,

desired: [zeroDimn, size, nilDimn, nilDimn]

].box];

source.DestroyReader[];

END;

fillGlue: TSObject.Glue = NEW[TSGlue.Glue ← [zeroDimn, TSGlue.fill, zeroDimn]];

Fill: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

PushItem[handle, fillGlue];

END;

This proc can dump boxes, for use in debugging

DumpBox: SAFE PROCEDURE [f: Frame] =

TRUSTED BEGIN

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

TSDumper.DumpList[TSObject.SingletonList[PopItem[handle]]];

END;

emptyBox: TSObject.Box = NEW[TSObject.BoxRec ← [[zeroDimn, zeroDimn, zeroDimn, zeroDimn], empty[]]];

GetMark: SAFE PROCEDURE [f: Frame] = TRUSTED {

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

markKind: ROPE ← PopRope[f];

IF handle.currentMarks # NIL THEN {

markAtom: ATOM ← Atom.MakeAtom[markKind];

l: REF TSObject.MarkListItem ← handle.currentMarks;

UNTIL l = NIL OR l.markKind = markAtom DO

l ← l.link;

ENDLOOP;

IF l = NIL THEN PushItem[handle, emptyBox]

ELSE PushItem[handle, l.markValue];

}

ELSE PushItem[handle, emptyBox];

};

GetFirstMark: SAFE PROCEDURE [f: Frame] = TRUSTED {

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

markKind: ROPE ← PopRope[f];

IF handle.currentMarks # NIL THEN {

markAtom: ATOM ← Atom.MakeAtom[markKind];

l: REF TSObject.MarkListItem ← handle.currentMarks;

last: REF TSObject.MarkListItem ← NIL;

UNTIL l = NIL DO

IF l.markKind = markAtom THEN last ← l;

l ← l.link;

ENDLOOP;

IF last = NIL THEN PushItem[handle, emptyBox]

ELSE PushItem[handle, last.markValue];

}

ELSE PushItem[handle, emptyBox];

};

MergeMarkLists: PROCEDURE [new, old: TSObject.MarkList] RETURNS [TSObject.MarkList] = {

Merge the new and old lists of marks into one list with old duplicates eliminated, preserving order.

p, q, r: TSObject.MarkList;

Using a niave n**2 search, eliminate duplicates from the old list.

p ← old;

UNTIL p = NIL DO

r ← p;

q ← p.link;

UNTIL q = NIL DO

IF p.markKind = q.markKind THEN r.link ← q.link ELSE r ← q;

q ← q.link;

ENDLOOP;

p ← p.link;

ENDLOOP;

Find the end of the new list to concatenate the old one.

p ← new;

UNTIL p = NIL OR p.link = NIL DO

p ← p.link;

ENDLOOP;

IF p = NIL THEN new ← old ELSE p.link ← old;

RETURN [new];

};

ExchBox: SAFE PROCEDURE [f: Frame] = TRUSTED {

handle: Handle ← NARROW[TSAList.Find[LOOPHOLE[f]], Handle];

item1: REF ANY ← PopItem[handle];

item2: REF ANY ← PopItem[handle];

PushItem[handle, item1];

PushItem[handle, item2];

};

RegisterJaMProcs: PROCEDURE [f: Frame] =

BEGIN OPEN NodeStyleExtra;

[]←StyleCommand[f, ".page", Page]; -- -> <pagebox> .true . OR -> .false

[]←StyleCommand[f, ".getmark", GetMark]; -- -> <pagebox> (markkind) -> <pagebox> <markbox>

[]←StyleCommand[f, ".getfirstmark", GetFirstMark]; -- -> <pagebox> (markkind) -> <pagebox> <markbox>

[]←StyleCommand[f, ".columns", Columns]; -- -> <pagebox> .true . OR -> .false

[]←StyleCommand[f, ".shipout", ShipOut]; -- <box> -> . The box is sent out

[]←StyleCommand[f, ".documentname", DocumentName]; -- -> string .

[]←StyleCommand[f, ".textbox", TextBox]; -- string -> <box> . uses current font

[]←StyleCommand[f, ".textfont", TextFont]; -- fontnamestring fontpointsize -> . sets current font

[]←StyleCommand[f, ".vbox", Vbox]; -- <item1> <item2> ... <itemn> n -> <box> .

[]←StyleCommand[f, ".hbox", Hbox]; -- <item1> <item2> ... <itemn> n -> <box> .

[]←StyleCommand[f, ".vboxto", VboxTo]; -- <item1> <item2> ... <itemn> n height -> <box> .

[]←StyleCommand[f, ".hboxto", HboxTo]; -- <item1> <item2> ... <itemn> n height -> <box> .

[]←StyleCommand[f, ".fill", Fill]; -- -> <fillglue> .

[]←StyleCommand[f, ".dumpbox", DumpBox]; -- <box> -> .

[]←StyleCommand[f, ".exchbox", ExchBox]; -- <box1> <box2> -> <box2> <box1>

END;

END.

Michael Plass, September 1, 1982 9:21 pm: Put in calls to TSObject.DestroyReader.

Michael Plass, November 2, 1982 2:39 pm. Tioga formatted.

Michael Plass, November 12, 1982 10:11 am. pZone.

Michael Plass, November 16, 1982 2:36 pm. Changed to use some of the page layout parameters.

Michael Plass, November 17, 1982 9:34 am. Fixed frame and style stuff.

Michael Plass, November 17, 1982 11:13 am. Fixed bug that prevented .page from working after the end marker was sent.

Michael Plass, February 15, 1983 1:04 pm. Removed dependency on JaMTypeScript.

Rick Beach, May 17, 1983 10:17 am. Added .getmark routines., Rick

Edited on May 17, 1983 10:16 am, by Beach

Added .exchbox to permit a layout style to get a page, then get headers which must precede the page.

Edited on May 24, 1983 8:52 am, by Beach

Added MergeMarkLists to properly maintain a page history of marks., MergeMarkLists

Edited on January 10, 1984 9:33 am, by Plass

Added calls to TSWrecker.