DIRECTORY ColorTrixBasics, Commander, Controls, ControlsPrivate, Contours, FS, Imager, ImagerColor, IO, TIPUser, Vector2, ViewerClasses, ViewerOps;

ContoursCommandsImpl: CEDAR PROGRAM
IMPORTS ColorTrixBasics, Commander, Controls, ControlsPrivate, Contours, FS, Imager, ImagerColor, IO, TIPUser, Vector2, ViewerOps

~ BEGIN
OPEN Contours;
UserData:			TYPE ~ RECORD [o: Controls.OuterData, p: ProgramData];

ProgramData:		TYPE ~ REF ProgramDataRec;
ProgramDataRec:	TYPE ~ RECORD [
out:				STREAM _ NIL,						-- for any text output
outer:				Viewer _ NIL,						-- the outer (parent, top level) viewer
color:				Color _ Imager.black,				-- Imager color
alpha:				Control _ NIL,						-- interpolation alpha
scaler:				Control _ NIL,						-- contour scaler
hue:				Control _ NIL,						-- fill hue
fun:				Control _ NIL,						-- have some
contour:			Control _ NIL,						-- the contour control
contour0:			Control _ NIL,						-- first interpolant
contour1:			Control _ NIL,						-- second interpolant
save:				Contour _ NIL,						-- permit undo
scale:				Contour _ NIL,						-- avoid scale accumulation
scaling:			BOOL _ FALSE,
normals:			BOOL _ FALSE,						-- show contour normals?
info:				BOOL _ FALSE						-- report contour information?
];
ContoursInterpolate: Commander.CommandProc ~ {
p: ProgramData _ NEW[ProgramDataRec];
p.alpha _ Controls.NewControl["Alpha", vSlider, p, 0.0, 1.0, 0.5, Interpolate, , , , , , , 120]; 
p.contour0 _ Controls.NewControl[type: contour, w: 160, proc: Interpolate, data: p];
p.contour1 _ Controls.NewControl[type: contour, w: 160, proc: Interpolate, data: p];
p.contour _ Controls.NewControl[type: contour, w: 160, data: p];
p.outer _ Controls.OuterViewer[
name: "Contours Interpolate",
controls: LIST[p.contour0, p.contour1, p.contour, p.alpha],
data: p
];
};

Interpolate: Controls.ControlProc ~ {
IF control.mouse.state # up THEN {
p: ProgramData _ NARROW[control.data];
contour0: Contour _ Contours.FromControl[p.contour0];
contour1: Contour _ Contours.FromControl[p.contour1];
Contours.ToControl[p.contour, Contours.Interpolate[contour0, contour1, p.alpha.value]];
};
};
ContoursTest: Commander.CommandProc ~ {
p: ProgramData _ NEW[ProgramDataRec _ [out: cmd.out]];

p.contour _ Controls.NewControl[
name: "Contour and Normals", type: contour, data: p, w: 180, flavor: $Normals];
p.scaler _ Controls.NewControl["Scale", vSlider, p, 0.0, 5.0, 1.0, Scale, , , , , , , 138]; 
p.hue _ Controls.NewControl["Hue", vSlider, p, 0.0, 1.0, 0.5, Hue, , , , , , , 138]; 
p.fun _ Controls.NewControl["Fun", vSlider, p, 0.0, 5.0, 1.0, Fun, , , , , , , 138]; 
p.outer _ Controls.OuterViewer[
name: "Contours Test",
column: right,
controls: LIST[p.contour, p.scaler, p.hue, p.fun],
buttons: LIST[
["Info-Off", ToggleInfo, 0],
["Normals-Off", ToggleNormals, 0],
["Read", Read, 0],
["Write", Write, 0],
["UnDo", UnDo, 1],
["Clear", Clear, 1],
["Center", Center, 1],
["Thin", Thin, 1],
["Smooth", Smooth, 1],
["Close", Close, 1],
["Outline", Outline, 1],
["Fill", Fill, 1],
["FillPm", FillPm, 1]],
typeScriptHeight: 18,
data: p
];
};

Scale: Controls.ControlProc ~ {
IF control.mouse.state # up THEN ScaleContour[NARROW[control.data, ProgramData]];
};

Fun: Controls.ControlProc ~ {
p: ProgramData _ NARROW[control.data];
hue: REAL _ p.hue.value+0.02;
IF control.mouse.state = up THEN RETURN;
IF hue > p.hue.max THEN hue _ p.hue.min;
Controls.SetSliderDialValue[p.hue, hue];
Controls.SetSliderDialValue[p.scaler, p.fun.value];
ScaleContour[NARROW[control.data, ProgramData]];
p.color _ ImagerColor.ColorFromRGB[ImagerColor.RGBFromHSL[[p.hue.value, 1.0, 0.5]]];
FillContour[p];
};

ScaleContour: PROC [p: ProgramData] ~ {
contour: Contour _ Contours.Copy[p.scale];
centroid: Pair _ Contours.Centroid[contour];
contour _ Contours.Offset[contour, Vector2.Neg[centroid]];
contour _ Contours.Scale[contour, p.scaler.value];
contour _ Contours.Offset[contour, centroid];
p.scaling _ TRUE;
Contours.ToControl[p.contour, contour];
};

FillContour: PROC [p: ProgramData] ~ {
Contours.Fill[InitColorDisplayContext[], Contours.FromControl[p.contour], p.color];
};

Fill: Controls.ClickProc ~ {
FillContour[UserDataFromClientData[clientData].p];
};

FillPm: Controls.ClickProc ~ {
p: ProgramData _ UserDataFromClientData[clientData].p;
Contours.FillPm[ColorTrixBasics.GetColorDisplayPm[], Contours.FromControl[p.contour], 100];
};

Hue: Controls.ControlProc ~ {
p: ProgramData _ NARROW[control.data];
IF control.mouse.state = up THEN RETURN;
p.color _ ImagerColor.ColorFromRGB[ImagerColor.RGBFromHSL[[p.hue.value, 1.0, 0.5]]];
FillContour[p];
};

ToggleInfo: Controls.ClickProc ~ {
u: UserData _ UserDataFromClientData[clientData];
u.p.info _ NOT u.p.info;
Controls.ButtonToggle[u.o, u.p.info, "Info-On", "Info-Off"];
CheckPrintInfo[u.p];
};

CheckPrintInfo: PROC [p: ProgramData] ~ {
IF p.info THEN {
rope: ROPE _ IO.PutFR[
"%g pairs in %g contour\n",
IO.int[Controls.NPointsInContour[p.contour]],
IO.rope[IF Controls.IsContourClosed[p.contour] THEN "closed" ELSE "open"]];
Controls.TypeScriptWrite[NARROW[p.outer.data], rope];
};
};

ToggleNormals: Controls.ClickProc ~ {
u: UserData _ UserDataFromClientData[clientData];
Controls.ButtonToggle[u.o, u.p.normals _ NOT u.p.normals, "Normals-On", "Normals-Off"];
ViewerOps.PaintViewer[u.p.contour.viewer, client, FALSE, NIL];
};

PaintNormals: ViewerClasses.PaintProc ~ {
control: Control _ NARROW[self.data];
p: ProgramData _ NARROW[control.data];

IF control.mouse.state # up
THEN [] _ ControlsPrivate.PaintContour[self, context, whatChanged, clear]
ELSE {
contour: Contour _ Contours.FromControl[p.contour];
CheckPrintInfo[p];
IF p.normals THEN contour.normals _ Contours.Normals[contour];
Contours.Paint[contour, context, p.normals];
IF NOT p.scaling THEN {
p.scale _ contour;
Controls.SetSliderDialValue[p.scaler, 1.0];
};
p.scaling _ FALSE;
};
};

Read: Controls.ClickProc ~ {
u: UserData _ UserDataFromClientData[clientData];
name: ROPE _ Controls.TypeScriptReadFileName[u.o];
IF name # NIL THEN  {
stream: STREAM _ FS.StreamOpen[name ! FS.Error => GOTO noOpen];
Contours.ToControl[u.p.contour, Contours.Read[stream]];
CheckPrintInfo[u.p];
EXITS
noOpen =>
Controls.TypeScriptWrite[u.o, IO.PutFR["Couldn't open %g\n", IO.rope[name]]];
};
};

Write: Controls.ClickProc ~ {
u: UserData _ UserDataFromClientData[clientData];
name: ROPE _ Controls.TypeScriptReadFileName[u.o];
IF name # NIL THEN
Contours.Write[FS.StreamOpen[name, $create], Contours.FromControl[u.p.contour]];
};

UnDo: Controls.ClickProc ~ {
p: ProgramData _ UserDataFromClientData[clientData].p;
Contours.ToControl[p.contour, p.scale _ p.save];
CheckPrintInfo[p];
};

Clear: Controls.ClickProc ~ {
u: UserData _ UserDataFromClientData[clientData];
Controls.Reset[u.p.contour];
};

Center: Controls.ClickProc ~ {
p: ProgramData _ UserDataFromClientData[clientData].p;
contour: Contour _ Contours.FromControl[p.contour];
p.save _ p.scale _ Contours.Copy[contour];
Contours.ToControl[p.contour, Contours.Center[contour]];
};

Thin: Controls.ClickProc ~ {
p: ProgramData _ UserDataFromClientData[clientData].p;
p.scale _ Contours.Thin[p.save _ Contours.FromControl[p.contour]];
Contours.ToControl[p.contour, p.scale];
CheckPrintInfo[p];
};

Smooth: Controls.ClickProc ~ {
p: ProgramData _ UserDataFromClientData[clientData].p;
p.scale _ Contours.Smooth[p.save _ Contours.FromControl[p.contour]];
Contours.ToControl[p.contour, p.scale];
CheckPrintInfo[p];
};

Close: Controls.ClickProc ~ {
Controls.CloseContour[UserDataFromClientData[clientData].p.contour];
};

InitColorDisplayContext: PROC RETURNS [Context] ~ {
RETURN[ColorTrixBasics.InitCd[color, , , FALSE]];
};

Outline: Controls.ClickProc ~ {
p: ProgramData _ UserDataFromClientData[clientData].p;
Contours.Outline[InitColorDisplayContext[], Contours.FromControl[p.contour], p.color];
};
UserDataFromClientData: PROC [clientData: REF ANY] RETURNS [u: UserData] ~ {
u.p _ NARROW[(u.o _ NARROW[clientData]).data];
};

testUsage: ROPE _ "\nDraw a contour.";
interpolateUsage: ROPE _ "\nDraw two contours and interpolate between them.";

ViewerOps.RegisterViewerClass[$Normals, NEW[ViewerClasses.ViewerClassRec _ [
notify: Controls.NotifyControl,
paint: PaintNormals,
tipTable: TIPUser.InstantiateNewTIPTable["Controls.TIP"]]]];

Commander.Register["///Commands/ContoursTest", ContoursTest, testUsage];
Commander.Register["///Commands/ContoursInterpolate", ContoursInterpolate, interpolateUsage];

END.

ΞContoursCommandsImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Bloomenthal, September 20, 1986 8:57:57 pm PDT
Commands
Interpolation Program
General Testing Program
Miscellany
Κ˜š
œ™Jšœ
Οm
œ1™<J™.—J˜JšΟk	œBžœžœ-˜“
J˜šΠblœžœ
ž˜#JšžœBžœžœ˜
—J˜šœž˜Jšžœ
˜—
headš
Οl™Jšœžœžœ)˜BJ˜Jšœžœžœ˜(šœžœžœ˜JšœžœžœΟc˜1Jšœžœ‘)˜DJšœ#‘˜2Jšœžœ‘˜4Jšœžœ‘˜0Jšœžœ‘˜'Jšœžœ‘˜(Jšœžœ‘˜5Jšœžœ‘˜4Jšœžœ‘˜5Jšœžœ‘˜+Jšœžœ‘˜9Jšœžœžœ
˜Jšœžœžœ‘˜6Jšœ	žœžœ‘˜9Jš
œ˜——š
 ™šΟbœ˜.Jšœžœ˜%J˜aJš
œT˜TJš
œT˜TJš
œ@˜@š
œ˜Jš
œ˜Jšœ
žœ-˜;Jš
œ˜Jš
œ˜—J˜J˜—š’œ˜%šžœžœ˜"Jšœžœ˜&J˜5J˜5J˜WJ˜—Jš
œ˜——š
 ™š’œ˜'Jšœžœ"˜6J˜š
œ ˜ Jš
œO˜O—J˜\J˜UJ˜Uš
œ˜Jš
œ˜J˜Jšœ
žœ$˜2šœ	žœ
˜Jš
œ˜Jš
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜Jš
œ˜Jš
œ˜—J˜—J˜šΟnœ˜Jšžœžœžœ˜QJš
œ˜J˜—š£œ˜Jšœžœ˜&Jšœžœ˜Jšžœžœ
žœ
˜(Jšžœžœ˜(Jš
œ(˜(Jš
œ3˜3Jšœ
žœ˜0J˜TJš
œ˜Jš
œ˜J˜—š£œžœ˜'Jš
œ*˜*J˜,J˜:J˜2J˜-Jšœžœ
˜Jš
œ'˜'Jš
œ˜J˜—š£œžœ˜&Jš
œS˜SJš
œ˜J˜—š£œ˜J˜2J˜J˜—š£œ˜J˜6Jš
œ[˜[J˜J˜—š£œ˜Jšœžœ˜&Jšžœžœ
žœ
˜(Jš
œT˜TJš
œ˜Jš
œ˜J˜—š£
œ˜"Jš
œ1˜1Jšœžœ
˜Jš
œ<˜<Jš
œ˜Jš
œ˜J˜—š£œžœ˜)šžœžœ˜šœžœžœ˜Jš
œ˜Jšžœ+˜-Jšžœžœ%žœ
žœ
˜K—Jšœžœ˜5J˜—J˜J˜—š£
œ˜%Jš
œ1˜1Jšœ)žœ+˜WJšœ2žœžœ˜>Jš
œ˜J˜—š£œ˜)Jšœžœ˜%Jšœžœ˜&J˜šžœ˜JšžœE˜Išžœ˜J˜3Jš
œ˜Jšžœžœ-˜>Jš
œ,˜,šžœ
žœžœ˜Jš
œ˜Jš
œ+˜+J˜—Jšœžœ
˜J˜——Jš
œ˜J˜—š£œ˜Jš
œ1˜1Jšœžœ(˜2šžœžœ
žœ˜Icodeš	œžœžœžœ
žœ	˜?L˜7J˜š
ž˜š
œ	˜	Jšœžœžœ˜M——J˜—J˜J˜—š£œ˜Jš
œ1˜1Jšœžœ(˜2šžœžœ
ž˜Lšœžœ?˜P—J˜J˜—š£œ˜Jš
œ6˜6J˜0J˜J˜J˜—š’œ˜Jš
œ1˜1J˜J˜J˜—š£œ˜Jš
œ6˜6J˜3J˜*Jš
œ8˜8J˜J˜—š£œ˜Jš
œ6˜6Jš
œB˜BJš
œ'˜'J˜J˜J˜—š£œ˜Jš
œ6˜6Jš
œD˜DJš
œ'˜'J˜J˜J˜—š£œ˜Jš
œD˜DJ˜J˜—š£œžœ
žœ˜3Jšžœ#žœ˜1J˜J˜—š£œ˜J˜6Jš
œV˜VJ˜——š
 
™
š
£œžœžœ
žœžœ˜LJšœžœžœ˜.J˜J˜—Jšœžœ˜&Jšœžœ7˜MJ˜šœ(žœ!˜LJš
œ˜Jš
œ˜Jš
œ<˜<J˜—Jš
œH˜HJš
œ]˜]J˜—Jšžœ
˜J˜—…— Ό)•