DIRECTORY
Atom,
CD,
CDInstances,
CDCommandOps,
CDDirectory,
PopUpMenus,
CDOps,
CDPrivate,
CDProperties,
CDRopeViewer,
CDSequencer,
IO,
PropertyLists,
Rope,
RuntimeError USING [UNCAUGHT],
TerminalIO,
TokenIO,
ViewerTools USING [TiogaContents, TiogaContentsRec];

CDPropertyCommands: CEDAR PROGRAM 
IMPORTS Atom, CDCommandOps, CDDirectory, CDOps, CDProperties, CDRopeViewer, CDSequencer, IO, PopUpMenus, Rope, RuntimeError, TerminalIO = 
BEGIN


specialRights: BOOL _ FALSE;  -- gives the right to access exclusive properties

Atomize: PROC [r: Rope.ROPE] RETURNS [ATOM_NIL] = {
IF Rope.Length[r]>1 AND Rope.Fetch[r]='$ THEN r _ Rope.Substr[r, 1, Rope.Length[r]-1];
IF ~Rope.IsEmpty[r] THEN RETURN [Atom.MakeAtom[r]]
};

EnterSignalNameSP: PROC [comm: CDSequencer.Command] =
BEGIN 
inst: CD.Instance _ CDCommandOps.TheInstance[comm, "read signal-name"];
IF inst#NIL THEN {
name: Rope.ROPE;
TerminalIO.WriteRopes["  onto ", CDCommandOps.InstRope[inst]];
name _ TerminalIO.RequestRope[" type name: "];
IF Rope.IsEmpty[name] THEN name_NIL;
CDProperties.PutInstanceProp[onto: inst, prop: $SignalName, val: name];
IF name#NIL THEN TerminalIO.WriteRope["  done\n"] 
ELSE TerminalIO.WriteRope["  removed\n"];
}
END;

EnterInstanceNameSP: PROC [comm: CDSequencer.Command] =
BEGIN 
inst: CD.Instance _ CDCommandOps.TheInstance[comm, "read instance-name"];
IF inst#NIL THEN {
name: Rope.ROPE;
TerminalIO.WriteRopes["  onto ", CDCommandOps.InstRope[inst]];
name _ TerminalIO.RequestRope[" type name: "];
IF Rope.IsEmpty[name] THEN name_NIL;
CDProperties.PutInstanceProp[onto: inst, prop: $InstanceName, val: name];
IF name#NIL THEN TerminalIO.WriteRope["  done\n"] 
ELSE TerminalIO.WriteRope["  removed\n"];
}
END;

detail: INT _ 0;
WriteValue: PROC [x: REF] =
BEGIN
ENABLE RuntimeError.UNCAUGHT => GOTO err;
IF x=NIL THEN TerminalIO.WriteRope["NIL"] 
ELSE
WITH x SELECT FROM
ip: REF INT => TerminalIO.WriteF["^%g", IO.int[ip^]];
r: Rope.ROPE => TerminalIO.WriteRope[r];
a: ATOM => TerminalIO.WriteRopes["$", Atom.GetPName[a]];
ra: REF ATOM => TerminalIO.WriteRopes["^$", Atom.GetPName[ra^]];
d: CD.Design  => TerminalIO.WriteRopes["design ", (IF d.name=NIL THEN "no name" ELSE d.name)];
ob: CD.Object => TerminalIO.WriteRope[CDOps.ObjectInfo[ob]];
ap: CD.Instance => TerminalIO.WriteRope[CDCommandOps.InstRope[ap]];
l: CDPrivate.LayerRef => TerminalIO.WriteRope[CDOps.LayerName[l.number]];
ENDCASE => 
IF detail=0 THEN TerminalIO.WriteF1["(%b)", IO.int[LOOPHOLE[x]]]
ELSE TerminalIO.WriteRope[IO.PutR[IO.refAny[x]]];
EXITS
err => TerminalIO.WriteRope["??"];
END;

RequestValue: PROC [default: REF] RETURNS [REF] =
BEGIN
n: CARDINAL_0;
WHILE n=0 DO
n _ TerminalIO.RequestSelection["property value", LIST["leave it", "remove", "INT", "ROPE", "ATOM", "REF ANY"]];
SELECT n FROM
2 => {default _ NIL};
3 => {default _ NEW[INT_TerminalIO.RequestInt["int > "]]};
4 => {default _ TerminalIO.RequestRope["rope > "]};
5 => {default _ Atomize[TerminalIO.RequestRope["atom > "]]};
6 => {
TerminalIO.WriteRope["(on crash: abort is ok)"];
default _ IO.GetRefAny[IO.RIS[TerminalIO.RequestRope["ref any > "]]]
};
ENDCASE --0, 1-- => {NULL};
ENDLOOP;
RETURN [default]
END;

PropertyDesign: PROC [comm: CDSequencer.Command] =
BEGIN 
TerminalIO.WriteRope["enter property for the design\n"];
PropertyForSome[comm.design];
END;

PropertyApp: PROC [comm: CDSequencer.Command] =
BEGIN 
inst: CD.Instance _ CDCommandOps.TheInstance[comm, "enter property of instance"];
IF inst#NIL THEN PropertyForSome[inst];
END;

PropertyOb: PROC [comm: CDSequencer.Command] =
BEGIN 
inst: CD.Instance _ CDCommandOps.TheInstance[comm, "enter property for an object"];
IF inst#NIL THEN 
IF inst.ob.class.inDirectory OR specialRights THEN {
PropertyForSome[inst.ob];
IF inst.ob.class.inDirectory THEN 
CDDirectory.PropagateChange[inst.ob, comm.design];
}
ELSE TerminalIO.WriteRope["this object class has no user accessable properties\n"];
END;

PropertyForSome: PROC [what: REF] =
BEGIN 
value: REF;
atom: ATOM _ Atomize[TerminalIO.RequestRope["type property name: "]];
IF atom=NIL THEN {
TerminalIO.WriteRope[" empty name; not done\n"];
RETURN
};
value _ CDProperties.GetProp[what, atom];
TerminalIO.WriteRope["  old value: "];
WriteValue[value];
TerminalIO.WriteLn[];
IF IsExclusive[atom] THEN {
TerminalIO.WriteRope["  this property is used exclusively by the program; "]; 
IF ~specialRights THEN {
TerminalIO.WriteRope["interactive access is not possible\n"];
RETURN
}
};
value _ RequestValue[value];
CDProperties.PutProp[onto: what, prop: atom, val: value];
TerminalIO.WriteRope["  done\n"];
END;

ShowProperties: PROC [from: REF] =
BEGIN
WITH from SELECT FROM
a: CD.Instance => ShowPropertyList[a.properties];
o: CD.Object => ShowPropertyList[o.properties];
d: CD.Design => ShowPropertyList[d.properties^];
t: CD.Technology => ShowPropertyList[t.properties^];
ENDCASE => TerminalIO.WriteRope[" no showable CD properties"];
END;

ShowPropertyList: PROC [pl: CD.PropList] =
BEGIN
FOR list: CD.PropList _ pl, list.rest WHILE list#NIL DO
WITH list.first.key SELECT FROM
ra: REF ATOM => IF ra^=$MayBeRemoved THEN LOOP
ENDCASE => NULL;
ShowProperty[list.first];
ENDLOOP
END;

ShowProperty: PROC [pp: PropertyLists.KeyVal] =
BEGIN
TerminalIO.WriteRope["  name: "];
WriteValue[pp.key];
TerminalIO.WriteRope["  value: "];
WriteValue[pp.val];
TerminalIO.WriteLn[];
END;

ShowPropertiesSP: PROC [comm: CDSequencer.Command] =
BEGIN 
inst: CD.Instance _ CDCommandOps.TheInstance[comm, "show property lists"];
IF inst#NIL THEN {
IF inst.properties#NIL THEN {
TerminalIO.WriteRope["  --properties on instance\n"];
ShowPropertyList[inst.properties];
};
IF inst.ob.properties#NIL THEN {
TerminalIO.WriteRope["  --properties on object itself\n"];
ShowPropertyList[inst.ob.properties];
};
TerminalIO.WriteRope["  --\n"];
}
END;

ShowPropertiesDesign: PROC [comm: CDSequencer.Command] =
BEGIN 
TerminalIO.WriteRope["show properties of design\n"];
ShowPropertyList[comm.design.properties^];
TerminalIO.WriteRope["  --\n"];
END;

SaveComment: CDRopeViewer.SaveProc =
BEGIN
IF discard THEN RETURN;
CDProperties.PutProp[
onto: clientData, 
prop: $Tioga, 
val: NEW[ViewerTools.TiogaContentsRec_[contents: contents, formatting: formatting]]
]
END;

CommentDesignComm: PROC [comm: CDSequencer.Command] =
BEGIN 
TerminalIO.WriteRope["edit comment for design\n"];
CommentSome[what: comm.design, caption: Rope.Cat["[comment for ", comm.design.name, "]"]];
END;

CommentObComm: PROC [comm: CDSequencer.Command] =
BEGIN 
inst: CD.Instance _ CDCommandOps.TheInstance[comm, "comment object"];
IF inst#NIL THEN {
IF inst.ob.class.inDirectory THEN 
CommentSome[what: inst.ob, caption: Rope.Cat["Comment on ", CDOps.ObjectInfo[inst.ob]]]
ELSE TerminalIO.WriteRope["this object class has no comments\n"];
}
END;

CommentAppComm: PROC [comm: CDSequencer.Command] =
BEGIN 
inst: CD.Instance _ CDCommandOps.TheInstance[comm, "comment instance"];
IF inst#NIL THEN {
CommentSome[what: inst, caption: "comment some instance (ChipNDale)"];
}
END;

CommentSome: PROC [what: REF, caption: Rope.ROPE] =
BEGIN 
comment, formatting: Rope.ROPE _ NIL;
WITH CDProperties.GetProp[from: what, prop: $Tioga] SELECT FROM
t: ViewerTools.TiogaContents => {
comment _ t.contents;
formatting _ t.formatting;
};
r: Rope.ROPE => comment _ r;
ENDCASE => NULL; 
CDRopeViewer.Edit[contents: comment, formatting: formatting, caption: caption, save: SaveComment, clientData: what];
END;

NameMenuComm: PROC [comm: CDSequencer.Command] = {
m: PopUpMenus.Menu; x: REF;
inst: CD.Instance _ CDCommandOps.TheInstance[comm, "property and name menu"];
IF inst=NIL THEN m _ mD
ELSE IF inst.ob.class.inDirectory THEN m _ mFull
ELSE m _ mInst;
x _ PopUpMenus.Call[m, comm];
WITH x SELECT FROM
a: ATOM => CDSequencer.ExecuteCommand[comm: comm, key: a]
ENDCASE => NULL
};
IsExclusive: PROC [a: ATOM] RETURNS [BOOL_FALSE] = {
pType: CDProperties.PropertyProcs = CDProperties.FetchProcs[a];
IF pType#NIL THEN RETURN [pType.exclusive]
};

Register: PROC [n: NAT, key: ATOM, entry, doc: Rope.ROPE _ NIL] = {
[] _ PopUpMenus.Entry[mFull, entry, NIL, key, doc];
IF n<=1 THEN RETURN;
[] _ PopUpMenus.Entry[mInst, entry, NIL, key, doc];
IF n<=2 THEN RETURN;
[] _ PopUpMenus.Entry[mD, entry, NIL, key, doc];
};
mFull: PopUpMenus.Menu _ PopUpMenus.Create["Names & PropertyLists", NIL];
mInst: PopUpMenus.Menu _ PopUpMenus.Create["Names & PropertyLists", NIL];
mD: PopUpMenus.Menu _ PopUpMenus.Create["Names & PropertyLists", NIL];

CDSequencer.ImplementCommand[$CommentDesign, CommentDesignComm];
CDSequencer.ImplementCommand[$CommentApp, CommentAppComm];
CDSequencer.ImplementCommand[$CommentOb, CommentObComm];
CDSequencer.ImplementCommand[$SignalNameS, EnterSignalNameSP];
CDSequencer.ImplementCommand[$InstanceNameS, EnterInstanceNameSP];
CDSequencer.ImplementCommand[$PropertyDesign, PropertyDesign];
CDSequencer.ImplementCommand[$PropertyApp, PropertyApp];
CDSequencer.ImplementCommand[$PropertyOb, PropertyOb];
CDSequencer.ImplementCommand[$ShowPropertiesS, ShowPropertiesSP,, doQueue];
CDSequencer.ImplementCommand[$ShowPropertiesDesign, ShowPropertiesDesign,, doQueue];

Register[3, $RenameDesign, "rename design"];
Register[1, $RenameS, "rename object"];
Register[3, $PropertyDesign, "property (design)", "add/change a property"];
Register[2, $PropertyApp, "property (instance)", "add/change a property"];
Register[1, $PropertyOb, "property (object)", "add/change a property"];
Register[3, $CommentDesign, "comment (design)", "edit the comment view"];
Register[2, $CommentApp, "comment (instance)", "edit the comment view"];
Register[1, $CommentOb, "comment (object)", "edit the comment view"];
Register[2, $InstanceNameS, "instance-name", "accept an instancename"];
Register[2, $SignalNameS, "signal-name (instance)", "accept a signalname"];
Register[3, $ShowPropertiesDesign, "list prop (design)", "list properties hanging on design"];
Register[2, $ShowPropertiesS, "list prop (i&o)", "<N-left> | list properties of selected object"];
Register[3, $DisplayNames, "display signal-names", "<N-right> | signal names of all visible objects"];

CDSequencer.ImplementCommand[$NameMenu, NameMenuComm, , dontQueue];
END.

ðCDPropertyCommands.mesa   (part of ChipNDale)
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi,   November 7, 1983 5:39 pm 
Last edited by: Christian Jacobi, August 24, 1986 7:28:57 pm PDT
--if name = nil, property will be removed
--if name = nil, property will be removed
--XXX make public on next release; probably in CDCommandOps
--move this procedure to CDProperties
--l: CD.LayerRef => ...;
--at: ATOM => ...;



-- module initialization
�Êÿ˜
codeš
œ-™-Kšœ
Ïm
œ7™BKš
œ8™8K™@K˜—š
Ïk	˜	Kšœž
˜Kšžœ
˜K˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ
˜
Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ
žœžœ˜Kš
œ˜Kš
œ˜Kšœžœ#˜4—K˜šÐblœžœ
žœ
˜"Kšžœƒ
˜Š
—Kš
ž˜K˜K˜KšœžœžœÏc1˜OK˜šÏnœžœ
žœžœžœ
žœ˜3Kšžœžœžœ)˜VKšžœžœ
žœ˜2K˜—K˜š¡œžœ˜5Kšžœ
˜Kšœžœ?˜Gšžœžœ
žœ˜Kšœžœ
˜Kš
œ>˜>Kš
œ.˜.Kš
œ)™)Kšžœžœžœ
˜$Kš
œG˜GKšžœžœ
žœ"˜2Kšžœ%˜)K˜
—Kšžœ
˜—K˜š¡œžœ˜7Kšžœ
˜KšœžœA˜Išžœžœ
žœ˜Kšœžœ
˜Kš
œ>˜>Kš
œ.˜.Kš
œ)™)Kšžœžœžœ
˜$Kš
œI˜IKšžœžœ
žœ"˜2Kšžœ%˜)K˜
—Kšžœ
˜—K˜Kšœžœ˜Kš
œ;™;š¡
œžœžœ˜Kš
ž˜Kšžœžœžœ˜)Kšžœžœ
žœ˜*š
ž˜šžœžœ
ž˜Kšœžœ
žœžœ˜5Kšœžœ˜(Kšœžœ1˜8Kšœžœ4˜@Kšœžœ.žœžœ
žœžœ
˜^Kšœžœ6˜<Kšœžœ=˜CKš
œI˜Išžœ˜Kšžœ
žœžœžœ˜@Kšžœžœžœ
˜1———š
ž˜Kš
œ"˜"—Kšžœ
˜K˜—š
¡œžœžœžœžœ˜1Kš
ž˜Kšœžœ˜šžœž˜Kšœ2žœ:˜pšžœž˜
Kšœžœ˜Kšœžœ
žœ#˜:Kš
œ3˜3Kš
œ<˜<š
œ˜Kš
œ0˜0Kšœ
žœžœ
žœ'˜DKš
œ˜—Kšžœ
 œžœ˜—Kšžœ
˜—Kšžœ
˜Kšžœ
˜—K˜š¡œžœ˜2Kšžœ
˜Kš
œ8˜8Kš
œ˜Kšžœ
˜—K˜š¡œžœ˜/Kšžœ
˜KšœžœI˜QKšžœžœ
žœ˜'Kšžœ
˜—K˜š¡
œžœ˜.Kšžœ
˜KšœžœK˜Sšžœžœ
žœ
˜šžœžœžœ˜4Kš
œ˜šžœžœ
˜"Kš
œ2˜2—Kš
œ
˜
—KšžœO˜S—Kšžœ
˜—K˜š¡œžœžœ˜#Kšžœ
˜Kšœžœ
˜Kšœžœ;˜Ešžœžœ
žœ˜Kš
œ0˜0Kš
ž˜K˜—Kš
œ)˜)Kš
œ&˜&Kš
œ˜Kš
œ˜šžœžœ˜Kš
œN˜Nšžœžœ˜Kš
œ=˜=Kš
ž˜K˜
—K˜—Kš
œ˜Kš
œ9˜9Kš
œ!˜!Kšžœ
˜—K˜Kš
œ%™%š¡œžœžœ˜"Kš
ž˜šžœžœ
ž˜Kšœžœ,˜1Kšœžœ*˜/Kšœžœ+˜0Kšœžœ/˜4Kš
œ™Kšœžœ™Kšžœ7˜>—Kšžœ
˜—K˜š¡œžœžœ˜*Kš
ž˜š	žœžœžœžœ
ž˜7šžœžœ
ž˜Kš
œžœ
žœžœžœ
ž˜.Kšžœžœ
˜—Kš
œ˜Kš
ž˜—Kšžœ
˜K˜—š¡œžœ˜/Kš
ž˜Kš
œ!˜!Kš
œ˜Kš
œ"˜"Kš
œ˜Kš
œ˜Kšžœ
˜—K˜š¡œžœ˜4Kšžœ
˜KšœžœB˜Jšžœžœ
žœ˜šžœžœ
žœ˜Kš
œ5˜5Kš
œ"˜"K˜—šžœžœ
žœ˜ Kš
œ:˜:Kš
œ%˜%K˜—Kš
œ˜K˜
—Kšžœ
˜—K˜š¡œžœ˜8Kšžœ
˜Kš
œ4˜4Kš
œ*˜*Kš
œ˜Kšžœ
˜—K˜šÏbœ˜$Kš
ž˜Kšžœ	žœ
žœ
˜š
œ˜Kš
œ˜Kš
œ˜KšœžœK˜SKš
œ
˜
—Kšžœ
˜—K˜š¡œžœ˜5Kšžœ
˜Kš
œ2˜2Kš
œZ˜ZKšžœ
˜—K˜š¡
œžœ˜1Kšžœ
˜Kšœžœ=˜Ešžœžœ
žœ˜šžœžœ
˜"Kš
œW˜W—Kšžœ=˜AKš
œ
˜
—Kšžœ
˜—K˜š¡œžœ˜2Kšžœ
˜Kšœžœ?˜Gšžœžœ
žœ˜Kš
œF˜FKš
œ
˜
—Kšžœ
˜—K˜š¡œžœžœžœ˜3Kšžœ
˜Kšœžœžœ
˜%šžœ0žœ
ž˜?š
œ!˜!Kš
œ˜Kš
œ˜K˜—Kšœžœ˜Kšžœžœ˜—Kš
œt˜tKšžœ
˜—K˜š¡œžœ ˜2Kšœžœ
˜KšœžœE˜MKšžœžœ
žœ˜Kšžœ
žœžœ
˜0Kšžœ˜Kš
œ˜šžœžœ
ž˜Kšœžœ2˜9Kšžœž˜—Kš
œ˜—K™š¡œžœžœžœžœ
žœ˜4Kš
œ?˜?Kšžœžœ
žœ
žœ˜*Kš
œ˜—J˜š¡œžœžœžœžœžœ˜CKšœ$žœ˜3Kšžœžœ
žœ
˜Kšœ$žœ˜3Kšžœžœ
žœ
˜Kšœ!žœ˜0K˜—K™Kš
œI˜IKš
œI˜IKš
œF˜FK™Kš
œ™K˜Kš
œ@˜@Kš
œ:˜:Kš
œ8˜8Kš
œ>˜>Kš
œB˜BKš
œ>˜>Kš
œ8˜8Kš
œ6˜6Kš
œK˜KKš
œT˜TK˜Kš
œ,˜,Kš
œ'˜'Kš
œK˜KKš
œJ˜JKš
œG˜GKš
œI˜IKš
œH˜HKš
œE˜EKš
œG˜GKš
œK˜KKš
œ^˜^Kš
œb˜bKš
œf˜fK˜Kš
œC˜CKšžœ
˜—…—'j5Y