DIRECTORY
Basics								USING [LowHalf, BITSHIFT, logBitsPerWord, LongMult],
VM							USING [Allocate, AddressForPageNumber, wordsPerPage, Pin,
										 Unpin],
CountedVM					USING [Handle],
ColorDisplayHeadDorado	USING [RPtr, mcb, rpNIL, ChanCB, ChanCBPtr, first64K,
										 screenwidth], 
ImagerPixelMaps					USING [PixelMap],
ImagerDisplay				USING [DisplayData],
ImagerDisplayExtras			USING [RGBSequence],
Atom							USING [PutPropOnList, GetPropFromList],
Terminal							USING [Virtual, ColorMode, GetColorMode, SetColor, SetRedMap,
										 SetGreenMap, SetBlueMap, WaitForBWVerticalRetrace],
ImagerTerminalExtras;
ImagerTerminalExtrasImpl: CEDAR PROGRAM
IMPORTS VM, ColorDisplayHeadDorado, Basics, Atom, Terminal
EXPORTS ImagerTerminalExtras
SHARES  ColorDisplayHeadDorado
~ BEGIN
PixelMap: TYPE ~ ImagerPixelMaps.PixelMap;
DisplayData: TYPE ~ ImagerDisplay.DisplayData;
ImagerTerminalExtrasError: PUBLIC SIGNAL [reason: ATOM] ~ CODE;
storage, limit: ColorDisplayHeadDorado.RPtr _ ColorDisplayHeadDorado.rpNIL;
marginOffset: CARDINAL;
leftOverBytes: NAT;
SetDCB: PROC [aChannel: BOOLEAN _ TRUE, bitmap: LONG POINTER, 
				   leftMargin, width, height, wordsPerLine, whichLink: NAT] ~ TRUSTED {
Alloc: PROC [words: CARDINAL] RETURNS [pointer: ColorDisplayHeadDorado.RPtr] ~ TRUSTED{
page, count: INT;
storageTop: ColorDisplayHeadDorado.RPtr _ storage + words;
IF     (storage = ColorDisplayHeadDorado.rpNIL) 
OR (LOOPHOLE[storageTop, CARDINAL] > LOOPHOLE[limit, CARDINAL]) 
THEN {
[[page, count]] _ VM.Allocate[count: 1, partition: lowCore, in64K: TRUE];
storage _ LOOPHOLE[Basics.LowHalf[LOOPHOLE[VM.AddressForPageNumber[page]]]];
limit _ storage + VM.wordsPerPage;
};
pointer _ storage;
storage _ storage + words;
};
link: NAT _ 0;
chainPtr, lastPtr: LONG POINTER TO ColorDisplayHeadDorado.ChanCB _ NIL;
IF ColorDisplayHeadDorado.mcb = NIL THEN {
SIGNAL ImagerTerminalExtrasError[$NoColorDisplay];    RETURN[];  };
IF aChannel THEN lastPtr _ chainPtr _
						@ColorDisplayHeadDorado.first64K[ColorDisplayHeadDorado.mcb.achanCB]
				ELSE lastPtr _ chainPtr _
						@ColorDisplayHeadDorado.first64K[ColorDisplayHeadDorado.mcb.bchanCB];
IF chainPtr = NIL THEN {
SIGNAL ImagerTerminalExtrasError[$NoDCBChain];    RETURN[];  };
IF whichLink > 31 THEN {  SIGNAL ImagerTerminalExtrasError[$Over32DCBs];  RETURN[];  };
IF (wordsPerLine * 2 > leftOverBytes) THEN		-- check for excess leftovers at end of scan
IF (ColorDisplayHeadDorado.screenwidth - width) > leftOverBytes 
THEN {  SIGNAL ImagerTerminalExtrasError[$ExcessLeftOverPixels];  RETURN[];  };
WHILE (link < whichLink) AND NOT (chainPtr = NIL) DO 
link _ link + 1;
lastPtr _ chainPtr;											-- step to next link
IF chainPtr.link = ColorDisplayHeadDorado.rpNIL 
THEN chainPtr _ NIL
ELSE chainPtr _ @ColorDisplayHeadDorado.first64K[chainPtr.link];
ENDLOOP;

WHILE link <= whichLink DO 
relPtr: ColorDisplayHeadDorado.ChanCBPtr _ ColorDisplayHeadDorado.rpNIL;
IF chainPtr = NIL 
THEN {			-- Make new DCB, if unlinked
relPtr _ Alloc[SIZE[ColorDisplayHeadDorado.ChanCB]];
chainPtr _ @ColorDisplayHeadDorado.first64K[relPtr];
chainPtr.link _ ColorDisplayHeadDorado.rpNIL;		-- make sure chain ends here
}
ELSE relPtr _ lastPtr.link;			-- in case chain is already linked (or zeroth link)

IF (link < whichLink) OR (width = 0)							-- null DCB
THEN {
chainPtr.wordsPerLine _ 0; 
chainPtr.bitmap _ NIL; 
chainPtr.linesPerField _ IF link = whichLink  THEN height / 2   ELSE 0; 
chainPtr.pixelsPerLine _ 0;
chainPtr.leftMargin _ LAST[NAT];
chainPtr.scan _ lastPtr.scan;
}
ELSE  {
chainPtr.wordsPerLine _ wordsPerLine; 				-- load visible DCB
chainPtr.bitmap _ bitmap; 
chainPtr.linesPerField _ height / 2; 
chainPtr.pixelsPerLine _ width + 255;
chainPtr.leftMargin _ leftMargin + marginOffset;
chainPtr.scan _ lastPtr.scan;
};
lastPtr.link _ relPtr;											-- link into DCB chain after loaded

lastPtr _ chainPtr;											-- step to next link
IF chainPtr.link = ColorDisplayHeadDorado.rpNIL 
THEN chainPtr _ NIL
ELSE chainPtr _ @ColorDisplayHeadDorado.first64K[chainPtr.link];
link _ link + 1;
ENDLOOP;
};

DeleteDCB: PROC [aChannel: BOOLEAN _ TRUE, whichLink: NAT] ~ TRUSTED {
link: NAT _ 0;
chainPtr, lastPtr: LONG POINTER TO ColorDisplayHeadDorado.ChanCB _ NIL;
IF ColorDisplayHeadDorado.mcb = NIL THEN {
SIGNAL ImagerTerminalExtrasError[$NoColorDisplay];    RETURN[];  };
IF aChannel THEN lastPtr _ chainPtr _
						@ColorDisplayHeadDorado.first64K[ColorDisplayHeadDorado.mcb.achanCB]
				ELSE lastPtr _ chainPtr _
						@ColorDisplayHeadDorado.first64K[ColorDisplayHeadDorado.mcb.bchanCB];
IF chainPtr = NIL THEN {
SIGNAL ImagerTerminalExtrasError[$NoDCBChain];    RETURN[];  };

WHILE (link < whichLink) AND NOT (chainPtr = NIL) DO 
link _ link + 1;
lastPtr _ chainPtr;											-- step to next link
IF chainPtr.link = ColorDisplayHeadDorado.rpNIL 
THEN chainPtr _ NIL
ELSE chainPtr _ @ColorDisplayHeadDorado.first64K[chainPtr.link];
ENDLOOP;
IF link = whichLink THEN lastPtr.link _ chainPtr.link;		-- note, no storage recovery
};

PinPixelMap: PUBLIC PROC [vt: Terminal.Virtual, data: DisplayData, overLay: BOOLEAN _ FALSE] ~ {
logPixelsPerWord: NAT _ Basics.logBitsPerWord - data.pix[0].refRep.lgBitsPerPixel;
bitmapPtr: LONG POINTER;
widthChange, heightChange: INTEGER _ 0;
TRUSTED {
IF data.pix[0].sOrigin >= 0 THEN bitmapPtr _ data.pix[0].refRep.pointer
ELSE  {
bitmapPtr _ data.pix[0].refRep.pointer 
			  + Basics.LongMult[-data.pix[0].sOrigin, data.pix[0].refRep.rast];
heightChange _ data.pix[0].sOrigin;
}; 
IF data.pix[0].fOrigin < 0 THEN  {
ptrChange: NAT _ Basics.BITSHIFT[
							Basics.BITSHIFT[ -data.pix[0].fOrigin, -(logPixelsPerWord+1)],
							1];
bitmapPtr _ bitmapPtr + ptrChange;
widthChange _ -Basics.BITSHIFT[ ptrChange, logPixelsPerWord];
};
};
VM.Pin[ NARROW[data.pix[0].refRep.ref, CountedVM.Handle].interval ];
SetDCB[	aChannel: NOT overLay, 
			bitmap: bitmapPtr,
			leftMargin: 0,
			width: 0,
			height: MAX[0, data.pix[0].sOrigin],
			wordsPerLine: 0,	
			whichLink: 0
		]; 
SetDCB[	aChannel: NOT overLay, 
			bitmap: bitmapPtr,
			leftMargin: MAX[0, data.pix[0].fOrigin],
			width: MAX[0, Basics.BITSHIFT[ data.pix[0].refRep.rast, logPixelsPerWord] + widthChange],
			height: MAX[0, data.pix[0].refRep.lines + heightChange],
			wordsPerLine: data.pix[0].refRep.rast,
			whichLink: 1
		]; 
IF overLay
THEN data.props _ Atom.PutPropOnList[data.props, $PixelMapStatus, $OnAChannel]
ELSE  data.props _ Atom.PutPropOnList[data.props, $PixelMapStatus, $OnBChannel];
};
ReleasePixelMap: PUBLIC PROC [vt: Terminal.Virtual, data: DisplayData] ~ {
IF Atom.GetPropFromList[data.props, $PixelMapStatus] = $OnAChannel 
THEN {  DeleteDCB[TRUE, 1];   
		   data.props _ Atom.PutPropOnList[data.props, $PixelMapStatus, $Allocated];
		}
ELSE IF Atom.GetPropFromList[data.props, $PixelMapStatus] = $OnBChannel 
THEN {  DeleteDCB[FALSE, 1];
		   data.props _ Atom.PutPropOnList[data.props, $PixelMapStatus, $Allocated];
		}
ELSE SIGNAL ImagerTerminalExtrasError[$UnDisplayedPixelMap];
VM.Unpin[ NARROW[data.pix[0].refRep.ref, CountedVM.Handle].interval ]; 	-- release storage
};

LoadRGBColorMap: PUBLIC PROC [vt: Terminal.Virtual, 
									entries: REF ImagerDisplayExtras.RGBSequence, start: NAT _ 0] ~ {
mode: Terminal.ColorMode _ vt.GetColorMode;
vt.WaitForBWVerticalRetrace[];	-- await vt selection and top of scan (to control update rate)
IF mode.full = FALSE  										-- pseudocolor mapped display
THEN IF mode.bitsPerPixelChannelB = 2  							-- 4 tables each 256 entries
THEN {  FOR i: NAT IN [start..entries.length) DO
index: NAT _ i MOD 256;    table: NAT _ i / 256;
vt.SetColor[index, table, entries[i].r, entries[i].g, entries[i].b];
ENDLOOP;  }
ELSE {  FOR i: NAT IN [start..entries.length) DO					-- 16 tables each 16 entries
index: NAT _ i MOD 16;    table: NAT _ i / 16;
vt.SetColor[index, table, entries[i].r, entries[i].g, entries[i].b];
ENDLOOP ;  }
ELSE FOR index: NAT IN [start..entries.length) DO						-- full-color 24-bit display
vt.SetRedMap[index, entries[index].r];
vt.SetGreenMap[index, entries[index].g];
vt.SetBlueMap[index, entries[index].b];
ENDLOOP; 
};

{			-- initialize: set left margin assuming monitor type from resolution (potentially wrong)
SELECT ColorDisplayHeadDorado.screenwidth FROM
640 =>		{  marginOffset _ 54;				-- Hitachi 13" monitors, or Conrac @525 lines
			leftOverBytes _ 460;  };		 -- Exceeding this causes unstable raster
1024 =>	{  marginOffset _ 71;				-- Conrac @768 lines (may be 0, actually)
			leftOverBytes _ 0;  };
ENDCASE;
};
END.


rImagerTerminalExtrasImpl.mesa
This implements control over DCBs and color map for the Dorado color display.
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Last Edited by:
Crow  May 25, 1984 12:14:02 pm PDT
	Check for color display MCB, then DCB chain
	Find desired link in DCB chain
	Load desired link;  Make new links if desired link lies beyond end of chain
	Find desired link in DCB chain
	Delete Link, if found
Pin a pixel map to the color display, replacing whatever was there before.  Overlay = TRUE causes the B-channel to be used.  Overlays may have only 2 or 4 bits per pixel, 4 only if the A-channel (non-overlay) pixelmap has <= 4 bits per pixel.
Catch negative origins and bite into pixelmap
Pin VM pages involved
Set Null DCB to move down proper distance from top of screen
Set DCB representing pixelmap

Remove a pixel map from the color display
Κχ˜
headš
œ™J™M—šœ
Οm
œ1™<š
œ™J™#—
unitš
Οk	˜	Jšœž
œžœ˜BJšžœžœ4˜BJš
œ˜Jšœžœ
˜JšœžœJ˜fJšœžœ˜%Jšœžœ˜%Jšœžœ˜*Jšœžœ"˜2Jšœžœ8˜LJš
œ>˜>Jš
œ˜——
head2šœžœ
ž˜'Jšžœ
žœ0˜:Jšžœ˜Jšžœ˜Lšœž˜Lšœ
žœ˜*I
ašœ
žœ˜.Lš	œžœ
žœ
žœžœ
˜?Lš
œK˜KNšœžœ
˜Nšœžœ
˜—LšΟnœžœžœžœ
žœ
žœ˜>šœ;žœžœ˜Kš
Ÿœžœ	žœžœ*žœ
˜WJšœ
žœ
˜Jš
œ:˜:šžœ.˜0Jš
žœžœ
žœžœžœ˜@—šžœ˜Jšœžœ/žœ˜IJšœ
žœžœ
žœ˜LJšœžœ˜"J˜—Jš
œ˜Jš
œ˜Jš
œ˜—Jšœžœ˜šœžœ
žœ
žœ%˜GJš
œ,™,—šžœžœ
žœ˜*Jšžœ0žœ˜C—Jšžœ
žœ˜%Jš
œJ˜JJšœžœ˜Jš
œK˜Kšžœžœ
žœ˜Jšžœ,žœ˜?—Jšžœžœžœ*žœ˜Wšžœ$žœΟc,˜XJšžœ>˜@Jšžœžœ4žœ˜OJš
œ™—šžœžœ
žœžœ
˜5J˜Jšœ ˜2šžœ.˜0Jšžœž˜Jšžœ<˜@—Jšžœ
˜J˜J™L—šžœž˜Jš
œH˜Hšžœžœ
˜šžœ ˜%Jšœžœ!˜4Jš
œ4˜4Jšœ/ ˜KJš
œ
˜
—Jšžœ 3˜Q—J˜šžœžœ ˜6šžœ˜Jš
œ˜Jšœžœ˜Jšœžœžœžœ˜HJš
œ˜Jšœžœ
žœ˜ Jš
œ˜J˜
—šžœ˜Jšœ) ˜=Jš
œ˜Jš
œ%˜%Jš
œ%˜%Jš
œ0˜0Jš
œ˜J˜——Jšœ! #˜DJ˜Jšœ ˜2šžœ.˜0Jšžœž˜Jšžœ<˜@—Jš
œ˜Jšžœ
˜—Jš
œ˜—L˜šŸ	œžœžœžœ
žœžœ˜FJšœžœ˜Jšœžœ
žœ
žœ%˜Gšžœžœ
žœ˜*Jšžœ0žœ˜C—Jšžœ
žœ˜%Jš
œJ˜JJšœžœ˜Jš
œK˜Kšžœžœ
žœ˜Jšžœ,žœ˜?J˜Jš
œ™—šžœžœ
žœžœ
˜5J˜Jšœ ˜2šžœ.˜0Jšžœž˜Jšžœ<˜@—Jšžœ
˜J™—Jšžœžœ  ˜TJš
œ˜—N˜š
Ÿœžœ
žœ4žœžœ˜`N™ς
š
œR˜RN™-—Nšœžœ
žœ
˜Nšœžœ˜'šžœ˜	šžœžœ&˜Gšžœ˜Nš
œ'˜'Nš
œF˜FNš
œ#˜#Nš
œ˜——šžœžœ˜"Nšœžœ
žœ
˜!Nšœžœ/˜ENš
œ
˜
Nš
œ"˜"Nšœžœ˜=N˜—N˜N™—šžœžœ6˜DN™<—Nšœžœ
˜Nš
œ˜Nš
œ˜Nš
œ˜Nšœžœ˜'Nš
œ˜Nš
œ˜š
œ˜N™—Nšœžœ
˜Nš
œ˜Nšœžœ˜+Nšœ
žœžœ<˜\Nšœžœ-˜;Nš
œ)˜)Nš
œ˜Nš
œ˜Nšžœ˜
NšžœJ˜NNšžœL˜PN˜N™—šŸœžœ
žœ.˜JN™)šžœA˜CNšžœžœ˜Nš
œN˜NN˜—šžœ
žœA˜HNšžœžœ˜Nš
œN˜NN˜—Nšžœ
žœ1˜<Nšžœžœ8 ˜ZN˜N˜—NšŸœžœ
žœ˜4šœžœ)žœ	˜JNš
œ+˜+Nšœ >˜]Nšžœ
žœ ˜=šžœ' ˜Jš	žœžœžœ
žœž˜0Nšœžœžœžœ˜0Nš
œD˜DNšžœ˜—šžœžœžœ
žœžœ ˜QNšœžœžœžœ
˜.Nš
œD˜DNšžœ˜——šžœ
žœžœ
žœžœ ˜SNš
œ&˜&Nš
œ(˜(Nš
œ'˜'Nšžœ˜	—Nš
œ˜L˜—šœ X˜\šžœ$ž˜.šœ! -˜NNšœ (˜F—šœ! )˜JN˜——Nšžœ
˜N˜—Nšžœ
˜J˜J˜—…—!(-‘