DIRECTORY Real USING [Float], Imager USING [PathFromIntRectangle, Context], ImagerBasic USING [Path, Vec, IntVec, IntRectangle, Visibility], ImagerInternalDefs USING [ImagingSpace, Clipper, ClipperRecord, TransformRecord], ImagerTransform USING [IntTransform, TransformIntVec], ImagerClipper; ImagerClipperImpl: CEDAR PROGRAM IMPORTS Imager, ImagerTransform, Real EXPORTS Imager, ImagerClipper = BEGIN OPEN ImagerBasic; ClipPath: PUBLIC PROC [context: Context, outline: Path, exclude: BOOLEAN _ FALSE] = { context.clientClipper _ ClipClipper[context.clientClipper, TransformClipper[ClipperFromPath[area], context.clientTransform]]; ValidateCompositeClipper[context]; }; ClipRectangle: PROC [context: Context, outline: Rectangle, exclude: BOOLEAN _ FALSE]; TestRectangle: PUBLIC PROC [context: Context, area: Rectangle] RETURNS [Visibility] = { state: Visibility; clipper: ClipperRecord _ ClipperFromPath[area]; SELECT context.clipper.type FROM rectangle => { state _ TestClipperRectangle[clipper, context.clipper]; IF state = visible THEN context.noClipArmed _ TRUE; RETURN [ state ]; }; path => ERROR; -- until M. Plass works here ENDCASE => ERROR; }; TestPoint: PUBLIC PROC [context: Context, point: Vec] RETURNS [BOOLEAN] = { SELECT context.clipper.type FROM rectangle => IF (point.x <= Real.Float[context.clipper.xMax]) AND (point.x >= Real.Float[context.clipper.xMin]) AND (point.y <= Real.Float[context.clipper.yMax]) AND (point.y >= Real.Float[context.clipper.yMin]) THEN RETURN[ TRUE ] ELSE RETURN[ FALSE ]; path => ERROR; -- until M. Plass works here ENDCASE => ERROR; }; ClipIntRectangle: PUBLIC PROC [context: Context, outline: IntRectangle, exclude: BOOLEAN _ FALSE] = { IF context.clientTransform.type = hard THEN ConcatArea[context, Imager.PathFromIntRectangle[area]] ELSE ConcatRectangle[context, client, EZTfmRectangle[area, context.clientTransform]]; ValidateCompositeClipper[context]; }; TestIntRectangle: PUBLIC PROC [context: Context, area: IntRectangle] RETURNS [Visibility] = { state: Visibility; SELECT context.clipper.type FROM rectangle => { state _ TestClipperRectangle[ClipperFromRectangle[area], context.clipper]; IF state = visible THEN context.noClipArmed _ TRUE; RETURN [ state ]; }; path => RETURN [ TestArea[context, Imager.PathFromIntRectangle[area]] ]; ENDCASE => ERROR; }; TestIntPoint: PUBLIC PROC [context: Context, point: IntPair] RETURNS [BOOLEAN] = { SELECT context.clipper.type FROM rectangle => IF (point.x <= context.clipper.xMax) AND (point.x >= context.clipper.xMin) AND (point.y <= context.clipper.yMax) AND (point.y >= context.clipper.yMin) THEN RETURN[ TRUE ] ELSE RETURN[ FALSE ]; path => ERROR; -- until M. Plass works here ENDCASE => ERROR; }; DoWithoutClipping: PUBLIC PROC [context: Context, callBack: PROC[Context]] = { IF context.noClipArmed THEN context.noClip _ TRUE ELSE ERROR; callBack[ context ]; context.noClipArmed _ FALSE; context.noClip _ FALSE; }; SetClipper: PUBLIC PROC [context: Context, clipSpace: ImagingSpace, clipper: ClipperRecord] = { SELECT clipSpace FROM client => context.clientClipper _ clipper; viewer => context.viewerClipper _ clipper; device => context.deviceClipper _ clipper; ENDCASE => ERROR; ValidateCompositeClipper[context]; }; GetClipper: PUBLIC PROC [context: Context, clipSpace: ImagingSpace, clipper: ClipperRecord] = { SELECT clipSpace FROM client => clipper _ context.clientClipper; viewer => clipper _ context.viewerClipper; device => clipper _ context.deviceClipper; ENDCASE => ERROR; }; IntersectClipBoxes: PROC [clpr1, clpr2: ClipperRecord] RETURNS [ClipperRecord] = { clipper: ClipperRecord; clipper.xMin _ MAX[clpr1.xMin, clpr2.xMin]; clipper.xMax _ MIN[clpr1.xMax, clpr2.xMax]; clipper.yMin _ MAX[clpr1.yMin, clpr2.yMin]; clipper.yMax _ MIN[clpr1.yMax, clpr2.yMax]; IF (clipper.xMin >= clipper.xMax) OR (clipper.yMin >= clipper.yMax) -- disjoint areas? THEN { clipper.xMax _ clipper.xMin; clipper.yMax _ clipper.yMin; }; -- make null clipper.type _ rectangle; RETURN[clipper]; }; TestClipperRectangle: PROC [clippee, clipper: ClipperRecord] RETURNS [Visibility] = { IF (clippee.xMax <= clipper.xMin) OR (clippee.xMin >= clipper.xMax) OR (clippee.yMax <= clipper.yMin) OR (clippee.yMin >= clipper.yMax) THEN RETURN[ invisible ] ELSE IF (clippee.xMax <= clipper.xMax) AND (clippee.xMin >= clipper.xMax) AND (clippee.yMax <= clipper.yMax) AND (clippee.yMin >= clipper.yMin) THEN RETURN[ visible ] ELSE RETURN[ partlyVisible ]; }; ClipClipper: PROC [clipper1, clipper2: ClipperRecord] RETURNS [ClipperRecord] = { IF (clipper1.type = rectangle) AND (clipper2.type = rectangle) THEN RETURN [ IntersectClipBoxes[clipper1, clipper2] ] ELSE ERROR; -- M. Plass needed here }; ClipperFromPath: PROC [area: Path] RETURNS [ClipperRecord] = { clipper: ClipperRecord; clipper.type _ none; -- until M. Plass works here RETURN[clipper]; }; PathFromClipper: PROC [clipper: ClipperRecord] RETURNS [Path] = { path: Path; RETURN[path]; -- until M. Plass works here }; ClipperFromRectangle: PROC [area: IntRectangle] RETURNS [ClipperRecord] = { clipper: ClipperRecord; { OPEN clipper; type _ rectangle; xMin _ MIN[area.x, area.x + area.w]; xMax _ MAX[area.x, area.x + area.w]; yMin _ MIN[area.y, area.y + area.h]; yMax _ MAX[area.y, area.y + area.h]; clipper _ NIL; }; RETURN[clipper]; }; RectangleFromClipper: PROC [clipper: ClipperRecord] RETURNS [IntRectangle] = { OPEN clipper; RETURN [ IntRectangle[xMin, yMin, xMax - xMin, yMax - yMin] ]; }; EZTfmRectangle: PROC [area: IntRectangle, transform: TransformRecord] RETURNS [IntRectangle] = { rect: IntRectangle; IF (transform.type = hard) OR (transform.type = none) THEN ERROR; [[rect.x, rect.y]] _ ImagerTransform.IntTransform[transform, IntVec[area.x, area.y]]; [[rect.w, rect.h]] _ ImagerTransform.TransformIntVec[transform, IntVec[area.w, area.h]]; RETURN[ rect ]; }; TransformClipper: PROC [clipper: ClipperRecord, transform: TransformRecord] RETURNS [ClipperRecord] = { IF (transform.type # hard) AND (clipper.type = rectangle) THEN RETURN [ ClipperFromRectangle[ EZTfmRectangle[RectangleFromClipper[clipper], transform]] ] ELSE ERROR; -- M. Plass needed here }; ValidateCompositeClipper: PROC [context: Context] = { context.clipper _ ClipClipper[ TransformClipper[ ClipClipper[ TransformClipper[context.clientClipper, context.viewerTransform], context.viewerClipper], context.deviceTransform], context.deviceClipper]; }; END. ˜ImagerClipperImpl.mesa Created April 28, 1983 Last Edited by: Crow, June 20, 1983 8:46 pm Client-called Procedures Client clipping areas are first transformed to fix them on the viewer Modifies old clipping region by supplied outline. Exclude sets clipping outside path rather than inside. The Composite clipper is held in the device space, where clipping actually takes place. Therefore, incoming data is expected in device space (pretransformed). Modifies old clipping region by supplied outline. Exclude sets clipping outside path rather than inside. Fast Track procedures Modifies old clipping region by supplied outline. Exclude sets clipping outside path rather than inside. Each call must be preceded by a successful call to TestArea or TestIntRectangle Unpublicized Procedures Internal Procedures Does rectangle-preserving easy transforms only Assemble composite clipper, leave result in device space Ê8˜head™J™J™,šÏk ˜ Jšœ œ ˜Jšœ œ!˜0Jšœœ/˜BJšœœ9˜QJšœœ!˜6Jšœ˜——šœ ˜ Jšœ˜%Jšœ˜J˜Jšœœœ ˜—™J™EunitšÏnœœ+œœ˜UJšœi™iJšœ:˜:JšœI˜IJšœ"˜"J˜—LšÏiŸ™Ÿšž œœ1œœ˜UJšœi™i—šž œœ%œ˜WJšœ˜Jšœ/˜/Jšœ˜ šœE˜FJšœœœœ˜7Jšœœ˜—Jšœ œÏc˜/Jšœœ˜J˜—šž œœ œœ˜KJšœ˜ Jšœœ/œ˜BJšœ3˜6Jšœ3œ˜7Jšœ2˜2Jšœœœœ˜Jšœœœœ˜Jšœ œ ˜.Jšœœ˜J˜—LšŸ™šžœœ3œœ˜eJšœi™iJšœ'˜'Jšœ7˜;JšœQ˜UJšœ"˜"J˜—šžœœ(œ˜]Jšœ˜Jšœ˜ šœ œJ˜YJšœœœœ˜7Jšœœ˜—Jšœ œ:˜IJšœœ˜J˜—šžœœ$œœ˜RJšœ˜ Jšœ œ#œ#˜[Jšœ'œ"˜LJšœœœœ˜Jšœœœœ˜Jšœ œ ˜.Jšœœ˜J˜—šžœœœ˜NJšœ3žœž™OJš œœœœœ˜>Jšœ˜Jšœœœ˜7Jšœ˜——™šž œœH˜_Jšœ ˜Jšœ-˜-Jšœ+˜+Jšœ+˜+Jšœœ˜Jšœ"˜"J˜—šž œœH˜_Jšœ ˜Jšœ-˜-Jšœ+˜+Jšœ+˜+Jšœœ˜J˜——™šžœœœ˜RJšœ˜Jšœœ˜+Jšœœ˜+Jšœœ˜+Jšœœ˜+Jšœ œ! ˜WJšœF ˜VJšœ˜Jšœ ˜Jšœ˜—šžœœ#œ˜UJšœ"œ ˜HJšœ"œ ˜DJšœœ ˜Jšœœ œ ˜MJšœ"œ˜DJšœœ˜Jšœœ˜J˜—šžœœ%œ˜QJšœœ˜?Jšœœ+˜6Jšœœ ˜,J˜—šžœœœ˜>Jšœ˜Jšœ ˜5Jšœ ˜J˜—šžœœœ˜AJ˜Jšœ ˜0Jšœ˜—šžœœœ˜KJšœ˜šœ ˜Jšœ˜Jšœœ˜$Jšœœ˜$Jšœœ˜$Jšœœ˜$Jšœ œ˜Jšœ˜—Jšœ ˜J˜—šžœœœ˜NJšœ ˜ Jšœ8˜>Jšœ˜—Lšžœœ2˜Fšœœ˜!J™.Jšœ˜Jšœœœœ˜AJšœU˜UJšœX˜XJšœ ˜Jšœ˜—Lšžœœ6˜Lšœœ˜!Jšœœ˜:Jšœœ˜#JšœC˜CJšœœ ˜,Jšœ˜—šžœœ˜5J™8šœ˜šœ˜šœ˜šœ˜šœA˜AJšœ˜—Jšœ˜—Jšœ˜———Jšœ˜—J˜Jšœ˜——…—$`