
<<ColorDisplayCommand.mesa>>
<<Created from old ColorDisplay by Mik Lamming and Ken Pier>>
<<Last Edited by: Nickell, June 19, 1984 11:43:29 am PDT>>
<<Last Edited by: Beach, August 17, 1984 5:41:30 pm PDT>>
DIRECTORY
Ascii USING [Lower],
Buttons USING [Button, ButtonProc, Create, SetDisplayStyle],
ColorDisplay USING [SetColorDisplayStatus, GetColorDisplayStatus, GetColorDisplayProfile],
Commander USING [CommandProc, Register],
Containers USING [Container, Create],
IO USING [card, EndOfStream, GetTokenRope, IDProc, PutF, RIS, rope, STREAM],
Process USING [Pause, SecondsToTicks],
Rope USING [Equal, Fetch, Length, ROPE, Translate, TranslatorType],
ViewerOps USING [OpenIcon, SetOpenHeight];

ColorDisplayCommand: CEDAR PROGRAM 
IMPORTS Ascii, Buttons, ColorDisplay, Commander, Containers, IO, Process, Rope, ViewerOps  
~ {

FiddleWithDisplay: Commander.CommandProc ~ {
MyLower:Rope.TranslatorType = BEGIN RETURN[Ascii.Lower[old]]; END;
myOn: BOOLEAN;
myBpp: CARDINAL;
myOnLeft: BOOLEAN;
myMonType: Rope.ROPE;
noParams: BOOLEAN _ TRUE;
s: IO.STREAM _ IO.RIS[Rope.Translate[base:cmd.commandLine, translator:MyLower]];
[myOn, myOnLeft, myBpp, myMonType] _ ColorDisplay.GetColorDisplayStatus[];
DO
f:Rope.ROPE _ IO.GetTokenRope[s, IO.IDProc ! IO.EndOfStream => EXIT].token;
noParams _ FALSE;
SELECT Rope.Fetch[f, 0] FROM
'0 => myOn _ FALSE;
'1 => 
IF Rope.Equal[f, "1024x768"] THEN { myMonType _ "1024x768"; myOn _ TRUE }
ELSE IF Rope.Length[f]=1 THEN {myBpp _ 1; myOn _ TRUE; }
ELSE {
IO.PutF[cmd.err, "Option %g that begins with a 1 has to be 1024x768 or 1 exactly.\n", IO.rope[f]];
RETURN;
};
'2 => 
IF Rope.Equal[f, "24"] THEN { myOn _ TRUE; myBpp _ 24 }
ELSE IF Rope.Length[f]=1 THEN { myBpp _ 2; myOn _ TRUE }
ELSE {
IO.PutF[cmd.err, "Can't do %g bpp\n", IO.rope[f]];
RETURN;
};
'4 => { myBpp _ 4; myOn _ TRUE };
'6 => {
IF Rope.Equal[f, "640x480"] THEN { myMonType _ "640x480"; myOn _ TRUE }
ELSE {
IO.PutF[cmd.err, "%g is an invalid key\n", IO.rope[f]];
RETURN;
};
};
'8 => { myBpp _ 8; myOn _ TRUE };
'l => { myOnLeft _ TRUE; myOn _ TRUE };
'r => { myOnLeft _ FALSE; myOn _ TRUE };
'd => {
[myOn, myOnLeft, myBpp, myMonType] _ ColorDisplay.GetColorDisplayProfile[];
};
'o => 
IF Rope.Equal[f, "on"] THEN myOn _ TRUE
ELSE IF Rope.Equal[f, "off"]  THEN myOn _ FALSE
ELSE {
IO.PutF[cmd.err, "%g is an invalid key\n", IO.rope[f]];
RETURN;
};
'? => IO.PutF[cmd.err, "%g, %g bpp, %g, %g\n",
IO.rope[IF myOn THEN "on" ELSE "off"],
IO.card[myBpp],
IO.rope[IF myOnLeft THEN "left" ELSE "right"],
IO.rope[myMonType]];
ENDCASE => {
IO.PutF[cmd.err, "%g is an invalid key\n", IO.rope[f]];
RETURN[];
};
ENDLOOP;
IF noParams THEN myOn _ ~myOn;
ColorDisplay.SetColorDisplayStatus[myOn, myOnLeft, myBpp, myMonType];
};

CreateColorDisplayTool: PROC ~ {
p: PROCESS RETURNS [];            --To fork away a process
prev, on, off, left, right, lowres, highres, c1, c2, c4, c8, c24: Buttons.Button;
hMargin: INT ~ -1;
hSeparator: INT ~ 20;
vMargin: INT ~ 5;
vHeight: INT ~ 10;
thisX, thisY: INT;

colorDisplayTool: Containers.Container _ Containers.Create[
info: [
name: "ColorDisplayTool",
column: right,
scrollable: FALSE
]
];

thisX _ hMargin+hSeparator; thisY _ vMargin;
<<On Button>>
prev _ on _ Buttons.Create[
info: [
name: "On",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDTOn,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin;
<<Off Button>>
prev _ off _ Buttons.Create[
info: [
name: "Off",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDTOff,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin + hSeparator;
<<1 Button>>
prev _ c1 _ Buttons.Create[
info: [
name: "1 ",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDT1,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin;
<<2 Button>>
prev _ c2 _ Buttons.Create[
info: [
name: "2 ",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDT2,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin;
<<4 Button>>
prev _ c4 _ Buttons.Create[
info: [
name: "4 ",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDT4,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin;
<<8 Button>>
prev _ c8 _ Buttons.Create[
info: [
name: "8 ",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDT8,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin;
<<24 Button>>
prev _ c24 _ Buttons.Create[
info: [
name: "24 ",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDT24,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin + hSeparator;
<<Left Button>>
prev _ left _ Buttons.Create[
info: [
name: "Left",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDTLeft,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin;
<<Right Button>>
prev _ right _ Buttons.Create[
info: [
name: "Right",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDTRight,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin + hSeparator;
<<640x480 Button>>
prev _ lowres _ Buttons.Create[
info: [
name: "640x480",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDTLowRes,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin;
<<1024x768 Button>>
prev _ highres _ Buttons.Create[
info: [
name: "1024x768",
wx:  thisX,
wy:  thisY,
parent:  colorDisplayTool,
border:  TRUE
],
proc: CDTHighRes,
fork: FALSE
];
thisX _ thisX + prev.ww + hMargin + hSeparator;
<<Set the height of the viewer as a whole>>
ViewerOps.SetOpenHeight[colorDisplayTool, thisY + vHeight + 2*vMargin];
ViewerOps.OpenIcon[icon: colorDisplayTool, bottom: FALSE];

<<Start the process that updates the color of the buttons>>
p _ FORK MonitorButtons[on, off, c1, c2, c4, c8, c24, left, right, lowres, highres];
};

MonitorButtons: PROC [on, off, c1, c2, c4, c8, c24, left, right, lowres, highres: Buttons.Button] ~ {
OPEN Buttons;
RepaintColorDisplayButtons: PROC [displayOn, displayOff: BOOL, bpp: INT, displayLowRes: BOOL] ~ {
<<This proc toggles the color of the buttons to show currect state of display>>
SetDisplayStyle[on, IF displayOn THEN $WhiteOnBlack ELSE $BlackOnWhite];
SetDisplayStyle[off, IF displayOn THEN $BlackOnWhite ELSE $WhiteOnBlack];
SetDisplayStyle[c1, IF bpp=1 THEN $WhiteOnBlack ELSE $BlackOnWhite];
SetDisplayStyle[c2, IF bpp=2 THEN $WhiteOnBlack ELSE $BlackOnWhite];
SetDisplayStyle[c4, IF bpp=4 THEN $WhiteOnBlack ELSE $BlackOnWhite];
SetDisplayStyle[c8, IF bpp=8 THEN $WhiteOnBlack ELSE $BlackOnWhite];
SetDisplayStyle[c24, IF bpp=24 THEN $WhiteOnBlack ELSE $BlackOnWhite];
SetDisplayStyle[left, IF displayOnLeft THEN $WhiteOnBlack ELSE $BlackOnWhite];
SetDisplayStyle[right, IF displayOnLeft THEN $BlackOnWhite ELSE $WhiteOnBlack];
SetDisplayStyle[lowres, IF displayLowRes THEN $WhiteOnBlack ELSE $BlackOnWhite];
SetDisplayStyle[highres, IF displayLowRes THEN $BlackOnWhite ELSE $WhiteOnBlack];
};
displayOn, displayOnLeft, displayLowRes, wasOn, wasOnLeft, wasLowRes: BOOLEAN;
bpp, wasBpp: INT;
monitorType: Rope.ROPE;
<<Set up the initial state and color of the buttons>>
[displayOn, displayOnLeft, bpp, monitorType] _ ColorDisplay.GetColorDisplayStatus[];
displayLowRes _ monitorType.Equal["640x480"];
RepaintColorDisplayButtons[displayOn, displayOnLeft, bpp, displayLowRes];
DO
<<Make the current reading the last one, and get a new current, and see if different>>
wasOn _ displayOn; wasOnLeft _ displayOnLeft;
wasBpp _ bpp; wasLowRes _ displayLowRes;
[displayOn, displayOnLeft, bpp, monitorType] _ ColorDisplay.GetColorDisplayStatus[];
displayLowRes _ monitorType.Equal["640x480"];
IF wasOn#displayOn OR wasOnLeft#displayOnLeft OR wasBpp#bpp OR wasLowRes#displayLowRes THEN
RepaintColorDisplayButtons[displayOn, displayOnLeft, bpp, displayLowRes];
Process.Pause[Process.SecondsToTicks[1]];
ENDLOOP;
};

CDTOn: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[on: TRUE]};
CDTOff: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[on: FALSE]};
CDTLeft: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[onLeft: TRUE]};
CDTRight: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[onLeft: FALSE]};
CDTLowRes: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[monitorType: "640x480"]};
CDTHighRes: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[monitorType: "1024x768"]};
CDT1: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[on: TRUE, bpp: 1]};
CDT2: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[on: TRUE, bpp: 2]};
CDT4: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[on: TRUE, bpp: 4]};
CDT8: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[on: TRUE, bpp: 8]};
CDT24: Buttons.ButtonProc ~ {ColorDisplay.SetColorDisplayStatus[on: TRUE, bpp: 24]};

BugColor: Buttons.ButtonProc ~ {
SELECT mouseButton FROM
red => ColorDisplay.SetColorDisplayStatus[on: ~ColorDisplay.GetColorDisplayStatus[].on];
blue => CreateColorDisplayTool[];
ENDCASE;
};


Init: PROC[] RETURNS[] = BEGIN
<<Register the program with the commander and read user profile>>
Commander.Register[key:"ColorDisplay",  proc:FiddleWithDisplay, doc:"Configure color monitor"];
<<Establish the 'color' button up at the top>>
[] _ Buttons.Create[
info: [name: "Color"],
proc: BugColor,
fork: FALSE
];
END;

Init[];

}.