DIRECTORY Atom, Imager, ImagerBasic, ImagerDisplay, ImagerFrameBuffer, ImagerManhattan, ImagerMasks, ImagerPixelMaps, ImagerPrivate, Terminal, TerminalExtras; ImagerExampleDisplayImpl: CEDAR PROGRAM IMPORTS Atom, Imager, ImagerDisplay, ImagerFrameBuffer, ImagerMasks, ImagerPrivate, Terminal, TerminalExtras ~ BEGIN DisplayClass: TYPE ~ ImagerDisplay.DisplayClass; DisplayClassRep: TYPE ~ ImagerDisplay.DisplayClassRep; DisplayData: TYPE ~ ImagerDisplay.DisplayData; DisplayDataRep: TYPE ~ ImagerDisplay.DisplayDataRep; DeviceRectangle: TYPE ~ ImagerBasic.DeviceRectangle; Color: TYPE ~ ImagerBasic.Color; ColorRep: TYPE ~ ImagerBasic.ColorRep; SampledColor: TYPE = REF ColorRep.sampled; ConstantColor: TYPE = REF ColorRep.constant; SpecialColor: TYPE = REF ColorRep.special; Mask: TYPE ~ ImagerMasks.Mask; ManhattanPolygon: TYPE ~ ImagerManhattan.Polygon; exampleDisplayClass: ImagerDisplay.DisplayClass ~ NEW[ImagerDisplay.DisplayClassRep _ [ displayType: $Gray8bpp, viewUnitsPerPixel: 1, Create: Create, ApplyMask: ApplyMask, DoUnderLock: DoUnderLock ]]; Create: PROC [displayClass: DisplayClass, creationData: REF] RETURNS [displayData: DisplayData] ~ { ppi: REAL _ 42; WITH creationData SELECT FROM props: Atom.PropList => { ppiRef: REF _ Atom.GetPropFromList[props, $pixelsPerInch]; WITH ppiRef SELECT FROM r: REF REAL => ppi _ r^; i: REF INT => ppi _ i^; ENDCASE => NULL; }; ENDCASE => NULL; displayData _ NEW[DisplayDataRep[1]]; displayData.displayClass _ displayClass; displayData.xRes _ ppi; displayData.yRes _ ppi; displayData.rotate _ TRUE; TRUSTED {displayData[0] _ ImagerFrameBuffer.GrayScaleDisplay8[]}; displayData.surfaceWidth _ displayData[0].fSize; displayData.surfaceHeight _ displayData[0].sSize; }; DoUnderLock: PROC [displayData: DisplayData, action: PROC, rectangle: DeviceRectangle] ~ { vt: Terminal.Virtual _ Terminal.Current[]; TerminalExtras.LockColorFrame[ vt: vt, xmin: MAX[rectangle.fMin, 0], ymin: MAX[rectangle.sMin, 0], xmax: MAX[rectangle.fMin+rectangle.fSize, 0], ymax: MAX[rectangle.sMin+rectangle.sSize, 0] ]; action[! UNWIND => {TerminalExtras.UnlockColorFrame[vt]}]; TerminalExtras.UnlockColorFrame[vt]; }; ApplyMask: PROC [displayData: DisplayData, color: Color, mask: Mask, sTranslate, fTranslate: INTEGER] ~ { LockedApplyMask: PROC ~ { function: ImagerPixelMaps.Function _ [null, null]; IF color = Imager.XOR THEN { color _ Imager.white; function _ [xor, null]; }; WITH color SELECT FROM constantColor: ConstantColor => { pixelValue: [0..255] _ constantColor.Y/256; ImagerMasks.ApplyConstant[ mask: mask, clipper: displayData.compositeClipper, dest: displayData[0], value: pixelValue, function: function, sTranslate: sTranslate, fTranslate: fTranslate ]; }; ENDCASE => Imager.Error[$UnsupportedColorType]; }; bb: DeviceRectangle _ ImagerMasks.BoundingBox[mask]; bb.sMin _ bb.sMin + sTranslate; bb.fMin _ bb.fMin + fTranslate; IF color # displayData.cachedColor THEN { displayData.cachedColorData _ NIL; displayData.cachedColor _ color; }; DoUnderLock[displayData, LockedApplyMask, bb]; }; exampleImagerClass: ImagerPrivate.Class ~ ImagerDisplay.CreateImagerClass[exampleDisplayClass]; ImagerPrivate.RegisterDevice[exampleImagerClass]; END. œImagerExampleDisplayImpl.mesa Michael Plass, March 26, 1984 11:52:02 am PST This is an example implementation of an Imager display device. It implements an 8-bit-per-pixel gray-level display with no antialiasing. The creationData is inherited from the Create call. Here we ignore it, but a possible use for it is to point to an alternate buffer. This is where we would calculate any cached color data. ʧ˜J™™-J™—šÏk œ•˜žJ˜—šœ ˜'Jšœh˜t™‰J˜—Jšœœ˜0Jšœœ!˜6Jšœ œ˜.Jšœœ ˜4Jšœœ˜4šœœ˜ Jšœ œ˜&Jšœœœ˜*Jšœœœ˜,Jšœœœ˜*—Jšœœ˜šœœ˜1J˜—šœ2œ"˜WJšœ˜Jšœ˜Jšœ˜Jšœ˜Jšœ˜J˜J˜—šÏnœœ,œ˜