Copyright © 1983, 1986 by Xerox Corporation. All rights reserved.

History

Atom,

CD,

CDBasics,

CDDefaultProcs,

CDEnvironment,

CDIO,

CDVArrow,

CDCurves,

CDOps,

CDPDPlot,

CDProperties,

CDPropertyTools,

CDSequencer,

CDValue,

Commander,

CStitching,

IO,

PeachPrint,

PDFileFormat,

PDFileWriter,

Process,

Real,

Rope,

RuntimeError USING [UNCAUGHT],

TerminalIO,

ViewerClasses,

ViewerSpecs;

IMPORTS Atom, CD, CDBasics, CDDefaultProcs, CDEnvironment, CDIO, CDValue, CDVArrow, CDOps, CDCurves, CDProperties, CDPropertyTools, CDSequencer, CGArea, CGClipper, CGReducer, Commander, CStitching, IO, PDFileWriter, PeachPrint, Process, Real, Rope, RuntimeError, TerminalIO

EXPORTS CDPDPlot =

ENABLE UNWIND => NULL;

BROADCAST retry; --to make others call CheckAborted

WHILE plottingInProgress DO

plottingInProgress ← TRUE

};

ENABLE UNWIND => NULL;

plottingInProgress ← FALSE;

BROADCAST retry

};

-- used to identify tiles without toner so that you can avoid recording them

-- used to identify tiles with full toner so that you can avoid recording them

--gives a key to get the keys to get the color stipple as property of the layers

ColorVersatec: PROC [dd: REF DeviceDesc] = {

InkJetC150: PROC [dd: REF DeviceDesc] = {

Color400: PROC [dd: REF DeviceDesc] = {

Puffin: PROC [dd: REF DeviceDesc] = {

PlateMaker: PROC [dd: REF DeviceDesc] = {

Raven384: PROC [dd: REF DeviceDesc] = {

dd ← NEW[DeviceDesc];

dd.contextFilter ← NEW[CD.ContextFilter←ALL[TRUE]];

SELECT key FROM

};

tes: ARRAY CD.Layer OF CStitching.Tesselation ← ALL[NIL],

plotScale: REAL ← 1.0, -- pixels per CD.Number

plotClip: CD.Rect ← [0, 0, 0, 0], --in design space touching all geometry in plot

stripeClip: CD.Rect ← [0, 0, 0, 0],--in design space touching all geometry in stripe

bandClip: CD.Rect ← [0, 0, 0, 0],--in design space touching all geometry in band

pdState: PDFileWriter.PDState,

colorLoads: REF ColorDescription,

anouncedLayer: INT ← -1,

design: CD.Design,

pdy: CARDINAL ← 0,  -- top of band in pixel coords

rightBound: INT 𡤀,

dd: REF DeviceDesc

];

--but not clipped!

RETURN [(cdX-ps.stripeClip.x1)*ps.plotScale]

};

--Remember that the sign bit changes !!

--but not clipped!

RETURN [(ps.stripeClip.y2-cdY)*ps.plotScale]

};

ps: PlotState;   

clipSize: CD.Position;

dd: REF DeviceDesc ← task.dd;

design: CD.Design ← task.design;

pageStep: CD.Position;

pageWidth: CD.Position;

dr: CD.DrawRef;

IF design=NIL OR dd=NIL THEN ERROR;

BEGIN

};

ps: PlotState = NARROW[pr.devicePrivate];

IF CDBasics.NonEmpty[r] AND ps.dd.contextFilter[l] THEN {

};

PrepareContextFilter: PROC [dd: REF DeviceDesc] = {

IF dd.stippleKey=NIL THEN {

IF technology.key#CDProperties.GetAtomProp[dd.stippleKey, lastTechPropKey] THEN {

WITH CDValue.Fetch[technology, dd.stippleKey] SELECT FROM

IF technology.key#CDProperties.GetAtomProp[dd.stippleKey, lastTechPropKey] THEN {

dd.tonerToKey ← NEW[TonerKeys ← ALL[NIL]];

FOR t: PDFileWriter.Toner IN PDFileWriter.Toner DO

PrepareContextFilter[dd];

};

MakeLoadref: PROC [pattern: REF ANY] RETURNS [loadRef: PDFileWriter.LoadReference] = TRUSTED {

MakeLoad: PROC [ps: PlotState, lev: CD.Layer] = INLINE {

--SetColor

IF ps.anouncedLayer=lev THEN RETURN;

IF ps.colorLoads^[lev]=NIL THEN MakeLoad[ps, lev];

FOR toner: Toner IN Toner DO

ps.anouncedLayer ← lev

};

OutputTrapezoid: PROC [xbotL: REAL, xbotR: REAL, ybot: REAL, xtopL: REAL, xtopR: REAL, ytop: REAL] = {

--PlotPolygon

pp: CDCurves.CurveSpecific = NARROW[ob.specific];

polygon: CGReducer.Ref = CGReducer.New[size: 8];

tiling: CGArea.Ref = CGArea.New[size: 4];

clipRef: CGClipper.Ref = CGClipper.New[size: 4];

clip: GraphicsBasic.Box ← [

CGClipper.SetBox[self: clipRef, box: clip];

CGClipper.Load[self: clipRef, reducer: polygon];

FOR p: LIST OF CD.Position ← pp.points, p.rest WHILE p#NIL DO

CGReducer.Close[polygon];

CGReducer.Generate[self: polygon, area: tiling];

UNTIL CGArea.Empty[tiling] DO

}; --PlotPolygon

IF CDCurves.IsPolygon[ob] THEN {

ELSE CDDefaultProcs.DrawContext[pr, proc, ob, trans, layer]

};

delta: INT = 8;--doesn't cause overflow, plot scale is limited

x1, x2, y1, y2: INT; --in device coords

ps: PlotState = NARROW[pr.devicePrivate];

IF bugIsStillThere THEN RETURN;

--restrict outline to be only slightly larger than device, to prevent arithmetic overflow

--convert to device pixel coordinates

--draw inclusive border pixels

};

FOR lev: CD.Layer IN CD.Layer DO

};

--coordinates in devices pixel coordinates;

--xStart = Real.Round[ToDeviceX[ps, r.x1]];

--yStop = Real.Round[ToDeviceY[ps, r.y1]]; swap 1-2 for y coords!

--xStop = Real.Round[ToDeviceX[ps, r.x2]];

--yStart = Real.Round[ToDeviceY[ps, r.y2]];

--prints including start pixels, excluding stop pixels

xStart ← MAX[xStart, 0];

xStop ← MIN[xStop, ps.rightBound];

yStart ← MAX[yStart, ps.pdy];

yStop ← MIN[yStop, ps.pdy+ps.dd.bandSSize, ps.dd.imageSSize];

IF yStop>yStart AND xStop>xStart THEN

};

IF tile.value=$covered THEN {

};

micronsPerInch: REAL ~ 25400;

specialScale: REAL ← -1; --means microns on plotted device per lambda

WITH CDProperties.GetAtomProp[task.dd.stippleKey, $CDxPDPlotScale] SELECT FROM

IF specialScale>0 THEN {

};

ENABLE error => {

clip: CD.Rect;

mustSendToDevice: BOOL ← FALSE;

server: Rope.ROPE; copies: INT ← 1;

task: REF TaskDesc ← NEW[TaskDesc ← [design: comm.design, abort: abortPlot, strips: 1]];

TerminalIO.PutRope["Color plot\n"];

task.dd ← MakeDevice[comm.key];

IF task.dd=NIL THEN {

TerminalIO.PutRopes[task.dd.name, "\n"];

SELECT TerminalIO.RequestSelection["PD Plot", LIST["plot complete design", "plot drawn rectangle", "specials, strips, servers..."]] FROM

IF clip.x1>=clip.x2 OR clip.y1>=clip.y2 THEN {

task.clip ← clip;

IF mustSendToDevice THEN

Plot[task];

IF mustSendToDevice THEN {

EXITS tobad => NULL

};

modifier: Rope.ROPE ← IF strips>1 THEN IO.PutFR["%d", IO.int[strip+1]] ELSE NIL;

IF Rope.IsEmpty[base] THEN base ← "PDPlot";

fileName ← CDIO.MakeName[wDir: "///temp/", base: base, modifier: modifier, ext: "pd"];

};

prio: Process.Priority = Process.GetPriority[];

IF ~plottingInProgress THEN {

Process.SetPriority[Process.priorityBackground];

WHILE plottingInProgress DO

Process.SetPriority[prio];

IO.PutRope[cmd.out, " finished\n"]

};

IF blackX#NIL THEN CDProperties.PutLayerProp[onto: l, prop: blackX, val: NIL];

IF cyanX#NIL THEN CDProperties.PutLayerProp[onto: l, prop: cyanX, val: NIL];

IF magentaX#NIL THEN CDProperties.PutLayerProp[onto: l, prop: magentaX, val: NIL];

IF yellowX#NIL THEN CDProperties.PutLayerProp[onto: l, prop: yellowX, val: NIL];

};

IF currTech#NIL THEN ERROR error;

CDPropertyTools.RemoveProperties[$CDxPDPlotScale];

CDPropertyTools.RemoveProperties[device];

CDProperties.PutAtomProp[device, $CDxPDPlotScale, NIL]; --might be not associated

IF b#NIL THEN CDPropertyTools.RemoveProperties[b];

IF c#NIL THEN CDPropertyTools.RemoveProperties[c];

IF m#NIL THEN CDPropertyTools.RemoveProperties[m];

IF y#NIL THEN CDPropertyTools.RemoveProperties[y];

currTech ← CD.FetchTechnology[tech];

blackX ← b;

cyanX ← c;

yellowX ← y;

magentaX ← m;

CDValue.Store[currTech, device, text];

IF invert THEN {

ELSE {

CDProperties.PutAtomProp[device, $CDxLastTechnology, currTech.key];

FOR l: CD.Layer IN CD.Layer DO Forgett[l] ENDLOOP;

};

currTech ← NIL

};

currLayer ← CD.FetchLayer[t: currTech, uniqueKey: uniqueKey];

Forgett[currLayer]

};

currLayer ← layer;

Forgett[currLayer]

};

CDProperties.PutLayerProp[onto: currLayer, prop: key, val: $ink]

};

CDProperties.PutLayerProp[onto: currLayer, prop: key,

};

CDProperties.PutLayerProp[onto: currLayer, prop: key,

};

CDPropertyTools.Associate[$CDxPDPlotScale, $CDxPDPlotScale];

tonerToKeyKeys[black] ← $CDxPDPlotBlack;

tonerToKeyKeys[cyan] ← $CDxPDPlotCyan;

tonerToKeyKeys[magenta] ← $CDxPDPlotMagenta;

tonerToKeyKeys[yellow] ← $CDxPDPlotYellow;

CDSequencer.ImplementCommand[key: $PDPlotVersatec, proc: PDColorPlotComm, queue: doQueue];

CDSequencer.ImplementCommand[key: $PDPlotC150, proc: PDColorPlotComm, queue: doQueue];

CDSequencer.ImplementCommand[key: $PDPlotColor400, proc: PDColorPlotComm, queue: doQueue];

CDSequencer.ImplementCommand[key: $PDPlotUserDevice, proc: PDColorPlotComm, queue: doQueue];

Commander.Register[

TerminalIO.PutRope["ChipNDale PD color plot program loaded\n"];

};