DIRECTORY
Char, Convert, FileNames, GGBasicTypes, GGCoreOps, GGCoreTypes, GGFont, GGFromImager, GGModelTypes, GGOutline, GGParseIn, GGScene, GGSegment, GGSegmentTypes, GGSlice, GGSliceOps, GGTraj, GGUtility, Imager, ImagerBackdoor, ImagerColor, ImagerDeviceVector, ImagerError, ImagerFont, ImagerInterpress, ImagerPath, ImagerPrivate, ImagerState, ImagerTransformation, ImagerTypeface, InterpressInterpreter, IO, Rope, SF, Vectors2d;

GGFromImagerImpl: CEDAR PROGRAM
IMPORTS Char, Convert, FileNames, GGCoreOps, GGFont, GGOutline, GGParseIn, GGScene, GGSegment, GGSlice, GGSliceOps, GGTraj, GGUtility, Imager, ImagerBackdoor, ImagerError, ImagerFont, ImagerInterpress, ImagerPath, ImagerState, ImagerTransformation, InterpressInterpreter, IO, Rope, Vectors2d
EXPORTS GGFromImager, Imager, ImagerFont = BEGIN

Camera: TYPE ~ GGModelTypes.Camera;
Class: TYPE ~ REF ClassRep;
ClassRep: PUBLIC TYPE ~ ImagerPrivate.ClassRep; -- export to Imager.ClassRep
Clipper: TYPE ~ ImagerBackdoor.Clipper;
Color: TYPE ~ Imager.Color;
ColorOperator: TYPE ~ Imager.ColorOperator;
Context: TYPE ~ Imager.Context;
CoordSys: TYPE ~ ImagerBackdoor.CoordSys;
Font: TYPE ~ ImagerFont.Font;
Object: TYPE ~ Imager.Object;
PathProc: TYPE ~ ImagerPath.PathProc;
PixelArray: TYPE ~ Imager.PixelArray;
PixelMap: TYPE ~ Imager.PixelMap;
Point: TYPE ~ GGBasicTypes.Point;
Rectangle: TYPE ~ Imager.Rectangle;
ROPE: TYPE ~ Rope.ROPE;
SampleMap: TYPE ~ Imager.SampleMap;
ScanMode: TYPE ~ ImagerTransformation.ScanMode;
Scene: TYPE ~ GGModelTypes.Scene;
SequenceOfReal: TYPE ~ REF SequenceOfRealObj;
SequenceOfRealObj: TYPE ~ GGCoreTypes.SequenceOfRealObj;
Slice: TYPE ~ GGModelTypes.Slice;
SliceParts: TYPE ~ GGModelTypes.SliceParts;
State: TYPE ~ REF StateRep;
StateRep: PUBLIC TYPE ~ ImagerState.StateRep;
StrokeEnd: TYPE ~ Imager.StrokeEnd;
StrokeJoint: TYPE ~ Imager.StrokeJoint;
Transformation: TYPE ~ ImagerTransformation.Transformation;
VEC: TYPE ~ Imager.VEC;
Visibility: TYPE ~ ImagerBackdoor.Visibility;
XChar: TYPE ~ ImagerFont.XChar;
XStringProc: TYPE ~ ImagerFont.XStringProc;

Data: TYPE ~ REF DataRep;
DataRep: TYPE ~ RECORD [
scene: Scene,
camera: Camera,
curOutline: Slice
];

Typeface: TYPE ~ REF TypefaceRep;
TypefaceRep: PUBLIC TYPE = ImagerTypeface.TypefaceRep; -- export to ImagerFont

WarningMessage: PUBLIC SIGNAL [context: Context, code: ATOM, message: ROPE] ~ CODE;

Create: PROC [camera: Camera] RETURNS [Context] ~ {
data: Data ~ NEW[DataRep ¬ [scene: GGScene.CreateScene[], camera: camera]];
state: State ~ ImagerState.CreateState[];
state.color ¬ Imager.black;
RETURN[NEW[Imager.ContextRep ¬ [class: gargoyleClass, state: state, data: data]]];
};

Capture: PUBLIC PROC [action: PROC [Context], camera: Camera] RETURNS [Scene] ~ {
context: Context ~ Create[camera];
action[context !
ImagerError.Warning => {
r: ROPE ~ IO.PutFR["code: %g, message: %g", [atom[ImagerError.AtomFromErrorCode[error.code]]], [rope[error.explanation]] ];
SIGNAL WarningMessage[context, $Capture, r];
RESUME;
};
];
WITH context.data SELECT FROM data: Data => RETURN [data.scene]; ENDCASE => ERROR;
};

ProcessStateChanges: PUBLIC PROC [context: Context] ~ {
state: State ~ context.state;
changed: ImagerState.ChangeFlags ~ state.changed;
state.changed ¬ ImagerState.notChanged;
IF changed.clipper AND state.clipper # NIL THEN SIGNAL WarningMessage[context, $Clipping, "NotImplemented: Clipping"];
};

RopeFromXStringProc: PROC [string: XStringProc] RETURNS [rope: ROPE ¬ NIL] ~ {
p: PROC [q: PROC [CHAR]] ~ {
currentSet: BYTE ¬ 0;
action: PROC [char: XChar] ~ {
set: BYTE ~ Char.Set[char];
IF set#currentSet THEN { q[VAL[255]]; q[VAL[currentSet ¬ set]] };
q[VAL[Char.Code[char]]];
};
string[action];
};
RETURN[Rope.FromChars[p]];
};

UnpackComplexFontName: PROC [fontName: Rope.ROPE] RETURNS [prefix, family, face: Rope.ROPE, fontSize: REAL] = {
DigitProc: IO.BreakProc = {
SELECT char FROM
IO.LF, IO.CR, IO.TAB, IO.SP => RETURN [break];
'0, '1, '2, '3, '4, '5, '6, '7, '8, '9 => RETURN [break];
ENDCASE => RETURN [other];
};
AlphaProc: IO.BreakProc = {
SELECT char FROM
IO.LF, IO.CR, IO.TAB, IO.SP => RETURN [break];
IN ['a .. 'z], IN ['A .. 'Z] => RETURN [break];
ENDCASE => RETURN [other];
};
new, sizeRope: Rope.ROPE;
prefix ¬ FileNames.Directory[path: fontName]; -- "xerox/*fonts/"
new ¬ FileNames.GetShortName[fontName]; -- get family "name"
face ¬ FileNames.Tail[new, '-]; -- get face component (MIR, BRR, ...)
IF Rope.Equal[face, new] THEN { -- have a name like Helvetica10I OR TERMINAL
endOfName: BOOL;
nameStream: IO.STREAM ¬ IO.RIS[new];
family ¬ IO.GetTokenRope[nameStream, DigitProc].token; -- get the leading alpha characters
sizeRope ¬ IO.GetTokenRope[nameStream, AlphaProc ! IO.EndOfStream, IO.Error => {endOfName ¬ TRUE; CONTINUE;};].token; -- get any digit characters
fontSize ¬ Convert.RealFromRope[sizeRope];
IF endOfName THEN face ¬ "" -- because face = new 
ELSE face ¬ Rope.Concat["-", GGParseIn.ReadWord[nameStream]];
}
ELSE { -- have a name like Helvetica-MIR
family ¬ Rope.Substr[base: new, start: 0, len: Rope.SkipTo[s: new, pos: 0, skip: "-"]]; -- throw away "-XXX"
face ¬ SELECT TRUE FROM
Rope.Equal[face, "MRR", FALSE] => "",
Rope.Equal[face, "BRR", FALSE] => "-B",
Rope.Equal[face, "Bold", FALSE] => "-B",
Rope.Equal[face, "MIR", FALSE] => "-I",
Rope.Equal[face, "Italic", FALSE] => "-I",
Rope.Equal[face, "BIR", FALSE] => "-BI",
ENDCASE => ERROR;
fontSize ¬ 1.0;
};
};

SetSegProperties: PROC [context: Context, m: Transformation, outlined: BOOL, seg: GGSegmentTypes.Segment] = {
strokeEnd: StrokeEnd;
strokeEnd ¬ VAL[NAT[context.state.np.strokeEnd]];
IF outlined THEN {
seg.strokeWidth ¬ Vectors2d.Magnitude[ImagerTransformation.TransformVec[m, [context.state.np.strokeWidth, 0.0] ] ];
seg.color ¬ IF ISTYPE[context.state.color, ImagerColor.ConstantColor] THEN context.state.color ELSE Imager.black;
seg.strokeEnd ¬ strokeEnd;
}
ELSE {
seg.strokeWidth ¬ 0.0;
seg.color ¬ NIL;
seg.strokeEnd ¬ round;
};
};

OutlineFromPath: PROC[context: Context, path: PathProc, m: Transformation, closed: BOOL, outlined: BOOL ¬ TRUE] RETURNS [GGModelTypes.Slice] ~ {
curOutline: GGModelTypes.Slice;
curTraj: GGModelTypes.Traj;
curSeg: GGSegmentTypes.Segment;
lp: VEC ¬ [0,0];
firstPoint: VEC ¬ [0,0];
Finish: PROC ~ {
IF curTraj # NIL THEN {
IF curSeg # NIL THEN {
IF closed THEN {
IF curSeg.hi = firstPoint THEN {
[] ¬ GGTraj.AddSegment[curTraj, hi, curSeg, lo];
GGTraj.CloseByDistorting[curTraj, hi];
}
ELSE {
[] ¬ GGTraj.AddSegment[curTraj, hi, curSeg, lo];
curSeg ¬ GGSegment.MakeLine[curSeg.hi, firstPoint, NIL];
SetSegProperties[context, m, outlined, curSeg];
GGTraj.CloseWithSegment[curTraj, curSeg, lo];
};
}
ELSE [] ¬ GGTraj.AddSegment[curTraj, hi, curSeg, lo];
}
ELSE { -- unlikely but legal case: Traj with a single point, no segment
[] ¬ GGTraj.AddSegment[curTraj, lo, GGSegment.MakeLine[[lp.x, lp.y], [lp.x, lp.y], NIL], lo];
};
curSeg ¬ NIL;
IF curOutline = NIL THEN curOutline ¬ GGOutline.CreateOutline[curTraj, NIL]
ELSE AppendChild[curOutline, curTraj];
curTraj ¬ NIL;
};
};
AppendChild: PROC [outline: Slice, child: Slice] = {
holyData: GGOutline.OutlineData ¬ NARROW[outline.data];
holyData.children ¬ GGUtility.AppendSliceList[holyData.children, LIST[child]];
child.parent ¬ outline;
GGTraj.SetTrajRole[child, hole];
};
Move: PROC [p: VEC] ~ {
Finish[];
curTraj ¬ GGTraj.CreateTraj[[p.x, p.y]];
firstPoint ¬ lp ¬ p;
};
Line: PROC [p1: VEC] ~ {
IF curSeg # NIL THEN [] ¬ GGTraj.AddSegment[curTraj, hi, curSeg, lo];
curSeg ¬ GGSegment.MakeLine[[lp.x, lp.y], [p1.x, p1.y], NIL];
SetSegProperties[context, m, outlined, curSeg];
lp ¬ p1;
};
Curve: PROC [p1, p2, p3: VEC] ~ {
IF curSeg # NIL THEN [] ¬ GGTraj.AddSegment[curTraj, hi, curSeg, lo];
curSeg ¬ GGSegment.MakeBezier[[lp.x, lp.y], [p1.x, p1.y], [p2.x, p2.y], [p3.x, p3.y], NIL];
SetSegProperties[context, m, outlined, curSeg];
lp ¬ p3;
};
Conic: PROC [p1, p2: VEC, r: REAL] ~ {
IF curSeg # NIL THEN [] ¬ GGTraj.AddSegment[curTraj, hi, curSeg, lo];
curSeg ¬ GGSegment.MakeConic[[lp.x, lp.y], [p1.x, p1.y], [p2.x, p2.y], r, NIL];
SetSegProperties[context, m, outlined, curSeg];
lp ¬ p2;
};
Arc: PROC [p1, p2: VEC] ~ {
IF curSeg # NIL THEN [] ¬ GGTraj.AddSegment[curTraj, hi, curSeg, lo];
curSeg ¬ GGSegment.MakeArc[[lp.x, lp.y], [p1.x, p1.y], [p2.x, p2.y], NIL];
SetSegProperties[context, m, outlined, curSeg];
lp ¬ p2;
};
ImagerPath.Transform[path, m, Move, Line, Curve, Conic, Arc];
Finish[];
GGSlice.KillBoundBox[curOutline];
RETURN [curOutline];
};

MyShow: PROC[context: Context, string: XStringProc, xrel: BOOL] = {
MyShowAux[context, RopeFromXStringProc[string], xrel];
};

MyShowText: PROC [context: Context, text: REF READONLY TEXT, start, len: NAT, xrel: BOOL] = {
rope: ROPE ~ IF len=NAT.LAST
THEN Rope.FromRefText[s: text, start: start] -- let len default
ELSE Rope.FromRefText[s: text, start: start, len: len];
MyShowAux[context, rope, xrel];
};

MyShowAux: PROC[context: Context, rope: Rope.ROPE, xrel: BOOL] = {
OPEN ImagerTransformation;
font: ImagerFont.Font ¬ context.class.GetFont[context];
escapement: VEC ¬ ImagerFont.RopeEscapement[font, rope];
camera: Camera ¬ NARROW[context.data, Data].camera;
IF context.state.np.noImage=0 THEN {
textSlice: GGModelTypes.Slice;
data: Data ¬ NARROW[context.data];
amplifySpace: REAL ¬ ImagerBackdoor.GetReal[context, $amplifySpace];
color: Imager.Color ¬ context.class.GetColor[context];
currentT: Transformation ¬ context.class.GetT[context];
currentPoint: Point ¬ context.class.GetCP[context, FALSE];
fontName: Rope.ROPE ¬ ImagerFont.Name[font];
fontData: GGFont.FontData ¬ GGFont.CreateFontData[]; -- ensure non-NIL fontData
fontData ¬ IF fontName # NIL THEN GGFont.ParseFontData[data: fontData, inStream: IO.RIS[fontName], literalP: TRUE ! GGFont.ParseError => CONTINUE;]
ELSE GGFont.FontDataFromNamelessFont[font];
fontData.transform ¬ Cat[Scale[fontData.storedSize], font.charToClient, Translate[currentPoint], currentT];
fontData.substituteOK ¬ TRUE; -- allow font substitution on file reads
textSlice ¬ GGSlice.MakeTextSlice[rope, color, camera.displayStyle, amplifySpace];
[] ¬ GGSlice.SetTextFontAndTransform[textSlice, fontData, NIL, NIL];
GGScene.AddSlice[data.scene, textSlice, -1];
};
ImagerState.StateSetXYRel[context, escapement];
};

MySetSampledColor: PUBLIC PROC [context: Context, pa: PixelArray, m: Transformation, colorOperator: ColorOperator] = {
ImagerState.StateSetSampledColor[context, pa, m, colorOperator];
};

MySetSampledBlack: PUBLIC PROC [context: Context, pa: PixelArray, m: Transformation, clear: BOOL] = {
ImagerState.StateSetSampledBlack[context, pa, m, clear];
};

MyShowBackward: PROC[context: Context, string: XStringProc] = {
SIGNAL WarningMessage[context, $MyShowBackward, "NotImplemented: ShowBackward"];
};

MyMaskFill: PROC[context: Context, path: PathProc, oddWrap: BOOL] = {
data: Data ~ NARROW[context.data];
state: State ~ context.state;
IF state.changed#ImagerState.notChanged THEN ProcessStateChanges[context];
IF context.state.np.noImage=0 THEN {
outline: GGModelTypes.Slice;
IF ImagerTransformation.CloseEnough[state.clientToDevice, identity]
THEN outline ¬ OutlineFromPath[context, path, NIL, TRUE, FALSE]
ELSE outline ¬ OutlineFromPath[context, path, state.clientToDevice, TRUE, FALSE];
IF outline = NIL THEN RETURN; -- MASKFILL with a null outline can occur in Interpress
GGOutline.SetWrapRule[outline, oddWrap];
GGSliceOps.SetFillColor[outline, NIL, GGCoreOps.CopyColor[state.color], $Set, NIL];
GGScene.AddSlice[data.scene, outline, -1];
data.curOutline ¬ outline;
};
};

ReplaceChild: PROC [outline: Slice, oldChild, newChild: Slice] = {
outlineData: GGOutline.OutlineData ¬ NARROW[outline.data];
beforeEnt, ent, afterEnt: LIST OF Slice;
found: BOOL ¬ FALSE;
[beforeEnt, ent, afterEnt, found] ¬ GGUtility.FindSliceAndNeighbors[oldChild, outlineData.children];
IF NOT found THEN ERROR;
IF beforeEnt = NIL THEN {
outlineData.children ¬ CONS[newChild, afterEnt];
}
ELSE {
beforeEnt.rest ¬ CONS[newChild, afterEnt];
};
newChild.parent ¬ outline;
GGTraj.SetTrajRole[newChild, GGTraj.GetTrajRole[oldChild]];
};

identity: ImagerTransformation.Transformation ¬ ImagerTransformation.Scale[1.0];
MyMaskStroke: PROC[context: Context, path: PathProc, closed: BOOL] ~ {
outline: GGModelTypes.Slice;
strokeJoint: StrokeJoint;
data: Data ~ NARROW[context.data];
state: State ~ context.state;
IF state.changed#ImagerState.notChanged THEN ProcessStateChanges[context];
IF context.state.np.noImage=0 THEN {
trajs: LIST OF Slice;
oldTraj: Slice;
IF ImagerTransformation.CloseEnough[state.clientToDevice, identity]
THEN outline ¬ OutlineFromPath[context, path, NIL, closed]
ELSE outline ¬ OutlineFromPath[context, path, state.clientToDevice, closed];
trajs ¬ GGOutline.TrajectoriesOfOutline[outline];
IF trajs.rest = NIL AND data.curOutline # NIL THEN {
oldTrajs: LIST OF Slice ¬ GGOutline.FindTrajShapeInOutline[trajs.first, data.curOutline];
oldTraj ¬ IF oldTrajs = NIL THEN NIL ELSE oldTrajs.first;
};
strokeJoint ¬ VAL[NAT[context.state.np.strokeJoint]];
IF oldTraj = NIL THEN {
GGSliceOps.SetFillColor[outline, NIL, NIL, $Set, NIL]; -- no fill color
GGSliceOps.SetStrokeJoint[outline, GGSliceOps.NewParts[outline, NIL, slice].parts, strokeJoint, NIL];
GGScene.AddSlice[data.scene, outline, -1];
}
ELSE {
ReplaceChild[data.curOutline, oldTraj, trajs.first];
GGSliceOps.SetStrokeJoint[trajs.first, GGSliceOps.NewParts[trajs.first, NIL, slice].parts, strokeJoint, NIL];
};
};
};

MyMaskDashedStroke: PROC[context: Context, path: PathProc, patternLen: NAT, pattern: PROC [NAT] RETURNS [REAL], offset, length: REAL] ~ {
outline: GGModelTypes.Slice;
strokeJoint: StrokeJoint;
data: Data ~ NARROW[context.data];
state: State ~ context.state;
patternSeq: SequenceOfReal ¬ NEW[SequenceOfRealObj[patternLen]];
IF state.changed#ImagerState.notChanged THEN ProcessStateChanges[context];
IF context.state.np.noImage=0 THEN {
completeParts: SliceParts;
IF ImagerTransformation.CloseEnough[state.clientToDevice, identity]
THEN outline ¬ OutlineFromPath[context, path, NIL, FALSE] -- to preserve arcs
ELSE outline ¬ OutlineFromPath[context, path, state.clientToDevice, FALSE];
completeParts ¬ GGSliceOps.NewParts[outline, NIL, slice].parts;
GGSliceOps.SetFillColor[outline, NIL, NIL, $Set, NIL]; -- no fill color
strokeJoint ¬ VAL[NAT[context.state.np.strokeJoint]];
GGSliceOps.SetStrokeJoint[outline, completeParts, strokeJoint, NIL];
FOR i: NAT IN [0..patternLen) DO
patternSeq[i] ¬ pattern[i];
ENDLOOP;
GGSliceOps.SetDashed[outline, completeParts, TRUE, patternSeq, offset, length, NIL];
GGScene.AddSlice[data.scene, outline, -1];
};
};

MyShowAndFixedXRel: PROC [context: Context, string: XStringProc, x: REAL] ~ {
SIGNAL WarningMessage[context, $ShowAndFixedXRel, "Not implemented: ShowAndFixedXRel"];
};

MyMaskRectangle: PROC[context: Context, r: Rectangle] ~ {
path: PathProc ~ {
moveTo[[r.x, r.y]]; lineTo[[r.x+r.w, r.y]];
lineTo[[r.x+r.w, r.y+r.h]]; lineTo[[r.x, r.y+r.h]]
}; 
MyMaskFill[context, path, FALSE];
};

MyMaskRectangleI: PROC[context: Context, x, y, w, h: INTEGER] ~ {
MyMaskRectangle[context, [x, y, w, h]];
};

MyMaskVector: PROC[context: Context, p1, p2: VEC] ~ {
path: PathProc ~ {moveTo[p1]; lineTo[p2]};
MyMaskStroke[context, path, FALSE];
};

MyMaskPixel: PROC[context: Context, pa: PixelArray] ~ {
DoMyMaskPixel: PROC [dc: Imager.Context] = {
Imager.MaskPixel[dc, pa];
};
data: Data ¬ NARROW[context.data];
boxSlice: Slice;
currentColor: Color;
currentT: ImagerTransformation.Transformation;

currentColor ¬ context.state.color;
currentT ¬ ImagerTransformation.Copy[context.state.clientToDevice];
boxSlice ¬ GGSlice.MakeBoxFromMaskPixel[pa, currentColor, NIL, currentT];
GGScene.AddSlice[data.scene, boxSlice, -1];
};

MyMaskBitmap: PROC[context: Context, bitmap: SampleMap, referencePoint: SF.Vec, scanMode: ScanMode, position: VEC] ~ {
DoMyMaskBits: PROC [dc: Imager.Context] = {
Imager.MaskBitmap[dc, bitmap, referencePoint, scanMode, position];
};
masterStream, outStream: IO.STREAM;
masterRope: Rope.ROPE;
data: Data ¬ NARROW[context.data];
ipRef: ImagerInterpress.Ref;
ipMaster: InterpressInterpreter.Master;
ipSlice: Slice;

outStream ¬ IO.ROS[];
ipRef ¬ ImagerInterpress.CreateFromStream[outStream, "Interpress/Xerox/3.0 "];
ImagerInterpress.DoPage[ipRef, DoMyMaskBits];
ImagerInterpress.Finish[ipRef];
masterRope ¬ IO.RopeFromROS[outStream];
masterStream ¬ IO.RIS[masterRope];
ipMaster ¬ InterpressInterpreter.FromStream[masterStream, NIL];
ipSlice ¬ GGSlice.MakeIPSliceFromMaster[ipMaster: ipMaster, router: NIL, includeByValue: TRUE]; -- KAP
GGScene.AddSlice[data.scene, ipSlice, -1];
};

MyDrawBitmap: PROC [context: Context, bitmap: SampleMap, referencePoint: SF.Vec, scanMode: ScanMode, position: VEC] ~ {
DoMyDrawBits: PROC [dc: Imager.Context] = {
Imager.MaskBitmap[dc, bitmap, referencePoint, scanMode, position];
};
masterStream, outStream: IO.STREAM;
masterRope: Rope.ROPE;
data: Data ¬ NARROW[context.data];
ipRef: ImagerInterpress.Ref;
ipMaster: InterpressInterpreter.Master;
ipSlice: Slice;

outStream ¬ IO.ROS[];
ipRef ¬ ImagerInterpress.CreateFromStream[outStream, "Interpress/Xerox/3.0 "];
ImagerInterpress.DoPage[ipRef, DoMyDrawBits];
ImagerInterpress.Finish[ipRef];
masterRope ¬ IO.RopeFromROS[outStream];
masterStream ¬ IO.RIS[masterRope];
ipMaster ¬ InterpressInterpreter.FromStream[masterStream, NIL];
ipSlice ¬ GGSlice.MakeIPSliceFromMaster[ipMaster: ipMaster, router: NIL, includeByValue: TRUE]; -- KAP
GGScene.AddSlice[data.scene, ipSlice, -1];
};

MyDrawPixels: PROC[context: Context, pixelMap: PixelMap, colorOperator: ColorOperator, referencePoint: SF.Vec, scanMode: ScanMode, position: VEC] ~ {
SIGNAL WarningMessage[context, $MyDrawPixels, "NotImplemented: DrawPixels"];
};

MyDoIfVisible: PROC[context: Context, r: Rectangle, action: PROC] ~ {
SIGNAL WarningMessage[context, $MyDoIfVisible, "NotImplemented: DoIfVisible"];
};

MyDoWithBuffer: PROC[context: Context, action: PROC, x, y, w, h: INTEGER, backgroundColor: Color] ~ {
SIGNAL WarningMessage[context, $MyDoWithBuffer, "NotImplemented: DoWithBuffer"];
};

MyDrawObject: PROC[context: Context, object: Object, position: VEC, interactive: BOOL] ~ {
SIGNAL WarningMessage[context, $MyDrawObject, "NotImplemented: DrawObject:"];
};

MyGetBounds: PROC [context: Context] RETURNS [Rectangle] ~ {
ERROR ImagerError.Error[[unimplemented, "NotImplemented: GetBounds"]]
};

MyViewReset: PROC[context: Context] ~ {
SIGNAL WarningMessage[context, $MyViewReset, "NotImplemented: ViewReset"];
};

MyViewTranslateI: PROC[context: Context, x, y: INTEGER] ~ {
SIGNAL WarningMessage[context, $MyViewTranslateI, "NotImplemented: ViewTranslateI"];
};

MyViewClip: PROC[context: Context, path: PathProc, oddWrap: BOOL, exclude: BOOL] ~ {
SIGNAL WarningMessage[context, $MyViewClip, "NotImplemented: ViewClip"];
};

MyViewClipRectangleI: PROC[context: Context, x, y, w, h: INTEGER, exclude: BOOL] ~ {
SIGNAL WarningMessage[context, $MyViewClipRectangleI, "NotImplemented: ViewClipRectangleI"];
};

MyGetTransformation: PROC[context: Context, from, to: CoordSys] RETURNS [Transformation] ~ {
state: State ¬ context.state;
m: Transformation ¬ NIL;
SELECT to FROM
client => m ¬ ImagerTransformation.Copy[state.clientToDevice];
view => m ¬ ImagerTransformation.Scale[1.0];
surface => m ¬ ImagerTransformation.Scale[1.0];
device => m ¬ ImagerTransformation.Scale[1.0];
ENDCASE => ERROR;
ImagerTransformation.ApplyInvert[m];
SELECT from FROM
client => ImagerTransformation.ApplyPreConcat[m: m, p: state.clientToDevice];
view => NULL;
surface => NULL;
device => NULL;
ENDCASE => ERROR;
RETURN [m]
};

MyTransform: PROC[context: Context, v: VEC, from, to: CoordSys, vec: BOOL] RETURNS [VEC]  ~ {
SIGNAL WarningMessage[context, $MyTransform, "NotImplemented: Transform"];
RETURN[[0,0]];
};

MyMoveViewRectangle: PROC[context: Context, width, height, fromX, fromY, toX, toY: INTEGER] ~ {
SIGNAL WarningMessage[context, $MyMoveViewRectangle, "NotImplemented: MoveViewRectangle"];
};

MyTestViewRectangle: PROC[context: Context, x, y, w, h: INTEGER] RETURNS [Visibility] ~ {
SIGNAL WarningMessage[context, $MyTestViewRectangle, "NotImplemented: TestViewRectangle"];
RETURN[all]
};

gargoyleClass: Class ~ NEW[ClassRep ¬ [
type: $Gargoyle,
Save: ImagerState.StateSave,
Restore: ImagerState.StateRestore,
SetInt: ImagerState.StateSetInt,
SetReal: ImagerState.StateSetReal,
SetT: ImagerState.StateSetT,
SetFont: ImagerState.StateSetFont,
SetColor: ImagerState.StateSetColor,
SetClipper: ImagerState.StateSetClipper,
GetInt: ImagerState.StateGetInt,
GetReal: ImagerState.StateGetReal,
GetT: ImagerState.StateGetT,
GetFont: ImagerState.StateGetFont,
GetColor: ImagerState.StateGetColor,
GetClipper: ImagerState.StateGetClipper,
ConcatT: ImagerState.StateConcatT,
Scale2T: ImagerState.StateScale2T,
RotateT: ImagerState.StateRotateT,
TranslateT: ImagerState.StateTranslateT,
Move: ImagerState.StateMove,
SetXY: ImagerState.StateSetXY,
SetXYRel: ImagerState.StateSetXYRel,
Show: MyShow,
ShowText: MyShowText,
StartUnderline: ImagerState.StateStartUnderline,
MaskUnderline: ImagerState.StateMaskUnderline,
CorrectMask: ImagerState.StateCorrectMask,
CorrectSpace: ImagerState.StateCorrectSpace,
Space: ImagerState.StateSpace,
SetCorrectMeasure: ImagerState.StateSetCorrectMeasure,
SetCorrectTolerance: ImagerState.StateSetCorrectTolerance,
Correct: ImagerState.StateCorrect,
DontCorrect: ImagerState.StateDontCorrect,
SetGray: ImagerState.StateSetGray,
SetSampledColor: ImagerState.StateSetSampledColor,
SetSampledBlack: ImagerState.StateSetSampledBlack,
ShowBackward: MyShowBackward,
MaskFill: MyMaskFill,
MaskStroke: MyMaskStroke,
ShowAndFixedXRel: MyShowAndFixedXRel,
MaskDashedStroke: MyMaskDashedStroke,
MaskRectangle: MyMaskRectangle,
MaskRectangleI: MyMaskRectangleI,
MaskVector: MyMaskVector,
MaskPixel: MyMaskPixel,
MaskBitmap: MyMaskBitmap,
DrawBitmap: MyDrawBitmap,
DrawPixels: MyDrawPixels,
DoIfVisible: MyDoIfVisible,
DoWithBuffer: MyDoWithBuffer,
DrawObject: MyDrawObject,
Clip: ImagerState.StateClip,
ClipRectangle: ImagerState.StateClipRectangle,
ClipRectangleI: ImagerState.StateClipRectangleI,
GetCP: ImagerState.StateGetCP,
GetBounds: MyGetBounds,
ViewReset: MyViewReset,
ViewTranslateI: MyViewTranslateI,
ViewClip: MyViewClip,
ViewClipRectangleI: MyViewClipRectangleI,
GetTransformation: MyGetTransformation,
Transform: MyTransform,
MoveViewRectangle: MyMoveViewRectangle,
TestViewRectangle: MyTestViewRectangle,
propList: NIL
]];

END.
~GGFromImagerImpl.mesa
Contents: Routines for building Gargoyle objects from Interpres.
Copyright Σ 1985, 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.
Michael Plass, September 18, 1989 11:14:22 am PDT
Bier, November 30, 1992 5:38 pm PST
Pier, June 16, 1992 1:07 pm PDT
Doug Wyatt, April 17, 1992 1:51 pm PDT

Viewer: TYPE ~ ViewerClasses.Viewer;
feedback: Viewer,
Takes a complex name like "xerox/pressfonts/Helvetica-MIR" and a font size and returns components.
May already have a simple name like xerox/tiogafonts/Helvetica10I.  KAP August 8, 1986
A kludge for the moment to avoid segments with sampled colors
ELSE curOutline _ GGOutline.AddChild[curOutline, curTraj];
ASSERT: this code can modify curOutline because it owns it.  This is a big win.
What a crock... in PCedar the len argument is a NAT15, which is smaller than NAT!
SIGNAL WarningMessage[context, $MaskBitmap, "NotImplemented: MaskBitmap"];
ipSlice _ GGSlice.MakeIPSliceFromMaster[ipMaster, NIL, NIL, NIL, TRUE];
SIGNAL WarningMessage[context, $DrawBits, "NotImplemented: DrawBits"];
ipSlice _ GGSlice.MakeIPSliceFromMaster[ipMaster, NIL, NIL, NIL, TRUE];
Κ•NewlineDelimiter

–
(cedarcode) style˜
code™K™@Kšœ
Οe
œI™TKš
œ1™1K™#K™K™&K™—š
Οk	˜	Kšœžœžœ˜§K˜—šΟnœžœ
ž˜Kšžœ‰žœ˜£Kšžœ$ž˜0—˜Kšœžœ˜#Kšœžœžœ
˜Kšœ
žœ
žœΟc˜LKšœ	žœ˜'Kšœžœ˜Kšœžœ˜+Kšœ	žœ˜Kšœ
žœ˜)Kšœžœ˜Kšœžœ˜Kšœ
žœ˜%Kšœžœ˜%Kšœ
žœ˜!Kšœžœ˜!Kšœžœ˜#Kšžœžœžœ
˜Kšœžœ˜#Kšœ
žœ!˜/Kšœžœ˜!Kšœžœžœ˜-Kšœžœ!˜8Kšœžœ˜!Kšœžœ˜+Kšœžœžœ
˜Kšœ
žœ
žœ˜-Kšœžœ˜#Kšœ
žœ˜'Kšœžœ'˜;Kšžœžœ
žœ
˜Kšœžœ™$Kšœžœ˜-Kšœžœ˜šœ
žœ˜+K˜—Kšœžœžœ	˜šœ	žœžœ˜Kš
œ
˜
K˜K™K˜Kš
œ˜K˜—Kšœ
žœžœ
˜!Kšœ
žœ
žœ ˜N—K˜KšŸœžœ
žœžœžœžœ
˜SK˜šŸœžœžœ˜3Kšœ
žœ;˜KKš
œ)˜)K˜Kšžœ
žœH˜RKš
œ˜K˜—š
Ÿœžœ
žœ
žœžœ˜QKš
œ"˜"˜˜Kšœžœžœo˜{Kšžœ&˜,Kšžœ
˜Kš
œ˜—Kš
œ˜—Kšžœžœ
žœžœžœžœ
˜RKš
œ˜K˜—šŸœžœ
žœ˜7Kš
œ˜K˜1K˜'Kš
žœžœžœ
žœ
žœ@˜vK˜K˜—š
Ÿœžœžœžœžœ˜Nšœžœžœžœ˜Kšœžœ˜šœžœ˜Kšœžœ˜Kšžœžœžœ
žœ˜AKšœžœ˜K˜—Kš
œ˜K˜—Kšžœ˜Kš
œ˜K˜—šŸœžœžœžœžœžœ˜oKš
œb™bKšœDžœ™VšŸ	œžœ˜
procšžœž˜Lšžœ
žœžœ
žœžœ
žœžœ
žœžœ	˜.Lšœ*žœ	˜9Lšžœžœ	˜—K˜—šŸ	œžœ˜šžœž˜Lšžœ
žœžœ
žœžœ
žœžœ
žœžœ	˜.Lšžœ
žœžœ	˜/Lšžœžœ	˜—K˜—Kšœžœ
˜K•StartOfExpansion[path: 
ROPE]šœ. ˜@Kšœ( ˜<Kšœ  %˜Ešžœžœ ,˜LKšœžœ
˜Kš	œžœ
žœžœ
žœ˜$Kšœ	žœ, #˜ZKšœžœ&žœžœžœžœ ˜‘
K˜*Kšžœžœ ˜2Kšžœ9˜=K˜
—–)[s: 
ROPE, pos: 
INT _ 0, skip: 
ROPE]šžœ !˜(KšœX ˜lšœžœ
žœ
ž˜Kšœžœ˜%Kšœžœ
˜'Kšœžœ
˜(Kšœžœ
˜'Kšœžœ
˜*Kšœžœ˜(—Kšžœžœ
˜K˜K˜—K˜K˜—šŸœžœ1žœ"˜mK™=K˜Kšœžœ
žœ˜1šžœ
žœ˜K˜sKš	œžœ
žœ1žœžœ˜qK˜K˜
—šžœ˜K˜Kšœžœ
˜K˜K˜—K˜K˜—šŸœžœ>žœžœžœžœ˜
Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ	˜Kšœžœ	˜šŸœžœ˜šžœžœ
žœ˜šžœ
žœ
žœ˜šžœžœ˜šžœžœ˜ K˜0Kš
œ&˜&K˜
—šžœ˜K˜0Kšœ3žœ˜8Kš
œ/˜/Kš
œ-˜-K˜—K˜
—Kšžœ1˜5Kš
œ
˜
—šžœ @˜GKšœSžœ˜]Kš
œ˜—Kšœ	žœ
˜
Kšžœžœ
žœ/žœ
˜KKšžœ6™:Kš
œO™OKšžœ"˜&Kšœ
žœ
˜Kš
œ˜—Kš
œ˜—šŸœžœ#˜4Kšœ"žœ˜7KšœAžœ	˜NK˜Kš
œ ˜ K˜—šŸœžœžœ˜Kš
œ	˜	K˜(K˜Kš
œ˜—šŸœžœžœ˜Kšžœ
žœ
žœ1˜EKšœ8žœ˜=Kš
œ/˜/K˜Kš
œ˜—šŸœžœžœ˜!Kšžœ
žœ
žœ1˜EKšœVžœ˜[Kš
œ/˜/K˜Kš
œ˜—šŸœžœ
žœžœ˜&Kšžœ
žœ
žœ1˜EKšœJžœ˜OKš
œ/˜/K˜Kš
œ˜—šŸœžœ
žœ˜Kšžœ
žœ
žœ1˜EKšœEžœ˜JKš
œ/˜/K˜Kš
œ˜—Kš
œ=˜=Kš
œ	˜	Kš
œ!˜!Kšžœ˜Kš
œ˜K˜—šŸœžœ.žœ˜CKš
œ6˜6K˜K˜—šŸ
œžœžœ
žœ
žœžœžœ˜]šœžœžœžœ
ž˜Kšžœ) ˜?Kšžœ3˜7Kšœ0žœžœ
™Q—Kš
œ˜K˜K˜—šŸ	œžœžœžœ˜BKšžœ˜K˜7Kšœžœ)˜8Kšœžœ˜3šžœžœ˜$Kš
œ˜Kšœ
žœ˜"Kšœžœ2˜DK˜6K˜7Kšœ3žœ˜:Kšœžœ˜,Kšœ5 ˜OKšœžœžœ
žœ0žœ
žœžœžœ˜“
Kšžœ'˜+K˜kK–T[m: 
ImagerTransformation.Transformation, n: 
ImagerTransformation.Transformation]šœžœ (˜FK˜RKšœ:žœžœ˜DKš
œ,˜,K˜—K–%[context: 
Imager.Context, v: 
VEC]š
œ/˜/Kš
œ˜K˜—šŸœžœ
žœX˜vKš
œ@˜@K˜K˜—šŸœžœ
žœ>žœ˜eKš
œ8˜8K˜K˜—šŸœžœ+˜?KšžœJ˜PK˜K˜—šŸ
œžœ,žœ˜EKšœ
žœ˜"Kš
œ˜Kšžœ&žœ˜Jšžœžœ˜$Kš
œ˜šžœA˜CKšžœ*žœžœžœ
˜?Kšžœ@žœžœ˜Q—Kš	žœžœ
žœ
žœ 7˜UKš
Οb(˜(Kšœ!žœ*žœ˜SKš
œ*˜*K˜Kš
œ˜—Kš
œ˜K˜—šŸœžœ0˜BKšœ%žœ˜:Kšœžœ
žœ˜(Kšœžœžœ
˜K˜dKšžœ
žœžœ
žœ
˜šžœ
žœ
žœ˜Kšœžœ˜0K˜
—šžœ˜Kšœžœ˜*K˜—K˜Kš
œ;˜;K˜K˜—K˜PšŸœžœ+žœ˜FKš
œ˜K˜Kšœ
žœ˜"Kš
œ˜Kšžœ&žœ˜Jšžœžœ˜$Kšœžœ
žœ˜Kš
œ˜šžœA˜CKšžœ*žœ	˜:KšžœH˜L—K˜1š
žœžœ
žœžœ
žœ˜4Kšœ
žœ
žœH˜YKšœ
žœžœ
žœ
žœ
žœ˜9K˜—Kšœžœ
žœ ˜5šžœžœ
žœ˜Kšœ!žœžœžœ ˜GKšœ@žœžœ˜eKš
œ*˜*K˜
—šžœ˜Kš
œ4˜4KšœHžœžœ˜mK˜—Kš
œ˜—Kš
œ˜K˜—šŸœžœ/žœžœžœžœžœžœ˜‰
Kš
œ˜K˜Kšœ
žœ˜"Kš
œ˜Kšœžœ ˜@Kšžœ&žœ˜Jšžœžœ˜$Kš
œ˜šžœA˜CKšžœ*žœžœ ˜MKšžœ@žœ˜K—Kšœ-žœ˜?Kšœ!žœžœžœ ˜GKšœžœ
žœ ˜5Kšœ?žœ˜Dšžœžœ
žœž˜ K˜Kšžœ
˜—Kšœ-žœžœ˜TKš
œ*˜*Kš
œ˜—Kš
œ˜K˜—šŸœžœ,žœ˜MKšžœQ˜WK˜K˜—šŸœžœ$˜9š
œ˜Kš
œ+˜+Kš
œ2˜2Kš
œ˜—Kšœžœ˜!Kš
œ˜K˜—šŸœžœžœ˜AKš
œ'˜'Kš
œ˜K˜—šŸœžœžœ˜5Kš
œ*˜*Kšœžœ˜#Kš
œ˜K˜—šŸœžœ&˜7šŸ
œžœ˜,Kš
œ˜K˜—Kšœ
žœ˜"Kš
œ˜K˜Kš
œ.˜.K˜K˜#K˜CKšœ:žœ˜IKš
œ+˜+Kš
œ˜K˜—šŸœžœ6žœ$žœ˜všŸœžœ˜+Kš
œB˜BK˜—Kšœžœ
žœ
˜#Kšœžœ
˜Kšœ
žœ˜"Kš
œ˜K˜'K˜K˜KšžœD™JK–’
[context: 
Imager.Context, base: 
LONG POINTER, wordsPerLine: 
NAT, sMin: 
NAT, fMin: 
NAT, sSize: 
NAT, fSize: 
NAT, tx: 
INTEGER _ 0, ty: 
INTEGER _ 0]šœžœ
žœ˜K˜NKš
œ-˜-Kš
œ˜Kšœ
žœ˜'Kšœžœ
žœ
˜"Kšœ:žœ˜?Kš	œ2žœžœžœžœ™GKšœDžœžœ ˜fKš
œ*˜*Kš
œ˜K˜—šŸœžœ7žœ$žœ˜wšŸœžœ˜+Kš
œB˜BK˜—Kšœžœ
žœ
˜#Kšœžœ
˜Kšœ
žœ˜"Kš
œ˜K˜'K˜K˜Kšžœ@™FK–’
[context: 
Imager.Context, base: 
LONG POINTER, wordsPerLine: 
NAT, sMin: 
NAT, fMin: 
NAT, sSize: 
NAT, fSize: 
NAT, tx: 
INTEGER _ 0, ty: 
INTEGER _ 0]šœžœ
žœ˜K˜NKš
œ-˜-Kš
œ˜Kšœ
žœ˜'Kšœžœ
žœ
˜"Kšœ:žœ˜?Kš	œ2žœžœžœžœ™GKšœDžœžœ ˜fKš
œ*˜*Kš
œ˜K˜—šŸœžœUžœ$žœ˜•
KšžœF˜LK˜K˜—šŸ
œžœ)žœ˜EKšžœH˜NK˜K˜—šŸœžœžœžœ˜eKšžœJ˜PK˜K˜—šŸœžœ-žœžœ˜ZKšžœG˜MK˜K˜—šŸœžœžœ˜<Kšžœ@˜EKš
œ˜K˜—šŸœžœ˜'KšžœD˜JK˜K˜—šŸœžœžœ˜;KšžœN˜TK˜K˜—šŸ
œžœ,žœžœ˜TKšžœB˜HK˜K˜—šŸœžœžœžœ˜TKšžœV˜\K˜K˜—šŸœžœ'žœ˜\K˜Kšœžœ
˜šžœž˜K˜>K˜,K˜/K˜.Kšžœžœ
˜—Kš
œ$˜$šžœž˜Kš
œM˜MKšœžœ
˜
Kšœžœ
˜Kšœ
žœ
˜Kšžœžœ
˜—Kšžœ˜
K˜K˜—šŸœžœžœžœžœžœ˜]KšžœD˜JKšžœ˜K˜K˜—šŸœžœ:žœ˜_KšžœT˜ZK˜K˜—šŸœžœžœžœ˜YKšžœT˜ZKšžœ˜K˜—K˜šœžœ
˜'Kš
œ˜KšŸœ˜KšŸœ˜"KšŸœ˜ KšŸœ˜"KšŸœ˜KšŸœ˜"KšŸœ˜$KšŸ
œ˜(KšŸœ˜ KšŸœ˜"KšŸœ˜KšŸœ˜"KšŸœ˜$KšŸ
œ˜(KšŸœ˜"KšŸœ˜"KšŸœ˜"KšŸ
œ˜(KšŸœ˜KšŸœ˜KšŸœ˜$KšŸœ	˜
KšŸœ
˜KšŸœ"˜0KšŸ
œ!˜.KšŸœ˜*KšŸœ ˜,KšŸœ˜KšŸœ%˜6KšŸœ'˜:KšŸœ˜"KšŸœ˜*KšŸœ˜"KšŸœ#˜2KšŸœ#˜2KšŸœ˜KšŸœ
˜KšŸ
œ˜KšŸœ˜%KšŸœ˜%KšŸ
œ˜KšŸœ˜!KšŸ
œ˜KšŸ	œ˜KšŸ
œ˜KšŸ
œ˜KšŸ
œ˜KšŸœ˜KšŸœ˜KšŸ
œ˜KšŸœ˜KšŸ
œ!˜.KšŸœ"˜0KšŸœ˜KšŸ	œ˜KšŸ	œ˜KšŸœ˜!KšŸœ
˜KšŸœ˜)KšŸœ˜'KšŸ	œ˜KšŸœ˜'KšŸœ˜'Kšœ
ž˜
K˜—K˜Kšžœ
˜—…—Wtž