DIRECTORY
Font USING [FONT, Name, RequestedTransformation],
NewImager USING [Class, ClassRep, Context, Error],
ImagerBasic USING [Color, ConstantColor, IntPair, IntRectangle, Pair, PathMapType, PixelArray, StrokeEnd, Transformation, Visibility],
ImagerTransform USING [Contents, TransformationRec],
IPOutput,
RefText USING [TrustTextAsRope],
Rope USING [FromChar, ROPE, Substr];

ImagerIPImpl: CEDAR PROGRAM
IMPORTS Font, Imager: NewImager, ImagerTransform, IPOutput, RefText, Rope
~ BEGIN OPEN ImagerBasic;

ROPE: TYPE ~ Rope.ROPE;

Context: TYPE ~ Imager.Context;
FONT: TYPE ~ Font.FONT;
Name: TYPE ~ ImagerPrivate.Name;
TransformationRec: TYPE ~ ImagerTransform.TransformationRec;
Master: TYPE ~ IPOutput.Master;

Init: PROC[context: Context, info: REF] ~ {
master: Master ~ IPOutput.Narrow[info];
context.data _ master;
};

GetMaster: PROC[context: Context] RETURNS[Master] ~ INLINE {
RETURN[IPOutput.Narrow[context.data]];
};

Get: PROC[context: Context, key: Variable] RETURNS[REF] ~ {
ERROR Imager.Error[$Unimplemented];
};

GetReal: PROC[context: Context, key: Variable] RETURNS[REAL] ~ {
ERROR Imager.Error[$Unimplemented];
};

GetInt: PROC[context: Context, key: Variable] RETURNS[INT] ~ {
ERROR Imager.Error[$Unimplemented];
};

Set: PROC[context: Context, key: Variable, value: REF] ~ {
master: Master ~ GetMaster[context];
SELECT key FROM
$T => ERROR Imager.Error[$Unimplemented];
$showVec => SELECT value FROM
font: FONT => SetFont[master, font];
ENDCASE => ERROR Imager.Error[$WrongType];
$color => SELECT value FROM
color: Color => SetColor[master, color];
ENDCASE => ERROR Imager.Error[$WrongType];
$clipper => ERROR Imager.Error[$Unimplemented];
ENDCASE => ERROR Imager.Error[$WrongType];
};

SetFont: PROC[master: Master, font: FONT] ~ {
name: ROPE ~ font.Name[];
m: TransformationRec ~ font.RequestedTransformation[].Contents[];
master.FindFont[name];
master.MakeT[m.a, m.b, m.c, m.d, m.e, m.f];
master.ModifyFont[];
master.ISet[$showVec];
};

SetColor: PROC[master: Master, color: Color] ~ {
WITH color SELECT FROM
c: ConstantColor => WITH c SELECT FROM
c: GrayConstantColor => master.SetGray[c.f];
c: CIEConstantColor => {
master.SetGray[1.0-(REAL[c.Y]/REAL[CARDINAL.LAST])];
};
ENDCASE => ERROR Imager.Error[$Unimplemented];
c: SampledColor => ERROR Imager.Error[$Unimplemented];
ENDCASE => ERROR Imager.Error[$Bug];
};

SetReal: PROC[context: Context, key: Variable, value: REAL] ~ {
master: Master ~ GetMaster[context];
SELECT key FROM
$DCScpx => ERROR Imager.Error[$Unimplemented];
$DCScpy => ERROR Imager.Error[$Unimplemented];
$correctMX => ERROR Imager.Error[$Unimplemented];
$correctMY => ERROR Imager.Error[$Unimplemented];
$mediumXSize => ERROR Imager.Error[$Unimplemented];
$mediumYSize => ERROR Imager.Error[$Unimplemented];
$fieldXMin => ERROR Imager.Error[$Unimplemented];
$fieldYMin => ERROR Imager.Error[$Unimplemented];
$fieldXMax => ERROR Imager.Error[$Unimplemented];
$fieldYMax => ERROR Imager.Error[$Unimplemented];
$strokeWidth => { master.PutReal[value]; master.ISet[$strokeWidth] };
$underlineStart => ERROR Imager.Error[$Unimplemented];
$amplifySpace => { master.PutReal[value]; master.ISet[$amplifySpace] };
$correctShrink => { master.PutReal[value]; master.ISet[$correctShrink] };
$correctTX => ERROR Imager.Error[$Unimplemented];
$correctTY => ERROR Imager.Error[$Unimplemented];
ENDCASE => ERROR Imager.Error[$WrongType];
};

SetInt: PROC[context: Context, key: Variable, value: INT] ~ {
master: Master ~ GetMaster[context];
SELECT key FROM
$priorityImportant => { master.PutInt[value]; master.ISet[$priorityImportant] };
$noImage => { master.PutInt[value]; master.ISet[$noImage] };
$strokeEnd => { master.PutInt[value]; master.ISet[$strokeEnd] };
$correctPass => ERROR Imager.Error[$Unimplemented];
ENDCASE => ERROR Imager.Error[$WrongType];
};

SetSampledColor: PROC[context: Context, pa: PixelArray, pixelT: Transformation, colorOperator: ATOM] ~ {
ERROR Imager.Error[$Unimplemented];
};

SetSampledBlack: PROC[context: Context, pa: PixelArray, pixelT: Transformation, transparent: BOOLEAN] ~ {
ERROR Imager.Error[$Unimplemented];
};

DoSave: PROC[context: Context, body: PROC] ~ {
master: Master ~ GetMaster[context];
master.BeginDoSaveSimpleBody[];
body[];
master.EndDoSaveSimpleBody[];
};

DoSaveAll: PROC[context: Context, body: PROC] ~ {
master: Master ~ GetMaster[context];
master.BeginMakeSimpleCO[];
body[];
master.EndMakeSimpleCO[];
master.DoSaveAll[];
};

ConcatT: PROC[context: Context, m: Transformation] ~ {
master: Master ~ GetMaster[context];
master.MakeT[m.a, m.b, m.c, m.d, m.e, m.f];
master.ConcatT[];
};

ScaleT: PROC[context: Context, s: REAL] ~ {
master: Master ~ GetMaster[context];
master.Scale[s]; master.ConcatT[];
};

Scale2T: PROC[context: Context, sx, sy: REAL] ~ {
master: Master ~ GetMaster[context];
master.Scale2[sx, sy]; master.ConcatT[];
};

RotateT: PROC[context: Context, a: REAL] ~ {
master: Master ~ GetMaster[context];
master.Rotate[a]; master.ConcatT[];
};

TranslateT: PROC[context: Context, x, y: REAL] ~ {
master: Master ~ GetMaster[context];
master.Translate[x, y]; master.ConcatT[];
};

Move: PROC[context: Context] ~ {
master: Master ~ GetMaster[context];
master.Move[];
};

Trans: PROC[context: Context] ~ {
master: Master ~ GetMaster[context];
master.Trans[];
};

SetXY: PROC[context: Context, x, y: REAL] ~ {
master: Master ~ GetMaster[context];
master.SetXY[x, y];
};

SetXYI: PROC[context: Context, x, y: INTEGER] ~ {
master: Master ~ GetMaster[context];
master.SetXY[x, y];
};

SetXYRel: PROC[context: Context, x, y: REAL] ~ {
master: Master ~ GetMaster[context];
IF y=0 THEN master.SetXRel[x]
ELSE IF x=0 THEN master.SetYRel[y]
ELSE master.SetXYRel[x, y];
};

SetXYRelI: PROC[context: Context, x, y: INTEGER] ~ {
master: Master ~ GetMaster[context];
IF y=0 THEN master.SetXRel[x]
ELSE IF x=0 THEN master.SetYRel[y]
ELSE master.SetXYRel[x, y];
};

DoTrajectories: PROC[master: Master, pathProc: PathProc, pathData: REF,
action: PROC[Master]] ~ {
started: BOOL _ FALSE;
lx, ly: REAL _ 0;
moveTo: PROC[x, y: REAL] ~ {
IF started THEN action[master] ELSE started _ TRUE;
master.MoveTo[lx _ x, ly _ y];
};
lineTo: PROC[x, y: REAL] ~ {
IF y=ly THEN master.LineToX[lx _ x]
ELSE IF x=lx THEN master.LineToY[ly _ y]
ELSE master.LineTo[lx _ x, ly _ y];
};
curveTo: PROC[x1, y1, x2, y2, x3, y3: REAL] ~ {
master.CurveTo[x1, y1, x2, y2, lx _ x3, ly _ y3];
};
conicTo: PROC[x1, y1, x2, y2: REAL, r: REAL] ~ {
master.ConicTo[x1, y1, lx _ x2, ly _ y2, r];
};
arcTo: PROC[x1, y1, x2, y2: REAL] ~ {
master.ArcTo[x1, y1, lx _ x2, ly _ y2];
};
pathProc[pathData, moveTo, lineTo, curveTo, conicTo, arcTo];
IF started THEN action[master];
};

MaskFill: PROC[context: Context, pathProc: PathProc, pathData: REF] ~ {
master: Master ~ GetMaster[context];
n: INT _ 0;
action: PROC[master: Master] ~ { n _ n+1 };
DoTrajectories[master, pathProc, pathData, action];
master.MakeOutline[n];
master.MaskFill[];
};

MaskStroke: PROC[context: Context, pathProc: PathProc, pathData: REF] ~ {
master: Master ~ GetMaster[context];
action: PROC[master: Master] ~ { master.MaskStroke[] };
DoTrajectories[master, pathProc, pathData, action];
};

MaskStrokeClosed: PROC[context: Context, pathProc: PathProc, pathData: REF] ~ {
master: Master ~ GetMaster[context];
action: PROC[master: Master] ~ { master.MaskStrokeClosed[] };
DoTrajectories[master, pathProc, pathData, action];
};

MaskVector: PROC [context: Context, x1, y1, x2, y2: REAL] ~ {
master: Master ~ GetMaster[context];
master.MaskVector[x1, y1, x2, y2];
};

MaskVectorI: PROC[context: Context, x1, y1, x2, y2: INTEGER] ~ {
master: Master ~ GetMaster[context];
master.MaskVector[x1, y1, x2, y2];
};

MaskRectangle: PROC[context: Context, x, y, w, h: REAL] ~ {
master: Master ~ GetMaster[context];
master.MaskRectangle[x, y, w, h];
};

MaskRectangleI: PROC[context: Context, x, y, w, h: INTEGER] ~ {
master: Master ~ GetMaster[context];
master.MaskRectangle[x, y, w, h];
};

StartUnderline: PROC[context: Context] ~ {
master: Master ~ GetMaster[context];
master.StartUnderline[];
};

MaskUnderline: PROC[context: Context, dy, h: REAL] ~ {
master: Master ~ GetMaster[context];
master.MaskUnderline[dy, h];
};

MaskUnderlineI: PROC[context: Context, dy, h: INTEGER] ~ {
master: Master ~ GetMaster[context];
master.MaskUnderline[dy, h];
};

MaskPixel: PROC[context: Context, pa: PixelArray] ~ {
ERROR Imager.Error[$Unimplemented];
};

ClipOutline: PROC[context: Context, pathProc: PathProc, pathData: REF] ~ {
ERROR Imager.Error[$Unimplemented];
};

ExcludeOutline: PROC[context: Context, pathProc: PathProc, pathData: REF] ~ {
ERROR Imager.Error[$Unimplemented];
};

ClipRectangle: PROC[context: Context, x, y, w, h: REAL] ~ {
ERROR Imager.Error[$Unimplemented];
};

ExcludeRectangle: PROC[context: Context, x, y, w, h: REAL] ~ {
ERROR Imager.Error[$Unimplemented];
};

ClipRectangleI: PROC[context: Context, x, y, w, h: INTEGER] ~ {
ERROR Imager.Error[$Unimplemented];
};

ExcludeRectangleI: PROC[context: Context, x, y, w, h: INTEGER] ~ {
ERROR Imager.Error[$Unimplemented];
};

ShowChar: PROC[context: Context, char: CHAR] ~ {
master: Master ~ GetMaster[context];
master.Show[Rope.FromChar[char]];
};

ShowCharacters: PROC[context: Context, characters: REF, start: INT, length: INT] ~ {
master: Master ~ GetMaster[context];
rope: ROPE ~ WITH characters SELECT FROM
text: REF TEXT => RefText.TrustTextAsRope[text],
ENDCASE => NARROW[characters];
master.Show[rope.Substr[start, length]];
};

CorrectMask: PROC[context: Context] ~ {
master: Master ~ GetMaster[context];
master.CorrectMask[];
};

CorrectSpace: PROC[context: Context, v: Pair] ~ {
master: Master ~ GetMaster[context];
master.CorrectSpace[v.x, v.y];
};

SetCorrectMeasure: PROC[context: Context, v: Pair] ~ {
master: Master ~ GetMaster[context];
master.SetCorrectMeasure[v.x, v.y];
};

SetCorrectTolerance: PROC [context: Context, v: Pair] ~ {
master: Master ~ GetMaster[context];
master.SetCorrectTolerance[v.x, v.y];
};

Space: PROC [context: Context, x: REAL] ~ {
master: Master ~ GetMaster[context];
master.Space[x];
};

SpaceI: PROC [context: Context, x: INTEGER] ~ {
master: Master ~ GetMaster[context];
master.Space[x];
};

Correct: PROC[context: Context, body: PROC] ~ {
master: Master ~ GetMaster[context];
master.BeginCorrect[];
body[];
master.EndCorrect[];
};

interpressClass: Imager.Class ~ NEW[Imager.ClassRep _ [
type: $Interpress,
DoSave: DoSave,
DoSaveAll: DoSaveAll,
Set: Set,
SetReal: SetReal,
SetInt: SetInt,
Get: Get,
GetReal: GetReal,
GetInt: GetInt,
ConcatT: ConcatT,
ScaleT: ScaleT,
Scale2T: Scale2T,
RotateT: RotateT,
TranslateT: TranslateT,
Move: Move,
Trans: Trans,
SetSampledColor: SetSampledColor,
SetSampledBlack: SetSampledBlack,
SetXY: SetXY,
SetXYI: SetXYI,
SetXYRel: SetXYRel,
SetXYRelI: SetXYRelI,
MaskFill: MaskFill,
MaskStroke: MaskStroke,
MaskStrokeClosed: MaskStrokeClosed,
MaskVector: MaskVector,
MaskVectorI: MaskVectorI,
MaskRectangle: MaskRectangle,
MaskRectangleI: MaskRectangleI,
StartUnderline: StartUnderline,
MaskUnderline: MaskUnderline,
MaskUnderlineI: MaskUnderlineI,
MaskPixel: MaskPixel,
ClipOutline: ClipOutline,
ExcludeOutline: ExcludeOutline,
ClipRectangle: ClipRectangle,
ExcludeRectangle: ExcludeRectangle,
ClipRectangleI: ClipRectangleI,
ExcludeRectangleI: ExcludeRectangleI,
ShowChar: ShowChar,
ShowCharacters: ShowCharacters,
CorrectMask: CorrectMask,
CorrectSpace: CorrectSpace,
SetCorrectMeasure: SetCorrectMeasure,
SetCorrectTolerance: SetCorrectTolerance,
Space: Space,
SpaceI: SpaceI,
Correct: Correct
]];


END.
€NewImagerIPImpl.mesa

Edited by:
Doug Wyatt, June 22, 1984 5:23:22 pm PDT
ImagerPrivate.RegisterDevice[interpressClass];
�Ê
˜Jš
œ™J™™
J™(—J˜š
Ïk	˜	Jšœ�œ�œ!˜1Jšœ
�œ#˜2Jšœ�œu˜†
Jšœ�œ˜4Jš
œ	˜	Jšœ�œ˜ Jšœ�œ�œ
˜$—J˜Jšœ�œ
�˜Jš�œB˜IJšœ�œ
�œ
˜J˜Jš�œ�œ�œ
˜J˜Jšœ	�œ˜Jš�œ�œ�œ
˜Jšœ�œ˜ Jšœ�œ%˜<šœ�œ˜J˜—šÏnœ�œ�œ˜+Jš
œ'˜'Jš
œ˜Jš
œ˜J˜—šž	œ�œ�œ�œ˜<Jš�œ ˜&Jš
œ˜J˜—šžœ�œ"�œ
�œ˜;Jš�œ˜#Jš
œ˜J˜—šžœ�œ"�œ
�œ˜@Jš�œ˜#Jš
œ˜J˜—šžœ�œ"�œ
�œ˜>Jš�œ˜#Jš
œ˜J˜—šžœ�œ)�œ˜:J˜$š�œ�˜Jšœ�œ˜)šœ�œ�˜Jšœ�œ˜$Jš�œ�œ˜*—šœ
�œ�˜Jš
œ(˜(Jš�œ�œ˜*—Jšœ�œ˜/Jš�œ�œ˜*—J˜J˜—šžœ�œ�œ˜-Jšœ�œ˜Jš
œA˜AJš
œ˜J˜+J˜J˜J˜J˜—šžœ�œ"˜0š�œ�œ
�˜šœ�œ�œ
�˜&Jš
œ,˜,˜Jšœ�œ�
œ�œ
�œ
�œ˜4J˜—Jš�œ�œ˜.—Jšœ�œ˜6Jš�œ�œ˜$—J˜J˜—šžœ�œ)�œ˜?J˜$š�œ�˜Jšœ�œ˜.Jšœ�œ˜.Jšœ�œ˜1Jšœ�œ˜1Jšœ�œ˜3Jšœ�œ˜3Jšœ�œ˜1Jšœ�œ˜1Jšœ�œ˜1Jšœ�œ˜1Jš
œE˜EJšœ�œ˜6Jš
œG˜GJš
œI˜IJšœ�œ˜1Jšœ�œ˜1Jš�œ�œ˜*—J˜J˜—šžœ�œ)�œ˜=J˜$š�œ�˜Jš
œP˜PJš
œ<˜<Jš
œ@˜@Jšœ�œ˜3Jš�œ�œ˜*—J˜J˜—šžœ�œJ�œ˜hJš�œ˜#Jš
œ˜J˜—šžœ�œH�œ˜iJš�œ˜#Jš
œ˜J˜—šžœ�œ�œ˜.J˜$J˜J˜J˜Jš
œ˜J˜—šž	œ�œ�œ˜1J˜$J˜J˜J˜J˜Jš
œ˜J˜—šžœ�œ)˜6J˜$J˜+J˜Jš
œ˜J˜—šžœ�œ�œ˜+J˜$J˜"Jš
œ˜J˜—šžœ�œ�œ˜1J˜$J˜(Jš
œ˜J˜—šžœ�œ�œ˜,J˜$J˜#Jš
œ˜J˜—šž
œ�œ�œ˜2J˜$J˜)Jš
œ˜J˜—šžœ�œ˜ J˜$J˜Jš
œ˜J˜—šžœ�œ˜!J˜$J˜Jš
œ˜J˜—šžœ�œ�œ˜-J˜$J˜Jš
œ˜J˜—šžœ�œ�œ˜1J˜$J˜Jš
œ˜J˜—šžœ�œ�œ˜0J˜$Jš�œ�œ˜Jš�œ
�œ�œ˜"Jš�œ˜Jš
œ˜J˜—šž
œ
�œ�œ˜4J˜$Jš�œ�œ˜Jš�œ
�œ�œ˜"Jš�œ˜Jš
œ˜J˜—šžœ�œ/�œ
˜GJšœ�œ
˜Jšœ	�œ�œ
˜Jšœ�œ˜šœ�œ�œ˜Jš�œ	�œ�œ�œ
˜3Jš
œ˜Jš
œ˜—šœ�œ�œ˜Jš�œ�œ˜#Jš�œ
�œ�œ˜(Jš�œ˜#Jš
œ˜—šœ	�œ�œ˜/J˜1Jš
œ˜—šœ	�œ�œ�œ˜0J˜,Jš
œ˜—šœ�œ�œ˜%Jš
œ'˜'Jš
œ˜—Jš
œ<˜<Jš�œ	�œ˜Jš
œ˜J˜—šžœ�œ1�œ˜GJ˜$Jšœ�œ˜Jšœ�œ˜+Jš
œ3˜3Jš
œ˜J˜Jš
œ˜J˜—šž
œ�œ1�œ˜IJ˜$Jšœ�œ+˜7Jš
œ3˜3Jš
œ˜J˜—šžœ�œ1�œ˜OJ˜$Jšœ�œ1˜=Jš
œ3˜3Jš
œ˜J˜—šž
œ�œ$�œ˜=J˜$Jš
œ"˜"Jš
œ˜J˜—šžœ
�œ#�œ˜@J˜$Jš
œ"˜"Jš
œ˜J˜—šž
œ�œ�œ˜;J˜$Jš
œ!˜!J˜J˜—šžœ
�œ�œ˜?J˜$Jš
œ!˜!J˜J˜—šžœ�œ˜*J˜$J˜Jš
œ˜J˜—šž
œ�œ�œ˜6J˜$J˜Jš
œ˜J˜—šžœ
�œ�œ˜:J˜$J˜Jš
œ˜J˜—šž	œ�œ&˜5Jš�œ˜#J˜J˜—šžœ�œ1�œ˜JJš�œ˜#Jš
œ˜J˜—šžœ�œ1�œ˜MJš�œ˜#Jš
œ˜J˜—šž
œ�œ�œ˜;Jš�œ˜#Jš
œ˜J˜—šžœ�œ�œ˜>Jš�œ˜#Jš
œ˜J˜—šžœ
�œ�œ˜?Jš�œ˜#Jš
œ˜J˜—šžœ
�œ�œ˜BJš�œ˜#Jš
œ˜J˜—šžœ�œ�œ˜0J˜$Jš
œ!˜!J˜J˜—š
žœ�œ�œ	�œ
�œ˜TJ˜$šœ�œ�œ�œ
�˜(Jšœ�œ
�œ"˜0Jš�œ�œ
˜—Jš
œ(˜(J˜J˜—šžœ�œ˜'J˜$J˜Jš
œ˜J˜—šžœ�œ˜1J˜$J˜Jš
œ˜J˜—šžœ�œ˜6J˜$J˜#Jš
œ˜J˜—šžœ�œ ˜9J˜$J˜%Jš
œ˜J˜—šžœ�œ�œ˜+J˜$J˜Jš
œ˜J˜—šžœ
�œ�œ˜/J˜$J˜Jš
œ˜J˜—šžœ�œ�œ˜/J˜$J˜J˜J˜Jš
œ˜J˜—šœ �œ˜7Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ	˜	J˜J˜J˜	J˜J˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ
˜
Jš
œ!˜!Jš
œ!˜!Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ#˜#Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ#˜#Jš
œ˜Jš
œ%˜%Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ%˜%Jš
œ)˜)Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜J˜—š
œ.™.J˜—Jš�œ
˜—…—,Ð:n