ColorTrixCommandsImplA.mesa
Copyright © 1985 by Xerox Corporation. All rights reserved.
Bloomenthal, December 4, 1986 12:38:31 pm PST
DIRECTORY Args, ColorTrixBasics, ColorTrixFile, ColorTrixMap, ColorTrixMod, ColorTrixPalette, ColorTrixPix, ColorTrixPrivate, Commander, FileNames, ImagerPixelMap, IO, Rope, Terminal, ViewerClasses;
ColorTrixCommandsImplA: CEDAR PROGRAM
IMPORTS Args, ColorTrixBasics, ColorTrixFile, ColorTrixMap, ColorTrixMod, ColorTrixPalette, ColorTrixPix, ColorTrixPrivate, FileNames, ImagerPixelMap, IO, Rope
EXPORTS ColorTrixPrivate
~ BEGIN
ROPE:     TYPE ~ Rope.ROPE;
PixelMap:    TYPE ~ ColorTrixBasics.PixelMap;
PixelMapMisc:  TYPE ~ ColorTrixBasics.PixelMapMisc;
DeviceRectangle: TYPE ~ ImagerPixelMap.DeviceRectangle;
Cmap:      TYPE ~ ColorTrixMap.Cmap;
palOn:    BOOL ← FALSE;
File IO Commands
CtView: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
name, center, clear, cmap, aisX, aisY, aisW, aisH, dum: Args.Arg;
[ok, name, center, clear, cmap, aisX, aisY, aisW, aisH, dum, dum, dum, dum]
← Args.ArgsGet[cmd, "%s-center%b-clear%b-cmap%s-a%iiii-w%iiii"];
IF NOT ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
x: CARDINAL ← IF aisX.ok THEN aisX.int ELSE 0;
y: CARDINAL ← IF aisY.ok THEN aisY.int ELSE 0;
w: CARDINAL ← IF aisW.ok THEN aisW.int ELSE LAST[CARDINAL];
h: CARDINAL ← IF aisH.ok THEN aisH.int ELSE LAST[CARDINAL];
IF cmap.ok AND NOT ColorTrixMap.Load[cmap.rope]
THEN RETURN[$Failure, Rope.Concat["Can't load ", cmap.rope]];
IF clear.ok AND clear.bool THEN {
IF pmMisc.bpp = 8
THEN ColorTrixBasics.FillPm[pmMisc.bw, 0]
ELSE ColorTrixBasics.FillRGBPm[pmMisc, 0, 0, 0];
};
msg 𡤌olorTrixFile.ViewFile[pmMisc, name.rope, center.ok AND center.bool, x, y, w, h];
IF msg # NIL THEN RETURN[$Failure, "Error in viewing file."];
};
};
CtSave: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
name, dum: Args.Arg;
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
[ok, name, dum, dum, dum, dum] ← Args.ArgsGet[cmd, "%s-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
ColorTrixFile.WritePmMiscToAIS[pmMisc, FileNames.ResolveRelativePath[name.rope]];
};
Window Commands
CtSetWindow: PUBLIC Commander.CommandProc ~ {
IF Args.NArgs[cmd] > 0
THEN {
ok: BOOL;
x, y, w, h: Args.Arg;
[ok, x, y, w, h] ← Args.ArgsGet[cmd, "%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
ColorTrixPrivate.SetGlobalWindow[[y.int, x.int, h.int, w.int]];
};
};
CtResetWindow: PUBLIC Commander.CommandProc ~ {
ColorTrixPrivate.SetGlobalWindow[ColorTrixPrivate.GetInitialWindow[]];
};
CtPrintWindow: PUBLIC Commander.CommandProc ~ {
w: DeviceRectangle ~ ColorTrixPrivate.GetGlobalWindow[];
cmd.out.PutF["global window is (x, y, w, h): [%g, %g, %g, %g].\n",
IO.int[w.fMin], IO.int[w.sMin], IO.int[w.fSize], IO.int[w.sSize]];
};
Clearing/Drawing Commands
CtClear: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
rVal, gVal, bVal: CARDINAL;
rArg, gArg, bArg, dum: Args.Arg;
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
[ok, dum, dum, dum, dum, rArg, gArg, bArg] ← Args.ArgsGet[cmd, "-w%iiii[iii"];
IF NOT ok THEN RETURN[$Failure, NIL];
rVal ← MIN[255, IF rArg.ok THEN INTEGER[rArg.int] ELSE 0];
gVal ← MIN[255, IF gArg.ok THEN INTEGER[gArg.int] ELSE rVal];
bVal ← MIN[255, IF bArg.ok THEN INTEGER[bArg.int] ELSE gVal];
SELECT pmMisc.bpp FROM
8 => ColorTrixBasics.FillPm[pmMisc.bw, rVal];
24 => ColorTrixBasics.FillRGBPm[pmMisc, rVal, gVal, bVal]
ENDCASE => NULL;
};
CtLine: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
x0, y0, x1, y1, r, g, b, dum: Args.Arg;
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
[ok, x0, y0, x1, y1, r, g, b, dum, dum, dum, dum] ← Args.ArgsGet[cmd, "[iiiiiii-w%iiii"];
IF NOT (ok AND x0.ok AND y0.ok AND x1.ok AND y1.ok AND r.ok)
THEN RETURN[$Failure, "Bad argument(s)."];
SELECT pmMisc.bpp FROM
8 => ColorTrixBasics.PutLine[pmMisc.bw, x0.int, y0.int, x1.int, y1.int, r.int];
24 => {
IF NOT (g.ok AND b.ok) THEN RETURN[$Failure, NIL];
ColorTrixBasics.PutRGBLine[pmMisc, x0.int, y0.int, x1.int, y1.int, r.int, g.int, b.int];
};
ENDCASE => NULL;
};
CtRamp: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
v, h, dum: Args.Arg;
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
[ok, v, h, dum, dum, dum, dum] ← Args.ArgsGet[cmd, "-v%b-h%b-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
SELECT pmMisc.bpp FROM
8 => IF h.bool
THEN ColorTrixPix.RampH[pmMisc.bw]
ELSE ColorTrixPix.RampV[pmMisc.bw];
24 => {
IF h.bool THEN ColorTrixPix.RampH[pmMisc.rg] ELSE ColorTrixPix.RampV[pmMisc.rg];
IF h.bool THEN ColorTrixPix.RampH[pmMisc.b] ELSE ColorTrixPix.RampV[pmMisc.b];
};
ENDCASE => NULL;
};
CtPie: PUBLIC Commander.CommandProc ~ {
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixPix.Pie[pmMisc.bw];
24 => {
ColorTrixPix.Pie[pmMisc.rg];
ColorTrixPix.Pie[pmMisc.b];
};
ENDCASE => NULL;
};
CtDither: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
dum, arg: Args.Arg;
[ok, arg, dum, dum, dum, dum] ← Args.ArgsGet[cmd, "%i-w%iiii"];
IF NOT ok OR NOT arg.ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixPix.Dither[pmMisc.bw, arg.int];
24 => {
ColorTrixPix.Dither[pmMisc.rg, arg.int];
ColorTrixPix.Dither[pmMisc.b, arg.int];
};
ENDCASE => NULL;
};
};
CtGrid: PUBLIC Commander.CommandProc ~ {
InnerGrid: PROC [pm: PixelMap] ~ {
FOR i: NAT ← 0, i+spacing WHILE i < pm.fSize DO
FOR j: NAT ← 0, j+1 WHILE j < pm.sSize DO
ImagerPixelMap.Fill[pm, [j, i, lineWidth, lineWidth], pVal];
ENDLOOP;
ENDLOOP;
FOR j: NAT ← 0, j+spacing WHILE j < pm.sSize DO
FOR i: NAT ← 0, i+1 WHILE i < pm.fSize DO
ImagerPixelMap.Fill[pm, [j, i, lineWidth, lineWidth], pVal];
ENDLOOP;
ENDLOOP;
};
ok: BOOL;
pVal, spacing, lineWidth: CARDINAL;
pValArg, spacingArg, lineWidthArg, dum: Args.Arg;
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
[ok, pValArg, spacingArg, lineWidthArg, dum, dum, dum, dum]
← Args.ArgsGet[cmd, "-pVal%i-spacing%i-lineWidth%i-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
pVal ← IF pValArg.ok THEN pValArg.int ELSE 255;
pVal ← 256*pVal+pVal;
spacing ← IF spacingArg.ok THEN spacingArg.int ELSE 40;
lineWidth ← IF lineWidthArg.ok THEN lineWidthArg.int ELSE 1;
SELECT pmMisc.bpp FROM
8 => InnerGrid[pmMisc.bw];
24 => {
InnerGrid[pmMisc.rg];
InnerGrid[pmMisc.b];
};
ENDCASE => NULL;
};
Palette Commands
CtPal: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
n, smooth: Args.Arg;
pm: PixelMap ← ColorTrixBasics.GetColorDisplayPm[];
[ok, n, smooth] ← Args.ArgsGet[cmd, "[i-smooth%b"];
IF NOT ok THEN RETURN[$Failure, NIL];
ColorTrixPalette.Pal[pm, IF n.ok THEN n.int ELSE 5, smooth.ok AND smooth.bool];
palOn ← TRUE;
};
CtUnPal: PUBLIC Commander.CommandProc ~ {
IF palOn THEN ColorTrixPalette.UnPal[ColorTrixBasics.GetColorDisplayPm[]];
palOn ← FALSE;
};
Processing Commands
CtLum: PUBLIC Commander.CommandProc ~ {
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.Lum[pmMisc.bw];
24 => {
ColorTrixMod.Lum[pmMisc.rg];
ColorTrixMod.Lum[pmMisc.b];
};
ENDCASE => NULL;
};
CtPVal: PUBLIC Commander.CommandProc ~ {
n: NAT ← 0;
new, old: Args.Arg;
list: REF List ← NIL;
nArgs: NAT ← Args.NArgs[cmd];
List: TYPE ~ RECORD[first: NAT, rest: REF List];
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
WHILE n < nArgs DO
IF Args.GetRope[cmd, n].Equal["-w"] THEN {n ← n+5; LOOP};
IF new.ok THEN {
IF NOT (old ← Args.ArgInt[cmd, n]).ok THEN RETURN[$Failure, "Bad old value."];
list ← NEW[List ← [old.int, list]];
}
ELSE IF NOT (new ← Args.ArgInt[cmd, n]).ok THEN RETURN[$Failure, "Bad new value."];
n ← n+1;
ENDLOOP;
IF list # NIL THEN SELECT pmMisc.bpp FROM
8 => ColorTrixMod.PVal[pmMisc.bw, new.int, list];
24 => {
ColorTrixMod.PVal[pmMisc.rg, new.int, list];
ColorTrixMod.PVal[pmMisc.b, new.int, list];
};
ENDCASE => NULL;
};
Manipulations Commands
CtCopy: PUBLIC Commander.CommandProc ~ {
InnerCopy: PROC [pm: PixelMap] ~ {
src: PixelMap ~ ImagerPixelMap.Clip[pm, [y0.int, x0.int, h0.int, w0.int]];
dst: PixelMap ~ ImagerPixelMap.Clip[pm, [y1.int, x1.int, h1.int, w1.int]];
ImagerPixelMap.Transfer[dst, ImagerPixelMap.ShiftMap[src, y1.int-y0.int, x1.int-x0.int]];
};
ok: BOOL;
x0, y0, w0, h0, x1, y1, w1, h1: Args.Arg;
[ok, x0, y0, w0, h0, x1, y1, w1, h1] ← Args.ArgsGet[cmd, "%iiiiii[ii"];
IF NOT ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc ← ColorTrixBasics.GetColorDisplayPmMisc[];
IF NOT w1.ok THEN w1.int ← w0.int;
IF NOT h1.ok THEN h1.int ← h0.int;
SELECT pmMisc.bpp FROM
8 => InnerCopy[pmMisc.bw];
24 => {
InnerCopy[pmMisc.rg];
InnerCopy[pmMisc.b];
};
ENDCASE => NULL;
};
};
CtLeft: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
dum, arg: Args.Arg;
[ok, arg, dum, dum, dum, dum] ← Args.ArgsGet[cmd, "%i-w%iiii"];
IF NOT ok OR NOT arg.ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.Left[pmMisc.bw, arg.int];
24 => {
ColorTrixMod.Left[pmMisc.rg, arg.int];
ColorTrixMod.Left[pmMisc.b, arg.int];
};
ENDCASE => NULL;
};
};
CtUp: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
dum, arg: Args.Arg;
[ok, arg, dum, dum, dum, dum] ← Args.ArgsGet[cmd, "%i-w%iiii"];
IF NOT ok OR NOT arg.ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.Up[pmMisc.bw, arg.int];
24 => {
ColorTrixMod.Up[pmMisc.rg, arg.int];
ColorTrixMod.Up[pmMisc.b, arg.int];
};
ENDCASE => NULL;
};
};
CtNegate: PUBLIC Commander.CommandProc ~ {
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.Negate[pmMisc.bw];
24 => {
ColorTrixMod.Negate[pmMisc.rg];
ColorTrixMod.Negate[pmMisc.b];
};
ENDCASE => NULL;
};
CtReflect: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
v, h, dum: Args.Arg;
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
[ok, v, h, dum, dum, dum, dum] ← Args.ArgsGet[cmd, "-v%b-h%b-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
IF h.bool
THEN SELECT pmMisc.bpp FROM
8 => ColorTrixMod.ReflectH[pmMisc.bw];
24 => {
ColorTrixMod.ReflectH[pmMisc.rg];
ColorTrixMod.ReflectH[pmMisc.b];
};
ENDCASE => NULL
ELSE SELECT pmMisc.bpp FROM
8 => ColorTrixMod.ReflectV[pmMisc.bw];
24 => {
ColorTrixMod.ReflectV[pmMisc.rg];
ColorTrixMod.ReflectV[pmMisc.b];
};
ENDCASE => NULL;
};
CtMirror: PUBLIC Commander.CommandProc ~ {
MirrorH: PROC [pmMisc: PixelMapMisc, leftToRight: BOOL] ~ {
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.MirrorH[pmMisc.bw];
24 => {
ColorTrixMod.MirrorH[pmMisc.rg];
ColorTrixMod.MirrorH[pmMisc.b];
};
ENDCASE => NULL;
};
MirrorV: PROC [pmMisc: PixelMapMisc, leftToRight: BOOL] ~ {
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.MirrorV[pmMisc.bw];
24 => {
ColorTrixMod.MirrorV[pmMisc.rg];
ColorTrixMod.MirrorV[pmMisc.b];
};
ENDCASE => NULL;
};
ok: BOOL;
l, r, t, b, dum: Args.Arg;
pmMisc: PixelMapMisc ← ColorTrixPrivate.GetWindowedPmMisc[cmd];
[ok, l, r, t, b, dum, dum, dum, dum] ← Args.ArgsGet[cmd, "-l%b-r%b-t%b-b%b-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
SELECT TRUE FROM
l.bool => MirrorV[pmMisc, TRUE];
r.bool => MirrorV[pmMisc, FALSE];
t.bool => MirrorH[pmMisc, TRUE];
b.bool => MirrorH[pmMisc, FALSE];
ENDCASE => MirrorH[pmMisc, FALSE];
};
END.