DIRECTORY
Ascii,
Atom,
CD,
CDBasics,
CDInstances,
CDLayers,
CDOps,
CDPanel,
CDPanelFonts,
CDPrivate,
CDSequencer,
CDTexts,
Rope,
TerminalIO;

CDTextsCommands: CEDAR MONITOR 
IMPORTS Ascii, Atom, CDBasics, CDInstances, CDLayers, CDOps, CDPanel, CDPanelFonts, CDSequencer, CDTexts, Rope, TerminalIO
SHARES CDTexts =
BEGIN

ROPE: TYPE = Rope.ROPE;
CDFont: TYPE = CDTexts.CDFont;

GetTextComm: PROC [comm: CDSequencer.Command] = {
inst: CD.Instance _ CDOps.TheInstance[comm.design, "load text into panel\n"];
IF inst#NIL THEN 
IF CDTexts.IsText[inst.ob] THEN {
tp: CDTexts.TextSpecific _ NARROW[inst.ob.specific];
CDPanelFonts.SetCurrentText[comm.design, tp.text];
}
ELSE TerminalIO.PutRope["failed: needs single text selection\n"];
};

GetFontComm: PROC [comm: CDSequencer.Command] = {
inst: CD.Instance _ CDOps.TheInstance[comm.design, "load font into panel\n"];
IF inst#NIL THEN 
IF CDTexts.IsText[inst.ob] THEN {
tp: CDTexts.TextSpecific _ NARROW[inst.ob.specific];
CDPanelFonts.SetCurrentFont[comm.design, tp.cdFont];
}
ELSE TerminalIO.PutRope["failed: needs single text selection\n"];
};

ReadDefaultFontComm: PROC [comm: CDSequencer.Command] = {
fontName: Rope.ROPE; scale: INT; font: CDTexts.CDFont;
TerminalIO.PutRope["input font name\n"];
fontName _ TerminalIO.RequestRope["  font name -> "];
scale _ TerminalIO.RequestInt["  pre scale factor*lambda -> "];
IF scale<=0 THEN TerminalIO.PutRope["  bad scale\n"]
ELSE {
font _ CDTexts.MakeFont[fontName, scale];
IF font=NIL 
THEN TerminalIO.PutRope["  failed\n"]
ELSE CDPanelFonts.SetCurrentFont[comm.design, font];
}
};

RemoveGarbage: PROC [line: Rope.ROPE] RETURNS [Rope.ROPE_NIL] = {
leng: INT _ Rope.Length[line];
start: INT _ 0;
WHILE start<leng DO
c: CHAR _ Rope.Fetch[line, start];
IF c=177C OR c<=40C THEN start _ start+1 ELSE EXIT;
ENDLOOP;
WHILE leng>start DO
c: CHAR _ Rope.Fetch[line, leng-1];
IF c=177C OR c<=40C THEN leng _ leng-1 ELSE EXIT;
ENDLOOP;
IF leng>start THEN RETURN [Rope.Substr[line, start, leng-start]];
};

InputText: PROC [design: CD.Design] RETURNS [r: Rope.ROPE] = {
r _ RemoveGarbage[CDPanelFonts.CurrentText[design]];
IF Rope.IsEmpty[r] THEN r _ TerminalIO.RequestRope["text >"];
};

DrawTextComm: PROC [comm: CDSequencer.Command] = {
ob: CD.Object; lay: CD.Layer; r: Rope.ROPE;
font: CDTexts.CDFont;
CDPanel.PutUpAll[comm.design]; -- to propagate the font right
font _ CDPanelFonts.CurrentFont[comm.design];
IF font=NIL THEN CDSequencer.Quit["** no font"];
IF comm.key=$DrawTextTerminal 
THEN r _ TerminalIO.RequestRope["create text >"]
ELSE r _ InputText[comm.design];
IF Rope.IsEmpty[r] THEN CDSequencer.Quit["empty text not included"];
lay _ CDLayers.CurrentLayer[comm.design]; 
lay _ CDPanelFonts.LayerForText[lay, comm.design.technology];
ob _ CDTexts.Create[text: r, font: font, layer: lay];
IF ob=NIL THEN CDSequencer.Quit["not done"];
[] _ CDOps.IncludeObjectI[comm.design, ob, comm.pos];
};

ReplaceTextComm: PROC [comm: CDSequencer.Command] = {
cnt: INT _ 0;  rect: CD.Rect;
newText: Rope.ROPE _ InputText[comm.design];
IF Rope.IsEmpty[newText] THEN {TerminalIO.PutRope["no text available\n"]; RETURN};
FOR il: CD.InstanceList _ CDOps.InstList[comm.design], il.rest WHILE il#NIL DO
IF il.first.selected AND CDTexts.IsText[il.first.ob] THEN {
tp: CDTexts.TextSpecific _ NARROW[il.first.ob.specific];
new: CD.Object _ CDTexts.Create[newText, tp.cdFont, il.first.ob.layer, CDTexts.IsFlipText[il.first.ob]];
IF new=NIL THEN LOOP;
cnt _ cnt + 1;
rect _ CDInstances.InstRectO[il.first];
il.first.ob _ new;
CDOps.Redraw[comm.design, CDBasics.Surround[rect, CDInstances.InstRectO[il.first]]];
}
ENDLOOP;
TerminalIO.PutF1["%g texts replaced\n", [integer[cnt]]];
};

SetFlip: PROC [design: CD.Design, flip: BOOL _ TRUE] RETURNS [cnt: INT_0] = {
FOR il: CD.InstanceList _ CDOps.InstList[design], il.rest WHILE il#NIL DO
IF il.first.selected AND CDTexts.IsText[il.first.ob] THEN  
IF (flip AND CDTexts.IsRigidText[il.first.ob]) OR (~flip AND CDTexts.IsFlipText[il.first.ob]) THEN {
ob: CD.Object _ CDTexts.Create[
text: NARROW[il.first.ob.specific, CDTexts.TextSpecific].text,
font: NARROW[il.first.ob.specific, CDTexts.TextSpecific].cdFont,
layer: il.first.ob.layer,
flip: flip
];
IF ob#NIL THEN il.first.ob _ ob;
cnt _ cnt+1
}
ENDLOOP; 
IF cnt>0 THEN CDOps.Redraw[design];
};

SetFlipComm: PROC [comm: CDSequencer.Command] = {
cnt: INT _ SetFlip[comm.design, TRUE];
TerminalIO.PutF["%g texts converted to flip mode\n", [integer[cnt]]]
};

SetRigidComm: PROC [comm: CDSequencer.Command] = {
cnt: INT _ SetFlip[comm.design, FALSE];
TerminalIO.PutF["%g texts converted to rigid mode\n", [integer[cnt]]];
};

ChangeSizeComm: PROC [comm: CDSequencer.Command] = {
up: BOOL _ Rope.Find[Atom.GetPName[comm.key], "double", 0, FALSE]>=0;
n: INT _ 0; 
FOR il: CD.InstanceList _ CDOps.InstList[comm.design], il.rest WHILE il#NIL DO
IF il.first.selected AND CDTexts.IsText[il.first.ob] THEN { 
tp: CDTexts.TextSpecific = NARROW[il.first.ob.specific];
oldSize: INT _ MIN[tp.cdFont.scaleI, 20000]; --large limit, prevent arithmetic overflow
newSize: INT _ MIN[(IF up THEN oldSize*2 ELSE (oldSize+1)/2), 10000B];
IF newSize#oldSize THEN {
newFont: CDTexts.CDFont _ CDTexts.MakeFont[tp.cdFont.supposedName, newSize];
IF newFont#NIL THEN 
IF SetInstanceFont[comm.design, il.first, newFont] THEN n _ n+1;
}
}
ENDLOOP;
TerminalIO.PutF["changed size for %g texts\n", [integer[n]]];
};

ChangeFontComm: PROC [comm: CDSequencer.Command] = {
n: INT _ 0; font: CDFont;
CDPanel.PutUpAll[comm.design];
font _ CDPanelFonts.CurrentFont[comm.design];
IF font=NIL THEN CDSequencer.Quit["** no font\n"];
FOR il: CD.InstanceList _ CDOps.InstList[comm.design], il.rest WHILE il#NIL DO
IF il.first.selected AND CDTexts.IsText[il.first.ob] THEN 
IF SetInstanceFont[comm.design, il.first, font] THEN n _ n+1;
ENDLOOP;
TerminalIO.PutF["font changed for %g texts\n", [integer[n]]];
};

ChangeItalic: PROC [fontName: ROPE, italic: BOOL] RETURNS [new: ROPE] = {
pressFontLeng: INT = 17; pressFontName: ROPE = "Xerox/PressFonts/";
tiogaFontLeng: INT = 17; tiogaFontName: ROPE = "Xerox/TiogaFonts/";
leng: INT _ Rope.Length[fontName];
new _ fontName;
IF leng>tiogaFontLeng THEN
IF Rope.Equal[Rope.Substr[fontName, 0, tiogaFontLeng], tiogaFontName, FALSE] THEN {
IF Rope.Equal[Rope.Substr[fontName, 0, tiogaFontLeng], tiogaFontName, FALSE] THEN {
IF italic THEN { 
IF Ascii.Upper[Rope.Fetch[fontName, leng-1]]='I THEN RETURN;
RETURN [Rope.Concat[fontName, "I"]];
}
ELSE {
IF Ascii.Upper[Rope.Fetch[fontName, leng-1]]#'I THEN RETURN;
RETURN [Rope.Substr[fontName, 0, leng-1]];
}
}
};
IF leng>pressFontLeng THEN
IF Rope.Equal[Rope.Substr[fontName, 0, pressFontLeng], pressFontName, FALSE] THEN {
IF italic THEN { 
IF Ascii.Upper[Rope.Fetch[fontName, leng-1]]='I THEN RETURN;
RETURN [Rope.Replace[fontName, leng-2, 1, "i"]];
}
ELSE {
IF Ascii.Upper[Rope.Fetch[fontName, leng-2]]#'I THEN RETURN;
RETURN [Rope.Replace[fontName, leng-2, 1, "r"]];
}
}
};

SetInstanceFont: PROC [design: CD.Design, text: CD.Instance, font: CDFont] RETURNS [ok: BOOL_FALSE] = {
IF font#NIL THEN {
ob: CD.Object _ CDTexts.Create[
text: NARROW[text.ob.specific, CDTexts.TextSpecific].text,
font: font,
layer: text.ob.layer,
flip: CDTexts.IsFlipText[text.ob]];
CDOps.RedrawInstance[design, text];
IF ob#NIL THEN {text.ob _ ob; ok _ TRUE};
CDOps.RedrawInstance[design, text, FALSE];
}
};

SetItalicIzation: PROC [design: CD.Design, comment: BOOL] = {
n: INT _ 0;
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF CDTexts.IsText[w.first.ob] AND w.first.selected THEN {
textPtr: CDTexts.TextSpecific _ NARROW[w.first.ob.specific];
oldFontName: ROPE _ textPtr.cdFont.supposedName;
newFontName: ROPE _ ChangeItalic[oldFontName, comment];
IF ~Rope.Equal[oldFontName, newFontName] THEN { 
font: CDFont _ CDTexts.MakeFont[newFontName, textPtr.cdFont.scaleI];
IF SetInstanceFont[design, w.first, font] THEN n _ n+1;
}
}
ENDLOOP;
TerminalIO.PutF["comment property changed for %g texts\n", [integer[n]]];
};

MakeComment: PROC [comm: CDSequencer.Command] = {
SetItalicIzation[comm.design, TRUE]
};

UnMakeComment: PROC [comm: CDSequencer.Command] = {
SetItalicIzation[comm.design, FALSE]
};

CDSequencer.ImplementCommand[$DrawTextTerminal, DrawTextComm];
CDSequencer.ImplementCommand[$DrawText, DrawTextComm];
CDSequencer.ImplementCommand[$ChangeFont, ChangeFontComm];
CDSequencer.ImplementCommand[$CDTextsDoubleSize, ChangeSizeComm];
CDSequencer.ImplementCommand[$CDTextsHalfSize, ChangeSizeComm];
CDSequencer.ImplementCommand[$CDTextsRigid, SetRigidComm];
CDSequencer.ImplementCommand[$CDTextsFlip, SetFlipComm];
CDSequencer.ImplementCommand[$MakeComment, MakeComment];
CDSequencer.ImplementCommand[$UnMakeComment, UnMakeComment];
CDSequencer.ImplementCommand[$GetText, GetTextComm,, doQueue];
CDSequencer.ImplementCommand[$GetFont, GetFontComm,, doQueue];
CDSequencer.ImplementCommand[$ChangeText, ReplaceTextComm];
CDSequencer.ImplementCommand[$ReadFont, ReadDefaultFontComm];
END. 

zCDTextsCommands.mesa  (part of ChipNDale)
Copyright c 1983, 1985, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, June 24, 1983 5:03 pm 
Last edited by: Giordano Beretta, April 8, 1986 5:46:03 pm PST
Last edited by: Christian Jacobi, March 17, 1987 6:05:57 pm PST
--smaller, binary limit to make going back [after hitting upper limit] nice

Κ
g˜
codeš
œ)™)Kšœ
Οm
œ=™HKš
œ3™3K™>K™?—K˜š
Οk	˜	Kš
œ˜Kšœž
˜Kšžœ
˜K˜	K˜K˜	Kš
œ˜K˜Kš
œ
˜
Kš
œ
˜
Kš
œ˜K˜Kš
œ˜Kš
œ˜K˜—šΟnœžœ
žœ
˜Kšžœs˜zKšžœ
˜—Kš
ž˜K˜Kšžœžœžœ
˜Kšœžœ˜K˜šŸœžœ ˜1KšœžœE˜Mšžœžœ
žœ
˜šžœžœ˜!Kšœžœ˜4Kš
œ2˜2K˜
—Kšžœ=˜A—Kš
œ˜—K˜šŸœžœ ˜1KšœžœE˜Mšžœžœ
žœ
˜šžœžœ˜!Kšœžœ˜4Kš
œ4˜4K˜
—Kšžœ=˜A—Kš
œ˜—K˜šŸœžœ ˜9Kšœžœ	žœ˜6Kš
œ(˜(Kš
œ5˜5Kš
œ?˜?Kšžœ
žœ$˜4šžœ˜Kš
œ)˜)šžœžœ
˜Kšžœ!˜%Kšžœ0˜4—K˜
—Kš
œ˜—K˜šŸ
œžœ
žœžœžœ
žœ˜AKšœžœ˜Kšœžœ˜šžœž˜Kšœžœ˜"Kš
žœžœžœžœ
žœ
˜3Kšžœ
˜—šžœž˜Kšœžœ˜#Kš
žœžœžœžœ
žœ
˜1Kšžœ
˜—Kšžœžœ
žœ(˜AK˜—K˜š
Ÿ	œžœ
žœ	žœ
žœ˜>Kš
œ4˜4Kšžœžœ&˜=Kš
œ˜—K˜šŸœžœ ˜2Kšœžœžœžœ
˜+Kš
œ˜KšœΟc˜=Kš
œ-˜-Kšžœžœ
žœ ˜0šžœ˜Kšžœ,˜0Kšžœ˜ —Kšžœžœ-˜DKš
œ*˜*Kš
œ=˜=Kš
œ5˜5Kšžœžœ
žœ˜,Kš
œ5˜5Kš
œ˜—K˜šŸœžœ ˜5Kšœžœ
žœ˜Kšœžœ˜,Kšžœžœ-žœ˜Rš	žœžœ5žœžœ
ž˜Nšžœžœžœ˜;Kšœžœ˜8Kšœžœa˜hKšžœžœ
žœ
žœ
˜K˜Kš
œ'˜'Kš
œ˜Kš
œT˜TK˜
—Kšžœ
˜—Kš
œ8˜8Kš
œ˜—K˜šŸœžœ
žœžœžœžœžœ˜Mš	žœžœ0žœžœ
ž˜Išžœžœžœ˜;š
žœžœ#žœžœ"žœ˜dšœžœ˜Kšœžœ2˜>Kšœžœ4˜@Kš
œ˜Kš
œ
˜
Kš
œ˜—Kšžœžœ
žœ˜ Kš
œ˜Kš
œ
˜
——Kšžœ˜	—Kšžœžœ˜#Kš
œ˜—K˜šŸœžœ ˜1Kšœžœžœ˜&Kš
œD˜DK˜—K˜šŸœžœ ˜2Kšœžœžœ˜'Kš
œF˜FK˜—K˜šŸœžœ ˜4Kšœžœ3žœ˜EKšœžœ˜š	žœžœ5žœžœ
ž˜Nšžœžœžœ˜<Kšœžœ˜8Kšœ	žœžœ *˜Wšœ	žœžœžœžœžœ˜FKš +œ
 œ
 ™K—šžœžœ˜Kš
œL˜Lšžœ	žœ
žœ
˜Kšžœ1žœ	˜@—K˜
—K˜
—Kšžœ
˜—Kš
œ=˜=Kš
œ˜—K˜šŸœžœ ˜4Kšœžœ˜Kš
œ˜Kš
œ-˜-Kšžœžœ
žœ"˜2š	žœžœ5žœžœ
ž˜Nšžœžœžœ
˜:Kšžœ.žœ	˜=—Kšžœ
˜—Kš
œ=˜=Kš
œ˜—K˜šŸœžœžœ
žœžœžœ˜IKšœžœžœ˜CKšœžœžœ˜CKšœžœ˜"Kš
œ˜šžœž˜šžœDžœžœ˜SšžœDžœžœ˜Sšžœžœ˜Kšžœ.žœ
žœ
˜<Jšžœ˜$J˜
—šžœ˜Jšžœ.žœ
žœ
˜<Jšžœ$˜*J˜
—K˜
—Jš
œ˜——šžœž˜šžœDžœžœ˜Sšžœžœ˜Kšžœ.žœ
žœ
˜<Jšžœ*˜0J˜
—šžœ˜Jšžœ.žœ
žœ
˜<Jšžœ*˜0J˜
—K˜
——K˜—K˜šŸœžœ
žœžœžœžœ
žœ˜gšžœžœ
žœ˜šœžœ˜Kšœžœ.˜:Kš
œ˜Kš
œ˜Kš
œ#˜#—Kš
œ#˜#Kšžœžœ
žœžœ˜)Kšœ#žœ˜*K˜
—K˜—K˜šŸœžœ
žœžœ˜=Kšœžœ˜š	žœžœ/žœžœ
ž˜Fšžœžœžœ˜9Kšœ žœ˜<Kšœ
žœ˜0Kšœ
žœ&˜7šžœ'žœ˜0Kš
œD˜DKšžœ(žœ	˜7K˜
—K˜
—Kšžœ
˜—Kš
œI˜IK˜—K˜šŸœžœ ˜1Kšœžœ
˜#K˜—K˜šŸ
œžœ ˜3Kšœžœ
˜$K˜—K˜Kš
œ>˜>Kš
œ6˜6Kš
œ:˜:Kš
œA˜AKš
œ?˜?Kš
œ:˜:Kš
œ8˜8Kš
œ8˜8Kš
œ<˜<Kš
œ>˜>Kš
œ>˜>Kš
œ;˜;Kš
œ=˜=Kšžœ˜K™—…—"Φ.·