DIRECTORY
Basics,
Buttons,
CD,
CDCommandOps,
CDColors,
CDIO,
CDSequencer,
CMos,
Commander,
Containers,
Convert,
Imager,
ImagerColor,
ImagerColorMap,
ImagerDitherContext,
ImagerTerminal,
InterminalBackdoor,
Icons,
Labels,
MessageWindow,
PopUpSelection,
Process,
Real,
Rope,
Sliders,
Terminal,
TerminalIO,
UserProfile,
ViewerOps,
ViewerClasses,
ViewerPrivate,
WindowManager;

CMosA8BitColors: CEDAR PROGRAM
IMPORTS Basics, Buttons, CDCommandOps, CDColors, CDIO, CDSequencer, CMos, Commander, Containers, Convert, Icons, ImagerColor, ImagerColorMap, ImagerDitherContext, ImagerTerminal, InterminalBackdoor, Labels, MessageWindow, PopUpSelection, Process, Real, Rope, Sliders, Terminal, TerminalIO, UserProfile, ViewerOps, ViewerPrivate, WindowManager =
BEGIN
terminal: Terminal.Virtual _ InterminalBackdoor.terminal;

useMapEntries: ImagerDitherContext.MapEntries _ NIL;

ContextCreator: ViewerPrivate.ContextCreatorProc =
BEGIN
context: Imager.Context;
SELECT screen FROM
bw => context _ ImagerTerminal.BWContext[vt: terminal, pixelUnits: TRUE];
color => {
context _ ImagerTerminal.ColorContext[vt: terminal, pixelUnits: TRUE];
IF useMapEntries#NIL THEN 
ImagerDitherContext.SetDitherMap[context, useMapEntries];
[] _ Terminal.SetColorCursorPresentation[terminal, onesAreWhite];
}
ENDCASE => ERROR;
RETURN [context]
END;

ForceColors: PROC [mapEntries: ImagerDitherContext.MapEntries] =
BEGIN
useMapEntries _ mapEntries;
ImagerColorMap.LoadEntries[vt: terminal, mapEntries: mapEntries, gamma: 1, shared: FALSE];
[] _ Terminal.SetColorCursorPresentation[terminal, onesAreWhite];
[] _ ViewerPrivate.SetCreator[ContextCreator];
END;

CallMenu: Buttons.ButtonProc =
BEGIN
p: CDSequencer.CommandProc _ CDSequencer.FetchCommand[$ColorDisplayMenuC, technology].proc;
IF p#NIL THEN p[NIL];
END;


ColorRec: TYPE = RECORD[r, g, b, w: REAL _ 0, name: Rope.ROPE _ NIL];

ColorDescRep: TYPE = ARRAY [0..numberOfColors) OF ColorRec;

Exception: TYPE = RECORD [x: CARDINAL, c: ColorRec, replace: BOOL _ TRUE];



technology: CD.Technology _ CMos.cmos;
technologyName: Rope.ROPE _ technology.name;
numberOfColors: INT = 9; --background, normal colors and extra colors
numberOfNormalColors: INT = 7; --without background and extra colors

cDefaults: REF ColorDescRep _ NEW[ColorDescRep _ [
[0.49, 0.62, 0.62, 0.05, "Sub"], --background
[0, 1, 0, 1, "pD"], 
[0, 1, 0, 1, "nD"], 
[0.5, 0.5, 1, 0.5, "m1"], 
[0.7, 0.4, 0.7, 0.4, "m2"], 
[1, 0.2, 0, 1, "pol"], 
[0.8, 0.8, 0.5, 0.15, "nW"], 
[0.60, 0.70, 0.75, 0.15, "pW"], 
[1, 0.95, 0.0, 0.9, "Xx"] --channel hack
]];

channelX: INT _ 8;

SetupSpecials: PROC [] =
BEGIN
cc: ColorRec _ currentColor[8]; --channel hack
x: INT _ channelX+1;

specials1 _ LIST[
[x: 1+16, c: [cc.r, cc.g, -cc.b, x*cc.w-1], replace: FALSE], --yellow on transistor
[x: 2+16, c: [cc.r, cc.g, -cc.b, x*cc.w-1], replace: FALSE], --yellow on transistor
[x:  32+64, c: [1, 1, 1, 1], replace: TRUE], --hack white error message 
[x:  1+32, c: [1, 1, 1, 1], replace: TRUE], --hack white error message 
[x:  2+64, c: [1, 1, 1, 1], replace: TRUE], --hack white error message 
[x:  127, c: [0, 0, 0, 1], replace: TRUE] --black for cuts 
];

specials2 _ LIST[
[x: 2, c: [1, 1, 1, 1], replace: TRUE], --pdiff without well
[x: 1+2, c: [0.8, 0.8, 0.8, 1], replace: TRUE] --light grey for inverted white
];

specials3 _ LIST[
[x: 245, c: [0, 0, 1, 1]], --get all nice colors back for other users
[x: 247, c: [0, 1, 0, 1]], 
[x: 249, c: [0, 1, 1, 1]],
[x: 250, c: [1, 0, 1, 1]],
[x: 251, c: [1, 1, 0, 1]],
[x: 252, c: [1, 1, 1, 1]], --white as opposite to 1+2
[x: 254, c: [1, 0, 0, 1]],
IF whiteOutLine  THEN Exception[x: 255, c: [1, 1, 1, 1]]
ELSE Exception[x: 255, c: [0, 0, 0, 1]] --all bits set
];

END;

Init8Patterns: Buttons.ButtonProc =
BEGIN
nDiffColor: CARDINAL = 1;
pDiffColor: CARDINAL = 2;
met1Color: CARDINAL = 4;
met2Color: CARDINAL = 8;
polyColor: CARDINAL = 16;
nWellColor: CARDINAL = 32;
pWellColor: CARDINAL = 64;
black: CARDINAL = 127;

Checker8: PROC[col1, col2: CARDINAL] RETURNS[REF CDColors.Brick] = 
BEGIN 
RETURN[NEW[CDColors.Brick _ [col1*256+col2, col2*256+col1, col1*256+col2, col2*256+col1]]]
END;

DefineDimmer8: PROC[lev: CD.Layer, color: CARDINAL] = 
BEGIN 
CDColors.DefineColor[lev, Checker8[color, 0], bit8, pushedOut];
END;

Full8: PROC[color: CARDINAL] RETURNS [b: REF CDColors.Brick] = 
BEGIN
RETURN[Checker8[color, color]]
END;

CDColors.DefineColor[CMos.ndif, Full8[nDiffColor], bit8];
CDColors.DefineColor[CMos.pdif, Full8[pDiffColor], bit8];
CDColors.DefineColor[CMos.met, Full8[met1Color], bit8];
CDColors.DefineColor[CMos.met2, Full8[met2Color], bit8]; 
CDColors.DefineColor[CMos.pol, Full8[polyColor], bit8];
CDColors.DefineColor[CMos.nwell, Full8[nWellColor], bit8];
CDColors.DefineColor[CMos.pwell, Full8[pWellColor], bit8];
CDColors.DefineColor[CMos.cut, Full8[black], bit8];

CDColors.DefineColor[CMos.cut2, Checker8[black, met1Color], bit8];
CDColors.DefineColor[CMos.bur, Checker8[black, 0], bit8];
CDColors.DefineColor[CMos.nwellCont, Checker8[pDiffColor, met1Color], bit8];
CDColors.DefineColor[CMos.pwellCont, Checker8[nDiffColor, met1Color], bit8];
CDColors.DefineColor[CMos.ovg, Checker8[met1Color, met2Color], bit8];

CDColors.DefineColor[CMos.imp, NEW[CDColors.Brick_[14, 14, 0, 0]], bit8];

CDColors.DefineColor[CD.backgroundLayer, NEW[CDColors.Brick _ [8, 0, 256*8, 0]], bit8];
CDColors.DefineColor[CD.errorLayer, NEW[CDColors.Brick _ [255, 0, 0, 0]], bit8];
CDColors.DefineColor[CD.shadeLayer, NEW[CDColors.Brick_[0, 255,0 , 255]], bit8];

DefineDimmer8[CMos.ndif, nDiffColor];
DefineDimmer8[CMos.pdif, pDiffColor];
DefineDimmer8[CMos.met, met1Color];
DefineDimmer8[CMos.met2, met2Color];
DefineDimmer8[CMos.pol, polyColor];
DefineDimmer8[CMos.nwell, nWellColor];
DefineDimmer8[CMos.cut, black];
DefineDimmer8[CMos.cut2, black];
END;

HackContextColors: PROC [] =
BEGIN
SetFilter[CMos.ndif, 1];
SetFilter[CMos.pdif, 2];
SetFilter[CMos.met, 3];
SetFilter[CMos.met2, 4];
SetFilter[CMos.pol, 5];
SetFilter[CMos.nwell, 6];
SetFilter[CMos.pwell, 7];
END;


whiteOutLine: BOOL;
currentColor: REF ColorDescRep = NEW[ColorDescRep]; 

curLayer: INT _ 1;
prevLayer: INT _ 1; -- to deselect the previous layer button
CoefSlider: TYPE = RECORD [
value: Labels.Label _ NIL,
select: Buttons.Button _ NIL,
bar: Sliders.Slider _ NIL
];

ColorSlider: TYPE = RECORD [
value: Labels.Label _ NIL,
bar: Sliders.Slider _ NIL
];

Handle: TYPE = REF AdjustColorRec;
AdjustColorRec: TYPE = RECORD [
outer: Containers.Container _ NIL,
coefLayer: ARRAY [0..numberOfColors) OF CoefSlider,
potarColor: ARRAY [0..3) OF ColorSlider,
height: CARDINAL _ 0		-- height measured from the top of the container
];

DataForSpecialProc: TYPE = REF DataForSpecialProcRec;
DataForSpecialProcRec: TYPE = RECORD [
my: Handle,
layer: CARDINAL
];

caption: Rope.ROPE = Rope.Concat[technologyName, " 8 bit color editor"];

ColorModeIs8: PROC [] RETURNS [BOOL] = INLINE 
BEGIN
RETURN [terminal.hasColorDisplay AND ~terminal.GetColorMode[].full AND terminal.GetColorMode[].bitsPerPixelChannelA=8];
END;

Check8BitMode: PROC [] RETURNS [ok: BOOL] =
BEGIN
ok _ ColorModeIs8[];
IF ~ok THEN
TRUSTED{Process.Detach[FORK TerminalIO.PutRope["Put the display in 8 bit per pixel mode first\n"]]};
END;

UpdateWeightSlider: Sliders.SliderProc =
BEGIN 
datac: DataForSpecialProc _ NARROW[clientData];
my: Handle _ datac.my;
layer: CARDINAL _ datac.layer;
IF ~ColorModeIs8[] THEN RETURN;
currentColor[layer].w _ value;
ComputeColors[];
Labels.Set[my.coefLayer[layer].value, Convert.RopeFromInt[Real.Fix[value*100]]];
END;

UpdateColorSlider: Sliders.SliderProc =
BEGIN 
data: DataForSpecialProc _ NARROW[clientData];
my: Handle _ data.my;
layer: CARDINAL _ data.layer;
IF ~ColorModeIs8[] THEN RETURN;
Labels.Set[my.potarColor[layer].value, Convert.RopeFromInt[Real.Fix[value*100]]];
SELECT layer FROM
0 => currentColor[curLayer-1].r _ value;
1 => currentColor[curLayer-1].g _ value;
2 => currentColor[curLayer-1].b _ value;
ENDCASE => ERROR;
ComputeColors[];
END;

ResetButton: Buttons.ButtonProc =
BEGIN
Init8Patterns[parent: parent, clientData: clientData];
ResetMapButton[parent: parent, clientData: clientData];
END;

XSelection: Buttons.ButtonProc =
BEGIN
whiteOutLine _ ~whiteOutLine;
ComputeColors[];
END;

ResetAndCreateButton: Buttons.ButtonProc =
BEGIN
viewer: ViewerClasses.Viewer _ ViewerOps.FindViewer[caption];
IF viewer=NIL THEN { 
IF mouseButton=yellow THEN CallMenu[NIL] 
ELSE {
IF Terminal.LegalColorMode[terminal, [FALSE, 8, 0]] AND ~ColorModeIs8[] THEN {
pos: WindowManager.ScreenPos _ left;
IF Rope.Equal["right", UserProfile.Token[key: "ColorDisplay.Side"], FALSE] THEN 
pos _ right;
WindowManager.StartColorViewers[screenPos: pos, bitsPerPixel: 8];
};
ResetButton[parent: parent];
IF mouseButton=blue THEN CreateAnInstance[];
}
}
ELSE { 
IF viewer.iconic THEN ViewerOps.OpenIcon[viewer]
ELSE MessageWindow.Append["use the color editor tool", TRUE];
};
END;


ResetMapButton: Buttons.ButtonProc =
BEGIN

UpdateAllSliders: PROC [my: Handle] =
BEGIN
w: Sliders.NormalizedSliderValue;
IF my=NIL OR my.outer=NIL OR my.outer.destroyed THEN RETURN;
FOR layer: INT IN [0..numberOfColors) DO
w _ currentColor[layer].w;
Sliders.SetContents[my.coefLayer[layer].bar, 0];
Sliders.SetContents[my.coefLayer[layer].bar, w];
Labels.Set[my.coefLayer[layer].value,
		Convert.RopeFromInt[Real.Fix[currentColor[layer].w*100]]];
ENDLOOP;
ButtonProcLayerInternal[0, my];
END;
IF Check8BitMode[] THEN {
ReadProfileColors[];
ComputeColors[];
IF clientData#NIL THEN UpdateAllSliders[NARROW[clientData, Handle]];
};
END;

ButtonProcLayer: Buttons.ButtonProc =
BEGIN
data: DataForSpecialProc _ NARROW[clientData];
IF Check8BitMode[] THEN {
ButtonProcLayerInternal[data.layer, data.my];
}
END;

ButtonProcLayerInternal:  PROC[layer: CARDINAL, my: Handle] =
BEGIN

SetPotar: PROC[layer: CARDINAL, my: Handle] =
BEGIN
Sliders.SetContents[my.potarColor[0].bar, currentColor[layer].r];
Sliders.SetContents[my.potarColor[1].bar, currentColor[layer].g];
Sliders.SetContents[my.potarColor[2].bar, currentColor[layer].b];
Labels.Set[my.potarColor[0].value, Convert.RopeFromInt[Real.Fix[currentColor[layer].r*100]]];
Labels.Set[my.potarColor[1].value, Convert.RopeFromInt[Real.Fix[currentColor[layer].g*100]]];
Labels.Set[my.potarColor[2].value, Convert.RopeFromInt[Real.Fix[currentColor[layer].b*100]]];
END;
curLayer _ layer+1;
SetPotar[layer, my];
Buttons.SetDisplayStyle[my.coefLayer[prevLayer-1].select, $BlackOnWhite];
Buttons.SetDisplayStyle[my.coefLayer[curLayer-1].select, $WhiteOnBlack];
prevLayer _ curLayer;
END;

CreateAnInstance: PROC[] =
BEGIN
nameColorSlider: ARRAY [0..3) OF Rope.ROPE _ ["R", "G", "B"];

coefX: CARDINAL = 10;
coefDX: CARDINAL = 25;
coefDeltaX: CARDINAL = coefDX+4;
coefSelectY: CARDINAL = 3;
coefSelectDY: CARDINAL = 15;
coefValueY: CARDINAL = coefSelectY+coefSelectDY+3;
coefValueDY: CARDINAL = 15;
coefBarY: CARDINAL = coefValueY+coefValueDY;

firstButtonY: CARDINAL = 3;
buttonX: CARDINAL = coefX+numberOfColors*coefDeltaX+8;
buttonDX: CARDINAL = 80;

firstSliderY: CARDINAL = 6;
sliderDY: CARDINAL = 22;
interSliderY: CARDINAL = 6;
labelX: CARDINAL = buttonX+buttonDX+10;  -- R, G, B
labelDX: CARDINAL = 14;
label2X: CARDINAL = labelX+labelDX;  -- number
label2DX: CARDINAL = 30;
sliderX: CARDINAL = label2X+label2DX;

my: Handle = NEW[AdjustColorRec];
buttonWy: CARDINAL _ firstButtonY;

NextButton: PROC [name: Rope.ROPE, proc: Buttons.ButtonProc] =
BEGIN
buttonDY: CARDINAL = 15;
interButtonY: CARDINAL = 2;
[] _ Buttons.Create[
info: [name: name,
wx: buttonX,
wy: buttonWy,
wh: buttonDY,
ww: buttonDX,
parent: my.outer,
border: TRUE],
proc: proc,
clientData: my,
fork: TRUE
];	
buttonWy _ buttonWy+buttonDY+interButtonY;
END;

IF ~ColorModeIs8[] THEN 
TerminalIO.PutRope["The 8 bit color tool works only after setting the display in 8 bit mode\n"];
IF ViewerOps.FindViewer[caption]#NIL THEN { 
TerminalIO.PutRope[caption];
TerminalIO.PutRope[" viewer already exits\n"];
RETURN
};
my.outer _ Containers.Create[[
name: caption,
iconic: TRUE,
icon: Icons.NewIconFromFile[CDIO.GetWorkingDirectory[NIL].Cat["Chipndale.icons"], 2],
column: left,
scrollable: FALSE 
]];
my.height _ firstSliderY+3*(sliderDY+interSliderY);
FOR curLayer: INT IN [0..numberOfColors) DO
wInit: REAL _ currentColor[curLayer].w;
my.coefLayer[curLayer].select _ Buttons.Create[
info: [
name: cDefaults[curLayer].name,
iconic: TRUE,
wx: coefX+curLayer*coefDeltaX,
wy: coefSelectY,
wh: coefSelectDY,
ww: coefDX,
parent: my.outer,
border: TRUE],
proc: ButtonProcLayer,
clientData: NEW[DataForSpecialProcRec _ [my: my, layer: curLayer]]
];	
my.coefLayer[curLayer].value _ Labels.Create[ [
name: Convert.RopeFromInt[Real.Fix[wInit*100]],	-- initial contents
iconic: TRUE,
wx: coefX+curLayer*coefDeltaX,
wy: coefValueY,
wh: coefValueDY,
ww: coefDX,
parent: my.outer,
border: TRUE
]];
my.coefLayer[curLayer].bar _ Sliders.Create[
info: [ 
name: cDefaults[curLayer].name,
iconic: TRUE,
parent: my.outer,
wx: coefX+curLayer*coefDeltaX,
wy: coefBarY,
wh: -5, --guardY
ww: coefDX,
border: TRUE],
sliderProc: UpdateWeightSlider,
orientation: vertical,
value: wInit,
clientData: NEW[DataForSpecialProcRec _ [my: my, layer: curLayer]
]];
Containers.ChildYBound[my.outer, my.coefLayer[curLayer].bar];
ENDLOOP;
NextButton["reset all", ResetButton];
NextButton["reset map", ResetMapButton];
NextButton["reset pattern", Init8Patterns];
NextButton["X Selection", XSelection];
NextButton["Menu", CallMenu];
FOR iColor: CARDINAL IN [0..3) DO
cInit: REAL _ SELECT iColor FROM
0 => currentColor[curLayer-1].r,
1 => currentColor[curLayer-1].g,
2 => currentColor[curLayer-1].b,
ENDCASE => ERROR;
[] _ Labels.Create[
info: [name: nameColorSlider[iColor],
parent: my.outer,
wx: labelX,
wy: firstSliderY+iColor*(sliderDY+interSliderY),
ww: labelDX,
wh: sliderDY,
border: TRUE
]];
my.potarColor[iColor].bar _ Sliders.Create[
info: [parent: my.outer,
wx: sliderX,
wy: firstSliderY+iColor*(sliderDY+interSliderY),
ww: 10,
wh: sliderDY],
sliderProc: UpdateColorSlider,
orientation: horizontal,
value: cInit,
clientData: NEW[DataForSpecialProcRec _ [my: my, layer: iColor]]
];
Containers.ChildXBound[my.outer, my.potarColor[iColor].bar];
my.potarColor[iColor].value _ Labels.Create[[
name: Convert.RopeFromInt[Real.Fix[cInit*100]],	-- initial contents
wx: label2X,
wy: firstSliderY+iColor*(sliderDY+interSliderY),
ww: label2DX,
wh: sliderDY,
parent: my.outer,
border: TRUE
]];
ENDLOOP;

ViewerOps.SetOpenHeight[my.outer, my.height];	-- hint our desired height
ViewerOps.PaintViewer[my.outer, all];				-- reflect above change
Buttons.SetDisplayStyle[my.coefLayer[0].select, $WhiteOnBlack];
END;

SaturationComm: CDSequencer.CommandProc =
BEGIN  
sat: CARDINAL _ 1;
IF Check8BitMode[] THEN {
list: LIST OF Rope.ROPE _ LIST["from profile"];
FOR i: INT DECREASING IN [0..numberOfColors) DO
list _ CONS[cDefaults[i].name, list]
ENDLOOP;
curLayer _ PopUpSelection.Request[header: "Layers", choice: list];
IF curLayer=0 THEN RETURN[];
IF curLayer<=numberOfColors THEN {
sat  _ PopUpSelection.Request[
header: "Values",
choice: LIST["Invisible", "1", "2", "3", "4", "5", "6", "7", "8", "9", "Saturated"] 
];
IF sat = 0 THEN RETURN[];
currentColor[curLayer-1].w _ Real.Float[sat-1]/10;
}
ELSE ReadProfileColors[];
ComputeColors[];
};
END;


specials1: LIST OF Exception _ NIL; --specials in the range of stipples [use for any comb] 
specials2: LIST OF Exception _ NIL; --specials in the range of stipples [use for exact comb]
specials3: LIST OF Exception _ NIL; --specials to be considered later


ComputeColors: PROC[] =
BEGIN

ComposeColor: PROC[c1, wc2: ColorRec] RETURNS [c: ColorRec] = 
INLINE BEGIN
w: REAL _ wc2.w;
c _ [c1.r+w*wc2.r, c1.g+w*wc2.g, c1.b+w*wc2.b, c1.w+w]
END;

SetMap: PROC[index: CARDINAL, color: ColorRec] = 
BEGIN
RtoC: PROC [r: REAL] RETURNS [c: [0..256)] = INLINE {
c _ MAX[MIN[Real.Round[r*255], 255], 0]
};
mapEntrie: ImagerColorMap.MapEntry _ [index, RtoC[color.r], RtoC[color.g], RtoC[color.b]];
mapEntries _ CONS[mapEntrie, mapEntries];
END;

mapEntries: LIST OF ImagerColorMap.MapEntry _ NIL;
c: ColorRec;
bits: CARDINAL _ numberOfNormalColors;
power: CARDINAL _ Basics.BITSHIFT[1, bits];

IF ~ColorModeIs8[] THEN RETURN;
SetupSpecials[];
FOR i: CARDINAL IN [0..power) DO
c _ [0, 0, 0, 0]; 
FOR bit: CARDINAL IN [0..bits) DO
IF Basics.BITAND[i, Basics.BITSHIFT[1, bit]]#0 THEN {
c _ ComposeColor[c, currentColor[bit+1]];
};
ENDLOOP;
FOR list: LIST OF Exception _ specials1, list.rest WHILE list#NIL DO
IF Basics.BITAND[i, list.first.x]=list.first.x THEN {
IF list.first.replace THEN c _ list.first.c 
ELSE c _ ComposeColor[c, list.first.c];
};
ENDLOOP;
FOR list: LIST OF Exception _ specials2, list.rest WHILE list#NIL DO
IF i=list.first.x THEN {
IF list.first.replace THEN c _ list.first.c 
ELSE c _ ComposeColor[c, list.first.c];
};
ENDLOOP;
IF c.w<0.2 THEN c _ ComposeColor[c, currentColor[0]];
IF c.w=0 THEN c _ currentColor[0]
ELSE c _ [c.r/c.w, c.g/c.w, c.b/c.w, 0];
SetMap[i, c];
ENDLOOP;
FOR list: LIST OF Exception _ specials3, list.rest WHILE list#NIL DO
IF list.first.x>=power THEN SetMap[list.first.x, list.first.c];
ENDLOOP;
ForceColors[mapEntries: mapEntries];
HackContextColors[];
END;

SetFilter: PROC [layer: CD.Layer, i: INT] = {
CDColors.DefineIColor[layer: layer, 
col: ImagerColor.ColorFromRGB[[R: currentColor[i].r, G: currentColor[i].g, B: currentColor[i].b]],
display: bit8
]; 
};

ReadProfileColors: PUBLIC PROC [] =
BEGIN
DefaultColor: PROC [def: ColorRec] RETURNS [c: ColorRec] =
BEGIN
r: Rope.ROPE _ Rope.Cat["ChipNDale.", technologyName, ".", def.name];
c.w _ Real.Float[UserProfile.Number[key: r.Concat[".w"], default: Real.Round[def.w*100]]]/100;
c.r _ Real.Float[UserProfile.Number[key: r.Concat[".r"], default: Real.Round[def.r*100]]]/100;
c.g _ Real.Float[UserProfile.Number[key: r.Concat[".g"], default: Real.Round[def.g*100]]]/100;
c.b _ Real.Float[UserProfile.Number[key: r.Concat[".b"], default: Real.Round[def.b*100]]]/100;
END;
FOR i: INT IN [0..numberOfColors) DO
currentColor[i] _ DefaultColor[cDefaults[i]];
ENDLOOP;
whiteOutLine _ UserProfile.Boolean[
key: Rope.Cat["ChipNDale." , technologyName, ".WhiteOutline"], 
default: TRUE
];
END;

ColorCommand: Commander.CommandProc =
BEGIN
CreateAnInstance[]; 
END;

ColorComm: PROC [comm: CDSequencer.Command] =
BEGIN
CreateAnInstance[]; 
END;

Init8Patterns[NIL];
ReadProfileColors[];
IF UserProfile.Boolean[Rope.Cat["ChipNDale.", technologyName, ".StartColorMap8"], ~Rope.Equal[technologyName, "chipnsil", FALSE]] THEN ComputeColors[];
CDSequencer.ImplementCommand[$SaturationComm, SaturationComm, technology, doQueue];
CDSequencer.ImplementCommand[$ColorTool, ColorComm, technology, dontQueue];
CDCommandOps.RegisterWithMenu[menu: $DisplayMenu, entry: Rope.Concat[technologyName, " 8 bit tool"], key: $ColorTooltech, tech: technology, queue: dontQueue];
[] _ Buttons.Create[
info: [name: Rope.Concat[technologyName, " colors"]], 
proc: ResetAndCreateButton
];
Commander.Register[  
key: Rope.Cat["CD", technologyName, "ColorRec"], 
proc: ColorCommand,
doc: Rope.Concat[technologyName, " 8 bit color tool"]
];

ERROR --not yet converted to cedar 7

END.

HCMosA8BitColors.mesa 
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Last Edited by: Monier,  September 24, 1984 9:55:48 pm PDT
Last Edited by: Jacobi,  October 29, 1984 5:46:54 pm PST
Last edited by: Christian Jacobi, October 17, 1986 2:05:03 pm PDT


--**color device**************************************
--experimenting showed that the following line was necessary....
FOR list: ImagerDitherContext.MapEntries _ mapEntries, list.rest WHILE list#NIL DO
Terminal.SetColor[terminal, list.first.mapIndex, 0, list.first.red, list.first.green, list.first.blue];
ENDLOOP;
--**end color device**************************************
--w is a wight; The color of an intersection (i.e. green1 over blue) is the 
--weighted sum of the rgb of each color.
--index 0 is supposed to be background
--XXXXXXXXXXXXXXXX TECHNOLOGY XXXXXXXXXXXXXXXX
--all parameter are discarded 
-- no change for bur, nwelCont, pwelCont, and ovgc for this background

--XXXXX end technology XXXXXXXXXXXXXXXXXXXXX

--we do only open the viewer, 
--because resetting can not reset already painted sliders... 
--Resets color map;
--does not touch patterns

--ResetMapButton

-- ButtonProcLayerInternal
--create an icon of the tool;
--does not change any color setup at initialization of the tool
-- create sliders for weights

-- create command buttons

-- create sliders for rgb colors
--takes a color setting (weights and rgb values) and sets up the device
--c1 not weighted; wc2 weighted
--colors in the range of layers
--bit loop
--check exception loops
--assign color
--include further colors from exception loop
Κ˜
codeš
œ™Kšœ
Οm
œ7™BK™:K™8K™A—K˜š
Οk	˜	Kš
œ˜Kš
œ˜Kšžœ
˜Kš
œ
˜
Kš
œ	˜	Kšžœ
˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜K˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜—K˜šΟnœžœ
ž˜Kšžœ*žœ£˜Ψ—Kš
ž˜K™Kš
œ9˜9K™K™6K˜Kšœ0žœ
˜4K˜šΟbœ$˜2Kš
ž˜Kš
œ˜šžœž˜KšœCžœ˜Iš
œ
˜
Kšœ@žœ˜Fšžœžœ
žœ
˜Kš
œ9˜9—Kš
œ@™@Kš
œA˜AK˜
—Kšžœžœ
˜—Kšžœ
˜Kšžœ
˜—K˜šŸœžœ/˜@Kš
ž˜Kš
œ˜šœSžœ˜Zšžœ>žœžœ
ž™RKš
œg™gKšžœ
™——Kš
œA˜AKš
œ.˜.Kšžœ
˜—K˜š œ˜Kš
ž˜Kš
œ[˜[Kšžœžœ
žœžœ˜Kšžœ˜—K™:K˜šœ
žœžœ
žœžœžœ˜EKš
œL™LKš
œ(™(—K˜šœžœžœžœ
˜;Kš
œ&™&—K˜Kšœžœžœžœžœžœ˜JK˜K˜Kš
œ.™.K˜Kš
œ&˜&Kšœžœ˜,KšœžœΟc,˜EKšœžœ‘%˜DK˜šœžœžœ˜2Kšœ!‘˜-Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ ˜ Kšœ‘˜(Kš
œ˜—K˜Kšœ
žœ˜K˜šŸ
œžœ˜Kš
ž˜Kšœ ‘˜.Kšœžœ˜K˜šœžœ
˜Kšœ5žœ‘˜SKšœ5žœ‘˜SKšœ&žœ‘˜HKšœ%žœ‘˜GKšœ%žœ‘˜GKšœ$žœ‘˜;Kš
œ˜—K˜šœžœ
˜Kšœ!žœ‘˜<Kšœ)žœ‘˜NKš
œ˜—K˜šœžœ
˜Kšœ‘*˜EKš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ‘˜5Kš
œ˜Kšžœžœ#˜8Kšžœ#‘˜6Kš
œ˜—K˜Kšžœ
˜—K˜šŸ
œ˜#Kš
œ™Kš
ž˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜K˜š
Ÿœžœ
žœžœ
žœ˜CKšžœ
˜Kšžœ
žœP˜ZKšžœ
˜—K˜šŸ
œžœžœžœ˜6Kšžœ
˜Kš
œ?˜?Kšžœ
˜—K˜š
Ÿœžœžœžœžœ˜?Kš
ž˜Kšžœ˜Kšžœ
˜—K˜Kš
œ9˜9Kš
œ9˜9Kš
œ7˜7Kš
œ9˜9Kš
œ7˜7Kš
œ:˜:Kš
œ:˜:Kš
œ3˜3K˜Kš
œB˜BKš
œ9˜9Kš
œL˜LKš
œL˜LKš
œE˜EK˜Kšœžœ'˜IK˜Kšœžœžœ+˜WKšœžœ
žœ)˜PKšœžœ
žœ)˜PK˜Kš
œ%˜%Kš
œ%˜%Kš
œ#˜#Kš
œ$˜$Kš
œ#˜#Kš
œ&˜&Kš
œ˜Kš
œ ˜ Kš
œF™FKšžœ
˜—K˜šŸœžœ˜Kš
ž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœ
˜—K™Kš
œ,™,K˜K˜Kšœžœ
˜KšœžœžœΟe
˜4K˜Kšœ
žœ˜Kšœžœ‘(˜<K™šœžœžœ˜Kšœžœ
˜Kšœžœ
˜Kšœž˜Kš
œ˜—K˜šœ
žœžœ˜Kšœžœ
˜Kšœž˜Kš
œ˜—K˜Kšœžœžœ˜"šœžœžœ˜Kšœžœ
˜"Kšœžœžœ˜3Kšœžœžœ
˜(Kšœžœ‘0˜FKš
œ˜—K˜Kšœžœžœ˜5šœžœžœ˜&Kš
œ˜Kšœž˜Kš
œ˜—K˜Kšœžœ6˜HK˜š
Ÿœžœžœžœžœ
˜.Kš
ž˜Kšžœžœžœ1˜wKšžœ
˜—K˜šŸ
œžœžœžœ˜+Kš
ž˜Kš
œ˜šžœž˜KšžœžœI˜d—Kšžœ
˜—K˜š œ˜(Kšžœ
˜Kšœžœ
˜/Kš
œ˜Kšœžœ˜Kšžœžœ
žœ
˜Kš
œ˜Kš
œ˜Kš
œP˜PKšžœ
˜—K˜š œ˜'Kšžœ
˜Kšœžœ
˜.Kš
œ˜Kšœžœ˜Kšžœžœ
žœ
˜Kš
œQ˜Qšžœž˜Kš
œ(˜(Kš
œ(˜(Kš
œ(˜(Kšžœžœ
˜—Kš
œ˜Kšžœ
˜—K˜š œ˜!Kš
ž˜Kš
œ6˜6Kš
œ7˜7Kšžœ
˜—K˜š 
œ˜ Kš
ž˜Kš
œ˜Kš
œ˜Kšžœ
˜—K˜š œ˜*Kš
ž˜Kš
œ=˜=šžœžœ
žœ˜Kšžœžœ
žœ˜)šžœ˜šžœ$žœ	žœžœ˜NKš
œ$˜$šžœBžœžœ
˜PKš
œ˜—Kš
œA˜AKš
œ˜—Kš
œ˜Kšžœžœ˜,K˜
—Kš
œ
˜
—šžœ˜Kš
œ™Kš
œ=™=Kšžœžœ˜0Kšžœ3žœ˜=Kš
œ˜—Kšžœ
˜—K˜K˜š œ˜$Kš
œ™Kš
œ™Kš
ž˜K˜šŸœžœ˜%Kš
ž˜Kš
œ!˜!Kšžœžœ
žœ
žœ
žœžœ
žœ
˜<šžœžœ
žœž˜(Kš
œ˜Kš
œ0˜0Kš
œ0˜0Kš
œ%˜%Kš
œ<˜<Kšžœ
˜—Kš
œ˜Kšžœ
˜—K™Kš
œ™šžœžœ˜Kš
œ˜K˜Kšžœžœ
žœžœ˜DK˜—Kšžœ
˜—K˜š œ˜%Kš
ž˜Kšœžœ
˜.šžœžœ˜Kš
œ-˜-K˜
—Kšžœ˜—šŸœžœž
œ
˜=Kš
ž˜K˜šŸœžœžœ˜-Kš
ž˜Kš
œA˜AKš
œA˜AKš
œA˜AKš
œ]˜]Kš
œ]˜]Kš
œ]˜]Kšžœ
˜—K™Kš
‘™Kš
œ˜Kš
œ˜Kš
œI˜IKš
œH˜HKš
œ˜Kšžœ
˜—K˜šŸœžœ˜Kš
œ™Kš
œ?™?Kš
ž˜Kšœžœžœžœ˜=K˜Kšœžœ˜Kšœžœ˜Kšœžœ˜ Kšœ
žœ˜Kšœžœ˜Kšœžœ˜2Kšœ
žœ˜Kšœ
žœ˜,K˜Kšœžœ˜Kšœ	žœ%˜6Kšœ
žœ˜K˜Kšœžœ˜Kšœ
žœ˜Kšœžœ˜Kšœžœ‘
˜3Kšœ	žœ˜Kšœ	žœ‘	˜.Kšœ
žœ˜Kšœ	žœ˜%K˜Kšœ
žœ˜!Kšœ
žœ˜"K˜šŸ
œžœ
žœ˜>Kš
ž˜Kšœ
žœ˜Kšœžœ˜š
œ˜š
œ˜Kš
œ˜Kš
œ
˜
Kš
œ
˜
Kš
œ
˜
Kš
œ˜Kšœžœ˜—Kš
œ˜Kš
œ˜Kšœž˜
Kš
œ˜—Kš
œ*˜*Kšžœ
˜—K˜šžœžœ
˜Kš
œ`˜`—šžœžœ
žœ˜,Kš
œ˜Kš
œ.˜.Kš
ž˜K˜—š
œ˜Kš
œ˜Kšœžœ
˜
Kšœžœžœ˜UKš
œ
˜
Kšœžœ
˜Kš
œ˜—Kš
œ3˜3Kš
œ™šžœžœ
žœž˜+Kšœžœ˜'š
œ/˜/š
œ˜Kš
œ˜Kšœžœ
˜
Kš
œ˜Kš
œ˜Kš
œ˜K˜Kš
œ˜Kšœžœ˜—Kš
œ˜Kšœžœ3˜BKš
œ˜—š
œ/˜/Kšœ0‘˜CKšœžœ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœž˜Kš
œ˜—š
œ,˜,š
œ˜Kš
œ˜Kšœžœ
˜
Kš
œ˜Kš
œ˜Kš
œ
˜
Kšœ‘˜Kš
œ˜Kšœžœ˜—Kš
œ˜Kš
œ˜Kš
œ
˜
Kšœžœ2˜AKš
œ˜—Kš
œ=˜=Kšžœ
˜—K™Kš
œ™Kš
œ%˜%Kš
œ(˜(Kš
œ+˜+Kš
œ&˜&Kš
œ˜K™Kš
œ ™ šžœ	žœ
žœž˜!šœžœžœž˜ Kš
œ ˜ Kš
œ ˜ Kš
œ ˜ Kšžœžœ
˜—š
œ˜š
œ%˜%Kš
œ˜Kš
œ˜Kš
œ0˜0Kš
œ˜Kš
œ
˜
Kšœž˜—Kš
œ˜—š
œ+˜+š
œ˜Kš
œ˜Kš
œ0˜0Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜Kš
œ
˜
Kšœžœ1˜@Kš
œ˜—Kš
œ<˜<š
œ-˜-Kšœ0‘˜CKš
œ˜Kš
œ0˜0Kš
œ
˜
Kš
œ
˜
Kš
œ˜Kšœž˜Kš
œ˜—Kšžœ
˜—K˜Kšœ.‘˜HKšœ)‘˜@Kš
œ?˜?Kšžœ
˜—K˜š œ˜)Kšžœ
‘
˜Kšœžœ˜šžœžœ˜Kš	œžœ
žœžœžœ˜/š	žœžœ
ž
œ
žœž˜/Kšœžœ˜$Kšžœ
˜—Kš
œB˜BKšžœžœ
žœ˜šžœž˜"š
œ˜Kš
œ˜KšœžœH˜TK˜—Kšžœ	žœ
žœ˜Kš
œ2˜2Kš
ž
˜
—Kšžœ˜Kš
œ˜K˜—Kšžœ
˜—K˜K˜Kšœžœ
žœ
žœ‘7˜[Kšœžœ
žœ
žœ‘8˜\Kšœžœ
žœ
žœ‘!˜EK˜K˜šŸ
œžœ˜Kš
œG™GKš
ž˜K˜šŸœžœžœ˜>Kš
œ™Kš
ž˜Kšœžœ	˜Kš
œ6˜6Kšžœ
˜—K˜šŸœžœžœ˜1Kš
ž˜š
Ÿœžœžœžœžœ˜5Kšœžœ
žœ˜'Kš
œ˜—Kš
œZ˜ZKšœ
žœ˜)Kšžœ
˜—K˜Kšœžœ
žœžœ
˜2Kš
œ˜Kšœžœ˜&Kšœžœ
žœ
˜+K˜Kšžœžœ
žœ
˜K˜Kš
œ™šžœžœ
žœž˜ Kš
œ˜Kš
œ
™
šžœžœ
žœž˜!šžœžœžœžœ˜5Kš
œ)˜)K˜—Kš
ž˜—Kš
œ™šžœžœ
žœ"žœžœ
ž˜Dšžœžœžœ˜5Kšžœžœ˜,Kšžœ#˜'Kš
œ˜—Kšžœ
˜—šžœžœ
žœ"žœžœ
ž˜Dšžœžœ˜Kšžœžœ˜,Kšžœ#˜'Kš
œ˜—Kšžœ
˜—K™Kšžœ	žœ&˜5Kšžœžœ˜!Kšžœ$˜(Kš
œ
˜
Kšžœ
˜—Kš
œ,™,šžœžœ
žœ"žœžœ
ž˜DKšžœžœ$˜?Kšžœ
˜—Kš
œ$˜$Kš
œ˜Kšžœ
˜—K˜šŸ	œžœ	žœžœ˜-š
œ$˜$Kš
œb˜bKš
œ
˜
Kš
œ˜—K˜K˜—šŸœžœ
žœ˜#Kš
ž˜šŸœžœžœ˜:Kš
ž˜Kšœžœ9˜EKš
œ^˜^Kš
œ^˜^Kš
œ^˜^Kš
œ^˜^Kšžœ
˜—šžœžœ
žœž˜$Kš
œ-˜-Kšžœ
˜—š
œ#˜#Kš
œ?˜?Kšœ	ž˜
Kš
œ˜—Kšžœ
˜K˜—š œ˜%Kš
ž˜Kš
œ˜Kšžœ
˜K˜—š 	œžœ˜-Kš
ž˜Kš
œ˜Kšžœ
˜K˜—Kšœžœ˜Kš
œ˜Kšžœxžœžœ˜—
Kš
œS˜SKš
œK˜KKš
œž
˜ž
š
œ˜Kš
œ6˜6Kš
œ˜Kš
œ˜—š
œ˜Kš
œ1˜1Kš
œ˜Kš
œ5˜5Kš
œ˜—K˜Kšžœ
‘˜$K˜Kšžœ
˜K˜—…—JPh