CDDefaultProcsImpl.mesa (part of ChipNDale)
Copyright © 1985, 1986 by Xerox Corporation. All rights reserved.
Created by Ch. Jacobi, May 22, 1985 3:35:49 pm PDT
Last edited by: Christian Jacobi, December 4, 1986 4:53:18 pm PST
DIRECTORY
Atom,
Basics,
CD,
CDBasics,
CDBasicsInline,
CDDefaultProcs,
CDDirectory,
Imager,
ImagerBackdoor,
ImagerManhattan,
ImagerMaskCapture,
ImagerTransformation,
Rope,
TokenIO;
CDDefaultProcsImpl:
CEDAR
PROGRAM
IMPORTS Atom, --Basics,-- CD, CDBasics, --CDBasicsInline,-- CDDirectory, Imager, --ImagerBackdoor,-- ImagerManhattan, ImagerMaskCapture, ImagerTransformation, Rope
EXPORTS CDDefaultProcs
SHARES CD =
BEGIN
OPEN CD;
--ObjectClass
QuickDrawMe:
PUBLIC
PROC [inst: Instance, trans: Transformation, pr:
REF DrawInformation] = {
IF inst.ob.class.drawMe#DrawMe THEN inst.ob.class.drawMe[inst, trans, pr]
ELSE {
ob1: CD.Object = CDDirectory.Expand[inst.ob].new;
IF ob1#
NIL
THEN {
pseudoInst: CD.Instance = NEW[CD.InstanceRep ← [ob: ob1, properties: inst.properties, trans: trans]];
ob1.class.quickDrawMe[pseudoInst, trans, pr];
pseudoInst.ob ← NIL;
pseudoInst.properties ← NIL;
}
ELSE pr.drawRect[CDBasics.MapRect[inst.ob.bbox, trans], CD.shadeLayer, pr]
}
};
DrawMe:
PUBLIC PROC [inst: Instance, trans: Transformation, pr:
REF DrawInformation] = {
IF inst.ob.class.quickDrawMe#QuickDrawMe THEN inst.ob.class.quickDrawMe[inst, trans, pr]
ELSE {
ob1: CD.Object = CDDirectory.Expand[inst.ob].new;
IF ob1#
NIL
THEN {
pseudoInst: CD.Instance = NEW[CD.InstanceRep ← [ob: ob1, properties: inst.properties, trans: trans]];
ob1.class.drawMe[pseudoInst, trans, pr];
pseudoInst.ob ← NIL;
pseudoInst.properties ← NIL;
}
ELSE pr.drawRect[CDBasics.MapRect[inst.ob.bbox, trans], CD.shadeLayer, pr]
}
};
ShowMeSelected:
PUBLIC
PROC [inst: Instance, trans: Transformation, pr:
REF DrawInformation] = {
pr.drawOutLine[CDBasics.MapRect[CD.InterestRect[inst.ob], trans],CD.selectionLayer, pr]
};
ShowMeSelectedWithExpand:
PUBLIC
PROC [inst: Instance, trans: Transformation, pr:
REF DrawInformation] = {
ob1: CD.Object = CDDirectory.Expand[inst.ob].new;
IF ob1=
NIL
THEN
pr.drawOutLine[CDBasics.MapRect[CD.InterestRect[inst.ob], trans], CD.selectionLayer, pr]
ELSE
ob1.class.showMeSelected[NEW[CD.InstanceRep ← [ob: ob1, trans: trans, selected: inst.selected]], trans, pr];
};
HitInside:
PUBLIC PROC [ob: Object, hitRect: Rect]
RETURNS [
BOOL] = {
RETURN [CDBasics.Intersect[CD.InterestRect[ob], hitRect] ]
};
InterestRect:
PUBLIC PROC [ob: Object]
RETURNS [Rect] = {
RETURN [ob.bbox]
};
InterestRectWithExpand:
PUBLIC
PROC [ob: Object]
RETURNS [Rect] = {
ob1: CD.Object = CDDirectory.Expand[ob].new;
RETURN [(IF ob1#NIL THEN CD.InterestRect[ob1] ELSE ob.bbox)]
};
InternalRead:
PUBLIC
PROC [h: TokenIO.Handle, key:
ATOM]
RETURNS [Object] = {
ERROR
};
Describe:
PUBLIC
PROC [ob: Object]
RETURNS [Rope.
ROPE] = {
Desc:
PROC [class:
CD.ObjectClass]
RETURNS [Rope.
ROPE] =
INLINE {
RETURN [
IF class.description=NIL THEN Atom.GetPName[class.objectType]
ELSE class.description
]
};
IF ob.class.inDirectory
THEN {
n: Rope.ROPE = CDDirectory.Name[ob];
IF ~Rope.IsEmpty[n] THEN RETURN [Rope.Cat[Desc[ob.class], " ", n]]
};
RETURN [Desc[ob.class]]
};
DescribeInstance:
PUBLIC
PROC [inst: Instance]
RETURNS [Rope.
ROPE] = {
RETURN [inst.ob.class.describe[inst.ob]]
};
--DrawProcs
DrawChild:
PUBLIC
PROC [inst: Instance, trans: Transformation, pr:
REF DrawInformation] = {
inst.ob.class.drawMe[inst, trans, pr]
};
DrawChildSel:
PUBLIC
PROC [inst: Instance, trans: Transformation, pr:
REF DrawInformation] = {
inst.ob.class.showMeSelected[inst, trans, pr]
};
DrawRect:
PUBLIC
PROC [r: Rect, l: Layer, pr: DrawRef] = {
DrawRectInContext:
PROC [context: Imager.Context, ob:
CD.Object, layer:
CD.Layer] = {
Imager.MaskBox[context, [xmin: r.x1, xmax: r.x2, ymin: r.y1, ymax: r.y2]];
};
pr.drawContext[pr, DrawRectInContext, NIL, [[0, 0], original], l]
};
IgnoreOutLine:
PUBLIC
PROC [r: Rect, l: Layer, pr: DrawRef] = {
};
ContextOutLine:
PUBLIC
PROC [r: Rect, l: Layer, pr: DrawRef] = {
ActionWithContext:
PROC [] = {
Imager.SetColor[pr.deviceContext, pr.contextColors[l]];
Imager.MaskVector[pr.deviceContext, [r.x1, r.y1], [r.x2, r.y1]];
Imager.MaskVector[pr.deviceContext, [r.x2, r.y1], [r.x2, r.y2]];
Imager.MaskVector[pr.deviceContext, [r.x2, r.y2], [r.x1, r.y2]];
Imager.MaskVector[pr.deviceContext, [r.x1, r.y2], [r.x1, r.y1]];
};
IF pr.deviceContext#
NIL
THEN {
IF pr.contextColors[l]#NIL THEN Imager.DoSave[pr.deviceContext, ActionWithContext]
}
};
DrawComment:
PUBLIC
PROC [r: Rect, comment: Rope.
ROPE, pr: DrawRef] = {
};
--version with bitmaps
DrawContext: PUBLIC PROC [pr: DrawRef, proc: DrawContextLayerProc, ob: Object, pos: Position, orient: Orientation, layer: Layer] = {
--calls proc which may use context; mode and color are set to layer's need
--call is suppressed if layer does not need drawing; this is default.
--on recursive calls, the context may or may not include previous transformations
ActionWithContext: PROC [] = {
IF ob#NIL THEN {
Imager.TranslateT[pr.deviceContext, [pos.x, pos.y]];
OrientateContext[pr.deviceContext, ob.size, orient];
};
Imager.SetColor[pr.deviceContext, pr.contextFilter[layer]];
proc[pr.deviceContext, ob, layer];
};
IF pr.contextFilter#NIL AND pr.contextFilter[layer]#NIL THEN {
IF pr.deviceContext#NIL THEN Imager.DoSave[pr.deviceContext, ActionWithContext]
ELSE IF ob#NIL THEN {
--if ob is nil we don't know the size for the bitmap nor the clip region
clip: CD.Rect ~ CDBasics.DeMapRect[itemInWorld: pr.interestClip, cellSize: ob.size, cellInstOrient: orient, cellInstPos: pos].itemInCell; --in object coordinates
inter: CD.Rect ~ CDBasics.Intersection[CDBasics.RectAt[[0, 0], ob.size], clip];
IF CDBasics.NonEmpty[inter] THEN {
DrawToBitmapContext: PROC [] = {
proc[context, ob, layer];
};
CapturePixel: PROC [x, y: INT] = INLINE {
r: CD.Rect ← CDBasics.MapRect[itemInCell: [x1: x, y1: y, x2: x+1, y2: y+1], cellSize: ob.size, cellInstOrient: orient, cellInstPos: pos];
r ← CDBasics.Intersection[r, pr.interestClip];
IF CDBasics.NonEmpty[r] THEN pr.drawRect[r, layer, pr];
};
CaptureBitmap: PROC [bitmap: ImagerBackdoor.Bitmap, off: CD.Position] = {
FOR y: CARDINAL IN [0..bitmap.height) DO
FOR x: CARDINAL IN [0..bitmap.width) DO
TRUSTED {
bitsRef: LONG POINTER TO CARDINAL
← LOOPHOLE[bitmap.base, LONG POINTER TO CARDINAL]
+ LONG[y]*bitmap.wordsPerLine
+ LONG[x/Basics.bitsPerWord];
IF Basics.BITAND[8000h, Basics.BITSHIFT[bitsRef^, x MOD Basics.bitsPerWord]]#0 THEN
CapturePixel[off.x+x, off.y+bitmap.height-y-1]
}
ENDLOOP;
ENDLOOP;
};
bitmap: ImagerBackdoor.Bitmap ← ImagerBackdoor.NewBitmap[width: inter.x2-inter.x1, height: inter.y2-inter.y1];
context: Imager.Context ← ImagerBackdoor.BitmapContext[bitmap];
Imager.SetColor[context, Imager.white];
Imager.MaskRectangleI[context, 0, 0, bitmap.width, bitmap.height];
Imager.TranslateT[context, [-inter.x1, -inter.y1]];
Imager.SetColor[context, Imager.black];
Imager.DoSave[context, DrawToBitmapContext];
CaptureBitmap[bitmap, CDBasics.BaseOfRect[inter]];
bitmap ← NIL;
context ← NIL;
};
};
};
};
TransContext:
PROC [cont: Imager.Context, trans: Transformation] =
INLINE {
Imager.TranslateT[cont, [trans.off.x, trans.off.y]];
IF CDBasics.IncludesMirrorX[trans.orient] THEN Imager.Scale2T[cont, [-1, 1]];
SELECT CDBasics.ConcentrateOnRotate90[trans.orient]
FROM
original => NULL;
rotate90 => Imager.RotateT[cont, 90];
rotate180 => Imager.RotateT[cont, 180];
rotate270 => Imager.RotateT[cont, 270];
ENDCASE => ERROR;
--or Imager.ConcatT[cont, CDBasicsInline.ImagerTransform[trans]]
};
DrawContext:
PUBLIC
PROC [pr: DrawRef, proc: DrawContextLayerProc, ob: Object, trans: Transformation, layer: Layer] = {
--calls proc which may use context; mode and color are set to layer's need
--call is suppressed if layer does not need drawing; this is default.
--on recursive calls, the context may or may not include previous transformations
ActionWithContext:
PROC [] = {
IF ob#NIL THEN TransContext[pr.deviceContext, trans];
Imager.SetColor[pr.deviceContext, pr.contextColors[layer]];
proc[pr.deviceContext, ob, layer];
};
IF pr.deviceContext#
NIL
THEN {
IF pr.contextColors[layer]#NIL THEN Imager.DoSave[pr.deviceContext, ActionWithContext]
}
ELSE
IF pr.contextFilter#
NIL
AND pr.contextFilter[layer]
THEN {
IF ob#
NIL
THEN {
--if ob is nil we don't know the size for the bitmap nor the clip region
clip: CD.Rect ~ CDBasics.DeMapRect[pr.interestClip, trans].itemInCell; --in object coordinates
inter: CD.Rect ~ CDBasics.Intersection[ob.bbox, clip];
IF CDBasics.NonEmpty[inter]
THEN {
Operator:
PROC [context: Imager.Context] = {
Imager.SetStrokeWidth[context, 1];
Imager.SetStrokeEnd[context, round];
Imager.SetStrokeJoint[context, round];
Imager.ClipRectangle[context, [x: inter.x1, y: inter.y1, w: inter.x2-inter.x1, h: inter.y2-inter.y1]];
proc[context, ob, layer ! ImagerMaskCapture.Cant => --RESUME--REJECT];
};
man: ImagerMaskCapture.Manhattan;
man ← ImagerMaskCapture.CaptureManhattan[Operator, ImagerTransformation.Scale[1]];
FOR m: ImagerMaskCapture.Manhattan ← man, m.rest
UNTIL m=
NIL
DO
r: CD.Rect ← CDBasics.MapRect[[x1: m.first.sMin, y1: m.first.fMin, x2: m.first.sMin+m.first.sSize, y2: m.first.fMin+m.first.fSize], trans];
r ← CDBasics.Intersection[r, pr.interestClip];
IF CDBasics.NonEmpty[r] THEN pr.drawRect[r, layer, pr];
ENDLOOP;
ImagerManhattan.Destroy[man];
};
};
};
};
IgnoreGround:
PUBLIC PROC [pr: DrawRef, pushedOut:
BOOL] = {
};
IgnorePriority:
PUBLIC PROC [pr: DrawRef] = {
};
END.