DIRECTORY
ChoiceButtons USING [UpdateChoiceButtons],
Convert USING [RopeFromInt, RopeFromReal],
Graph USING [CaretIndex, ColorIndex, Entity, EntityHashSize, EntityList, FontIndex, GraphHandle, NumberOfColors, NumberOfFonts, ROPE, Text, Texts, XY],
GraphConvert USING [RopeFromJustifX, RopeFromJustifY, RopeFromMark, RopeOfSlope, RopeOfXYValues],
GraphPrivate USING [GraphAtomProc, PaintEntity, PaintText],
GraphUtil USING [AppendEntityList, BlinkMsg, ControllerViewerExits, Crosssection, EntityFromId, GetIntField, GetRealField, HandleNotNil, InitSegAll, InitSegEnd, SpecIndexedEntity, SpecIndexedText, RaiseError, SetIntField, SetRealField, SetToggleColor, TextFromId],
IO USING [int, PutFR],
Rope USING [Cat, Concat],
ViewerTools USING [SetContents];

GraphResume: CEDAR PROGRAM
IMPORTS ChoiceButtons, Convert, GraphConvert, GraphPrivate, GraphUtil, IO, Rope, ViewerTools
EXPORTS GraphPrivate = { OPEN Graph, GraphPrivate, GraphUtil;

ResumeFromPanel: PUBLIC GraphAtomProc = {
IF ControllerViewerExits[handle] THEN { OPEN handle;
msg: ROPE; i: INT; r: REAL;
SELECT atom FROM
$Divisions => ResumeDivisionsFields[handle];
$Bounds => ResumeBoundsFields[handle];
$Carets => ResumeCaretsFields[handle];
$Primary => ResumeCaretFields[handle, primary];
$Secondary => ResumeCaretFields[handle, secondary];
$Slope => ResumeSlopeFields[handle];
$TextCaret => ResumeCaretFields[handle, text];
$Targets => ResumeTargetsFields[handle];
$Grids => ResumeGridsFields[handle];
$Color => {
[msg, i] _ GetIntField[controller.colorIndex];
IF msg = NIL THEN
IF i IN ColorIndex THEN ResumeColorFields[handle, i]
ELSE BlinkMsg[Rope.Cat[
"Index must be in [0..", Convert.RopeFromInt[NumberOfColors], ")"]];
};
$Font => {
[msg, i]_ GetIntField[controller.fontIndex];
IF msg = NIL THEN
IF i IN FontIndex THEN ResumeFontFields[handle, i]
ELSE BlinkMsg[Rope.Cat[
"Index must be in [0..", Convert.RopeFromInt[NumberOfFonts], ")"]];
};
$Text => {
text: Text _ SpecIndexedText[controller, allTexts];
IF text = NIL THEN BlinkMsg["No text with this id."]
ELSE ShowText[handle, text];
};
$Entity => {
entity: Entity _ SpecIndexedEntity[controller, entityHash];
IF entity = NIL THEN BlinkMsg["No curve with this id."]
ELSE ShowEntity[handle, entity];
};
$XYValues => {
msg: ROPE; i: INT;
[msg, i] _ GetIntField[controller.idOfy];
IF msg = NIL THEN {
entity: Entity _ EntityFromId[entityHash[i MOD EntityHashSize], i];
IF entity = NIL THEN BlinkMsg["No curve with this id."]
ELSE ResumeXYValues[handle, entity];
};
};
$Xsection => {
[msg, r] _ GetRealField[controller.xat];
IF msg = NIL THEN ResumeCrossSection[handle, r];
};
ENDCASE => RaiseError[$UnknownAtom, "in Resume"];
};
}; -- ResumeFromPanel

ShowText: PUBLIC PROC[handle: GraphHandle _ NIL, text: Text _ NIL] = {
IF HandleNotNil[handle] AND text # NIL THEN { OPEN handle;
IF TextFromId[graph.texts, text.id] = NIL THEN {
graph.texts _ CONS[text, graph.texts];
IF chart.viewer # NIL THEN PaintText[handle, text, paint];
};
IF controller # NIL THEN ResumeTextFields[handle, text];
};
}; -- ShowText

ShowEntity: PUBLIC PROC[handle: GraphHandle _ NIL, entity: Entity _ NIL] = {
IF HandleNotNil[handle] AND entity # NIL THEN { OPEN handle;
IF EntityFromId[graph.entityList, entity.id] = NIL THEN {
graph.entityList _ AppendEntityList[graph.entityList, CONS[entity, NIL]];
IF entity.group.x.segments = NIL THEN InitSegEnd[entity.group.x];
InitSegAll[entity];
IF chart.viewer # NIL THEN PaintEntity[handle, entity, TRUE, paint];
};
IF controller # NIL THEN ResumeEntityFields[handle, entity];
};
}; -- ShowEntity

ResumeDivisionsFields: PROC[handle: GraphHandle] = { OPEN handle;
controller.auto[divisions] _ SetToggleColor[controller.swDivisions, graph.auto[divisions]];
SetIntField[controller.divX, graph.division[x]];
SetIntField[controller.divY, graph.division[y]];
}; -- SetDivisionFields

ResumeBoundsFields: PUBLIC PROC[handle: GraphHandle] = { OPEN handle;
controller.auto[bounds] _ SetToggleColor[controller.swBounds, graph.auto[bounds]];
SetRealField[controller.xmin, graph.bounds.xmin];
SetRealField[controller.ymin, graph.bounds.ymin];
SetRealField[controller.xmax, graph.bounds.xmax];
SetRealField[controller.ymax, graph.bounds.ymax];
}; -- SetBoundsFields

ResumeCaretsFields: PROC[handle: GraphHandle] = { OPEN handle;
FOR i: CaretIndex IN CaretIndex DO ResumeCaretFields[handle, i] ENDLOOP;
ResumeSlopeFields[handle];
}; -- ResumeCaretsFields

ResumeCaretFields: PROC [handle: GraphHandle, index: CaretIndex] = { OPEN handle;
controller.caretOn[index] _ SetToggleColor[controller.swCaret[index], graph.caret[index].on];
SetRealField[controller.caretPlace[index][x], graph.caret[index].place.x];
SetRealField[controller.caretPlace[index][y], graph.caret[index].place.y];
}; -- ResumeCaretFields

ResumeSlopeFields: PROC[handle: GraphHandle] = { OPEN handle;
controller.slopeOn _ SetToggleColor[controller.swSlope, graph.showSlope];
IF graph.showSlope THEN ViewerTools.SetContents[controller.slope,
GraphConvert.RopeOfSlope[graph.caret[primary].place, graph.caret[secondary].place]];
}; -- ResumeSlopeFields

ResumeTargetsFields: PROC[handle: GraphHandle] = {
ResumeTargetFields[handle, x];
ResumeTargetFields[handle, y]; 
}; -- ResumeTargetsFields

ResumeTargetFields: PROC [handle: GraphHandle, xy: XY] = { OPEN handle;
controller.targetOn[xy] _ SetToggleColor[controller.swTarget[xy], graph.target[xy].on];
SetRealField[controller.targetValue[xy], graph.target[xy].value];
SetRealField[controller.targetWidth[xy], graph.target[xy].width];
}; -- ResumeTargetFields

ResumeGridsFields: PROC[handle: GraphHandle] = { OPEN handle;
controller.gridOn[x] _ SetToggleColor[controller.swGrid[x], graph.grids[x]];
controller.gridOn[y] _ SetToggleColor[controller.swGrid[y], graph.grids[y]];
}; -- ResumeGridsFields

ResumeColorFields: PROC[handle: GraphHandle, index: ColorIndex] = { OPEN handle;
SetRealField[controller.red, graph.color[index].R];
SetRealField[controller.green, graph.color[index].G];
SetRealField[controller.blue, graph.color[index].B];
}; -- ResumeColorFields

ResumeFontFields: PROC[handle: GraphHandle, index: FontIndex] = { OPEN handle;
ViewerTools.SetContents[controller.fontFamily, graph.font[index].family];
controller.boldOn _ SetToggleColor[controller.swBold, graph.font[index].bold];
controller.italicOn _ SetToggleColor[controller.swItalic, graph.font[index].italic];
SetIntField[controller.vFontSize, graph.font[index].vFontSize];
SetRealField[controller.pFontScale, graph.font[index].pFontScale];
}; -- ResumeFontFields

ResumeTextFields: PUBLIC PROC [handle: GraphHandle _ NIL, text: Text _ NIL] = {
IF HandleNotNil[handle] AND text # NIL THEN { OPEN handle;
ViewerTools.SetContents[controller.textContent, text.text];
SetRealField[controller.textPlaceX, text.place.x]; 
ChoiceButtons.UpdateChoiceButtons[controller.viewer, controller.justifXRef,
GraphConvert.RopeFromJustifX[text.justifX]];
controller.justifX _ text.justifX;
SetRealField[controller.textPlaceY, text.place.y]; 
ChoiceButtons.UpdateChoiceButtons[controller.viewer, controller.justifYRef,
GraphConvert.RopeFromJustifY[text.justifY]];
controller.justifY _ text.justifY;
SetIntField[controller.textColor, text.colorIndex]; 
SetIntField[controller.textFont, text.fontIndex];
SetRealField[controller.textRotation, text.rotation]; 
};
}; -- ResumeTextFields

ResumeEntityFields: PUBLIC PROC [handle: GraphHandle _ NIL, entity: Entity _ NIL] = {
IF ControllerViewerExits[handle] AND entity # NIL THEN { OPEN handle;
ViewerTools.SetContents[controller.entityName, entity.name];
ViewerTools.SetContents[controller.entityCmt, entity.comment];
SetIntField[controller.entityColor, entity.colorIndex]; 
SetRealField[controller.entityWidth, entity.width]; 
ChoiceButtons.UpdateChoiceButtons[controller.viewer, controller.markRef,
GraphConvert.RopeFromMark[entity.mark]];
controller.mark _ entity.mark;
};
}; -- ResumeEntityFields

ResumeXYValues: PROC [handle: GraphHandle, entity: Entity] = {
IF ControllerViewerExits[handle] AND entity # NIL THEN
ViewerTools.SetContents[handle.controller.values, GraphConvert.RopeOfXYValues[entity]];
}; -- ResumeXYValues


ResumeCrossSection: PROC[handle: GraphHandle, x: REAL] = { OPEN handle;
rope, tRope: ROPE _ NIL;
ok: BOOL;
y: REAL;
count: INT _ 0;
FOR el: EntityList _ graph.entityList, el.rest UNTIL el = NIL DO
[ok, y] _ Crosssection[el.first.group.x.segments, el.first.segments, x];
tRope _ IF ok THEN Convert.RopeFromReal[y] ELSE "*";
rope _ IF rope = NIL THEN tRope ELSE rope.Cat[", ", tRope];
count _ count + 1;
IF (count MOD 5) = 0 THEN rope _ rope.Concat[IO.PutFR[" -- %g\n", IO.int[count]]];
ENDLOOP;
ViewerTools.SetContents[controller.values, rope];
}; -- ResumeCrossSection
}.

LOG.
SChen, created at October 9, 1985 6:53:56 pm PDT.

rGraphResume.mesa, Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last Edited by:
Sweetsun Chen, April 23, 1986 2:29:57 pm PST
If handle = nil or controller = nil then error; otherwise:
resumes fields values on panel in the entry denoted by atom, if they are not set yet.
if atom denotes text or entity and if chart.viewer # nil, then display it on graph viewer.
if atom doesn't denote text or entity, then has no effect on graph viewer display.
$TargetX => ResumeTargetFields[handle, x];
$TargetY => ResumeTargetFields[handle, y];
$CurveGroup => {
[msg, i] _ GetIntField[controller.groupId, "id"];
IF msg = NIL THEN {
eg: EntityGroup _ EntityGroupFromId[handle.entityGroupList, i];
IF eg = NIL THEN BlinkMsg[Rope.Concat["There is no curve group with id = ", Convert.RopeFromInt[i]]]
ResumeCurveGroupFields[handle, eg];
};
};
Check if it is indeed not plotted.  If no, then {add it to end of graph.entityList. Init x and y segments. If plot exits, draw it and its legend.}
ResumeXButtonField: PROC[handle: GraphHandle] = { OPEN handle;
ViewerTools.SetContents[controller.xValues,
GraphConvert.RopeFromSDL[entityGroupList.first.x.segments]]; -- for now.
}; -- ResumeXButtonField

SetIntField[controller.entityGroupId, entity.groupId]; 
ViewerTools.SetContents[controller.idOfy, Convert.RopeFromInt[entity.id]];
ResumeXYValues[handle, entity];
ResumeCurveGroupFields: PROC[handle: GraphHandle, eg: EntityGroup] = { OPEN handle;
ViewerTools.SetContent[controller.groupName, eg.name];
SetIntField[controller.xId, eg.x.id];
ViewerTools.SetContent[controller.yIds, RopeOfEntityListIds[eg.entityList, eg.x]];
}; -- ResumeCurveGroupFields
Κ		˜JšœΟm
œ1™Nš
œ™Icode™,—š
Οk	˜	Jšœžœ˜*Jšœžœ˜*Jšœžœužœžœ˜—
Jšœ
žœO˜aJšœ
žœ)˜;Jšœ
žœω
˜ˆJšžœ
žœ˜Jšœžœ˜Jšœžœ˜ —J˜šœ
žœ
ž˜Jšžœ@žœ˜\Jšžœžœ ˜=J˜—šœžœ˜)™:Jš
œU™UJ™ZJ™R—šžœžœžœ˜4Jšœžœžœžœ
˜šžœž˜Jš
œ,˜,Jš
œ&˜&Jš
œ&˜&Jš
œ/˜/Jš
œ3˜3Jš
œ$˜$Jš
œ.˜.Jš
œ(˜(Jš
œ*™*Jš
œ*™*Jš
œ$˜$š
œ˜Jš
œ.˜.šžœžœ
ž˜Jšžœžœžœ˜4šžœ˜Jš
œD˜D——J˜—˜
Jš
œ,˜,šžœžœ
ž˜Jšžœžœžœ˜2šžœ˜Jš
œC˜C——J˜—š
œ
˜
Jš
œ3˜3Jšžœžœ
žœ"˜4Jšžœ˜J˜—š
œ˜Jš
œ;˜;Jšžœ
žœ
žœ#˜7Jšžœ˜ J˜—š
œ˜Jšœžœžœ
˜Jš
œ)˜)šžœžœ
žœ˜Jšœ+žœ˜CJšžœ
žœ
žœ#˜7Jšžœ ˜$J˜—J˜—š
œ˜Jš
œ(˜(Jšžœžœ
žœ˜0J˜—™Jš
œ1™1šžœžœ
žœ™Jš
œ?™?Jšžœžœ
žœT™dJš
œ#™#J™—J™—Jšžœ*˜1—J˜—JšœΟc˜J˜—š
Οnœžœ
žœžœžœ˜Fš
žœžœžœ
žœžœ˜:šžœ$žœ
žœ˜0Jšœžœ˜&Jšžœžœ
žœ ˜:J˜—Jšžœžœ
žœ ˜8J˜—JšœŸ˜J˜—š
 
œžœ
žœžœžœ˜LJ™’
š
žœžœ
žœ
žœžœ˜<šžœ-žœ
žœ˜9Jšœ6žœ	žœ˜IJšžœžœ
žœ˜AJ˜Jšžœžœ
žœžœ	˜DJ˜—Jšžœžœ
žœ$˜<J˜—JšœŸ
˜J˜š œžœžœ˜AJš
œ[˜[Jš
œ0˜0Jš
œ0˜0JšœŸ˜—J˜š œžœ
žœžœ˜EJš
œR˜RJš
œ1˜1Jš
œ1˜1Jš
œ1˜1Jš
œ1˜1JšœŸ˜—J˜š œžœžœ˜>Jšžœžœžœžœ
˜HJš
œ˜JšœŸ˜—J˜š œžœ.žœ˜QJš
œ]˜]Jš
œJ˜JJš
œJ˜JJšœŸ˜—J˜š œžœžœ˜=Jš
œI˜Išžœžœ*˜AJš
œT˜T—JšœŸ˜J˜—š œžœ˜2Jš
œ˜Jš
œ˜JšœŸ˜—J˜š œžœžœžœ˜GJš
œW˜WJš
œA˜AJš
œA˜AJšœŸ˜—J˜š œžœžœ˜=Jš
œL˜LJš
œL˜LJšœŸ˜—J˜š œžœ-žœ˜PJš
œ3˜3Jš
œ5˜5Jš
œ4˜4JšœŸ˜—J˜š œžœ,žœ˜NJš
œI˜IJš
œN˜NJš
œT˜TJš
œ?˜?Jš
œB˜BJšœŸ˜—J˜—š
 œžœ
žœžœžœ˜Oš
žœžœžœ
žœžœ˜:Jš
œ;˜;Jš
œ3˜3š
œK˜KJš
œ,˜,—Jš
œ"˜"Jš
œ3˜3š
œK˜KJš
œ,˜,—Jš
œ"˜"Jš
œ4˜4Jš
œ1˜1Jš
œ6˜6J˜—JšœŸ˜J˜š œžœžœ™>š
œ+™+Jšœ=Ÿ™H—JšœŸ™—J™—š
 œžœ
žœžœžœ˜Uš
žœžœ
žœ
žœžœ˜EJš
œ<˜<Jš
œ>˜>Jš
œ8˜8Jš
œ4˜4š
œH˜HJš
œ(˜(—Jš
œ˜Jš
œ7™7Jš
œJ™JJš
œ™J˜—JšœŸ˜J˜š œžœ*˜>šžœžœ
žœ
ž˜6Jš
œW˜W—JšœŸ˜J˜—š œžœ+žœ™SJš
œ6™6Jš
œ%™%Jš
œR™RJšœŸ™—J˜š œžœžœžœ˜GJšœ
žœžœ
˜Jšœžœ
˜	Jšœžœ
˜Jšœžœ˜šžœ,žœžœ
ž˜@Jš
œH˜HJšœžœžœžœ˜4Jš	œžœžœ
žœžœ˜;Jš
œ˜Jš
žœžœžœžœžœ˜RJšžœ
˜—Jš
œ1˜1JšœŸ˜——J˜J˜šžœ
˜J˜1—J˜—…—"1{