GGModelTypes.mesa
Last edited by: Eric Bier on January 22, 1987 4:34:50 pm PST
Copyright c 1985 by Xerox Corporation. All rights reserved.
Stone, August 5, 1985 2:13:37 pm PDT
Pier, October 21, 1986 1:17:19 pm PDT
DIRECTORY
GGBasicTypes, GGSegmentTypes, Imager, ImagerPath, ImagerTransformation, IO, Rope, Rosary, ViewerClasses;
GGModelTypes: CEDAR DEFINITIONS = BEGIN
Imported Types
Viewer: TYPE = ViewerClasses.Viewer;
Point: TYPE = GGBasicTypes.Point;
Vector: TYPE = GGBasicTypes.Vector;
Line: TYPE = GGBasicTypes.Line;
Circle: TYPE = GGBasicTypes.Circle;
BoundBox: TYPE = GGBasicTypes.BoundBox;
BitVector: TYPE = GGBasicTypes.BitVector;
BitMatrix: TYPE = GGBasicTypes.BitMatrix;
SequenceOfReal: TYPE = GGBasicTypes.SequenceOfReal;
SelectedObjectData: TYPE = GGSegmentTypes.SelectedObjectData;
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
Joint: TYPE = GGSegmentTypes.Joint;
Joint and Control Point sizes
jointSize: REAL = 6;
halfJointSize: REAL = 3;
hotJointSize: REAL = 10;
halfHotJointSize: REAL = 5;
Scene and View
Scene: TYPE = REF SceneObj;
SceneObj:
TYPE;
-- Opaque Type, Implemented by GGObjectsImpl
CameraData: TYPE = REF CameraDataObj;
CameraDataObj:
TYPE =
RECORD [
quality: QualityMode ← fast,
displayStyle: DisplayStyle ← print,
hideHot: BOOL ← FALSE,
hideAlignments: BOOL ← FALSE
];
DisplayStyle:
TYPE = {print, screen};
print uses Press fonts on the screen.
screen uses Tioga fonts on the screen
QualityMode:
TYPE = {fast, showall, quality};
fast is for interactive use.
showall is for making interpress masters which look like the screen.
quality is for previewing masters on the screen and making interpress masters for final artwork.
Slices
SliceDescriptor: TYPE = REF SliceDescriptorObj;
SliceDescriptorObj:
TYPE =
RECORD [
slice: Slice,
parts: SliceParts
];
SliceParts: TYPE = REF ANY;
Slice: TYPE = REF SliceObj;
SliceObj:
TYPE =
RECORD [
class: SliceClass,
data: REF ANY,
parent: Slice, -- for when slices can be part of clusters
selectedInFull: SelectedObjectData,
normalSelectedParts: SliceParts, -- maintained by GGSelect to improve performance
hotSelectedParts: SliceParts, -- maintained by GGSelect to improve performance
activeSelectedParts: SliceParts, -- maintained by GGSelect to improve performance
boundBox: BoundBox ← NIL,
onOverlay: BOOL ← FALSE,
extraPoints: LIST OF Joint,
priority: INT ← 0, -- scene order priority. 0 => in back
mark: BOOL ← FALSE -- for sweeping thru scenes by Undelete mechanism
];
SliceClass: TYPE = REF SliceClassObj;
SliceClassObj:
TYPE =
RECORD [
getBoundBox: SliceBoundBoxProc, -- includes space for stroke width and control points
getTightBox: SliceTightBoxProc, -- fits tightly around the graphical part of the slice
copy: SliceCopyProc,
Drawing
drawParts: SliceDrawPartsProc,
drawTransform: SliceDrawTransformProc,
drawSelectionFeedback: SliceDrawSelectionFeedbackProc,
drawAttractorFeedback: SliceDrawAttractorFeedbackProc,
Transforming
transform: SliceTransformProc,
Textual Description
describe: SliceDescribeProc,
fileout: SliceFileoutProc,
filein: SliceFileinProc,
Parts
emptyParts: SliceEmptyPartsProc,
newParts: SliceNewPartsProc,
unionParts: SliceUnionPartsProc,
differenceParts: SliceDifferencePartsProc,
movingParts: SliceMovingPartsProc,
fixedParts: SliceFixedPartsProc,
augmentParts: SliceAugmentPartsProc,
setSelectedFields: SliceSetSelectedFieldsProc,
Part Generators
pointsInDescriptor: SlicePointsInDescriptorProc,
pointPairsInDescriptor: SlicePointPairsInDescriptorProc,
nextPoint: SliceNextPointProc,
nextPointPair: SliceNextPointPairProc,
Hit Testing
closestPoint: SliceClosestPointProc,
closestPointAndTangent: SliceClosestPointAndTangentProc,
closestSegment: SliceClosestSegmentProc,
lineIntersection: SliceLineIntersectionProc,
circleIntersection: SliceCircleIntersectionProc,
hitDataAsSimpleCurve: SliceHitDataAsSimpleCurveProc,
Style
setStrokeWidth: SliceSetStrokeWidthProc,
getStrokeWidth: SliceGetStrokeWidthProc,
setStrokeColor: SliceSetStrokeColorProc,
getStrokeColor: SliceGetStrokeColorProc,
setFillColor: SliceSetFillColorProc,
getFillColor: SliceGetFillColorProc,
setArrows: SliceSetArrowsProc,
getArrows: SliceGetArrowsProc,
setDashed: SliceSetDashedProc,
getDashed: SliceGetDashedProc
];
Fundamental Slice Routines
SliceBoundBoxProc:
TYPE =
PROC [slice: Slice, parts: SliceParts]
RETURNS [box: BoundBox];
Returns the geometric bound box for the named parts of the slice. IF parts = NIL, find the boundBox of the whole slice. The returned boundbox will allow space for control points and stroke width.
SliceTightBoxProc:
TYPE =
PROC [slice: Slice, parts: SliceParts]
RETURNS [box: BoundBox];
Returns the tight fitting geometric bound box for the named parts of the slice. IF parts = NIL, find the boundBox of the whole slice.
SliceCopyProc: TYPE = PROC [slice: Slice] RETURNS [copy: Slice];
SliceDrawPartsProc:
TYPE =
PROC [slice: Slice, parts: SliceParts, dc: Imager.Context, camera: CameraData, quick:
BOOL];
Slice draws its parts into the Imager context. IF parts = NIL, draw the whole slice.
SliceDrawTransformProc:
TYPE =
PROC [slice: Slice, parts: SliceParts, dc: Imager.Context, camera: CameraData, transform: ImagerTransformation.Transformation];
Slice applies transformation (temporarily) to its indicated parts, then draws itself into the Imager context. Used for rubberbanding or dragging
SliceDrawSelectionFeedbackProc:
TYPE =
PROC [slice: Slice, selectedParts: SliceParts, hotParts: SliceParts, dc: Imager.Context, camera: CameraData, dragInProgress, caretIsMoving, hideHot, quick:
BOOL];
Slice draws its selection feedback, as indicated by its parts, into the Imager context. quick is a flag which, if set, causes the slice to draw an abbreviated version of its selection feedback. During motion is true if anything in the scene is currently moving. Hide hot is TRUE if hotness feedback should not be shown.
SliceDrawAttractorFeedbackProc:
TYPE =
PROC [sliceD: SliceDescriptor, selectedParts: SliceParts, dragInProgress:
BOOL, dc: Imager.Context, camera: CameraData];
sliceD is a simple SliceDescriptor describing where on the slice, the caret has been placed. The slice should draw appropriate feedback.
SliceTransformProc:
TYPE =
PROC [slice: Slice, parts: SliceParts, transform: ImagerTransformation.Transformation];
Apply the given transformation to internal data of the slice as specified by parts. It is now in a new position, orientation, scaling, or skewing.
SliceDescribeProc:
TYPE =
PROC [slice: Slice, parts: SliceParts]
RETURNS [rope: Rope.
ROPE];
Return a short description of slice and parts suitable for feedback line.
SliceFileoutProc:
TYPE =
PROC [slice: Slice, f:
IO.
STREAM];
Write a description of yourself onto stream f.
SliceFileinProc:
TYPE =
PROC [f:
IO.
STREAM, version:
REAL, feedback: Viewer]
RETURNS [slice: Slice];
Read a description of yourself from stream f.
Describing Parts of the Slice
ExtendMode: TYPE = {joint, controlPoint, segment, segmentRange, traj, outline, slice, topLevel, none};
SelectMode: TYPE = ExtendMode;
SlicePointsInDescriptorProc: TYPE = PROC [sliceD: SliceDescriptor] RETURNS [pointGen: PointGenerator];
SlicePointPairsInDescriptorProc: TYPE = PROC [sliceD: SliceDescriptor] RETURNS [pointPairGen: PointPairGenerator];
SliceNextPointProc: TYPE = PROC [pointGen: PointGenerator] RETURNS [pointAndDone: PointAndDone];
SliceNextPointPairProc: TYPE = PROC [pointPairGen: PointPairGenerator] RETURNS [pointPairAndDone: PointPairAndDone];
PointAndDone: TYPE = RECORD [point: Point, done: BOOL];
PointPairAndDone: TYPE = RECORD [lo, hi: Point, done: BOOL];
SliceEmptyPartsProc: TYPE = PROC [slice: Slice, parts: SliceParts] RETURNS [BOOL];
SliceNewPartsProc:
TYPE =
PROC [slice: Slice, hitData:
REF
ANY, mode: SelectMode]
RETURNS [parts: SliceParts];
Returns a class-specific description of its parts to be used in calls to SelectSlice. Parts are determined from the mode and from the hitData within the slice, which was set by the slice during calls to SliceClosest* procs.
SliceUnionPartsProc:
TYPE =
PROC [slice: Slice, partsA: SliceParts, partsB: SliceParts]
RETURNS [aPlusB: SliceParts];
Takes two parts descriptions and returns their union. This routine is used by the ExtendSelection routines.
SliceDifferencePartsProc:
TYPE =
PROC [slice: Slice, partsA: SliceParts, partsB: SliceParts]
RETURNS [aMinusB: SliceParts];
Takes two parts descriptions and returns their difference. This routine is used by the Deselection routines.
SliceMovingPartsProc:
TYPE =
PROC [slice: Slice, parts: SliceParts]
RETURNS [moving: SliceParts];
Takes a parts description (usually the selected parts just before a Drag operation) and returns a parts descriptor which describes everything in the slice that will move when the input parts are moved.
SliceFixedPartsProc:
TYPE =
PROC [slice: Slice, parts: SliceParts, selectedList:
LIST
OF
REF
ANY]
RETURNS [fixed: SliceParts];
Takes a parts description (usually the selected parts just before a Drag operation) and returns a parts descriptor which describes everything in the slice that will NOT move when the input parts are moved. selectedList is gargoyleData.selected.normal.
SliceAugmentPartsProc:
TYPE =
PROC [slice: Slice, parts: SliceParts, selectClass: SelectionClass]
RETURNS [more: SliceParts];
Takes a parts description (usually the selected parts just before a SelectSlice operation) and returns a parts descriptor which describes parts which should be selected as well. Used so that slices with segment/joint analogies can behave like polygons.
SliceSetSelectedFieldsProc: TYPE = PROC [sliceD: SliceDescriptor, selected: BOOL, selectClass: SelectionClass];
Hit Testing
SliceClosestPointProc:
TYPE =
PROC [sliceD: SliceDescriptor, testPoint: Point, tolerance:
REAL]
RETURNS [bestPoint: Point, bestDist:
REAL, hitData:
REF
ANY, success:
BOOL];
Used for hit testing. Find the nearest point on the parts of sliceD to testPoint. If the nearest point is farther away than tolerance units, this procedure may opt to return success = FALSE. If a valid point is returned, then success = TRUE. The proc should fill in slice.hitData, which is class-specific data describing the actual part of the slice that was closest. For some classes, this data will be a joint number, if the class objects have joints.
SliceClosestPointAndTangentProc:
TYPE =
PROC [sliceD: SliceDescriptor, testPoint: Point, tolerance:
REAL]
RETURNS [bestPoint: Point, bestDist:
REAL, tangent: Vector, hitData:
REF
ANY, success:
BOOL];
Used for hit testing. Find the nearest point on the parts of sliceD to testPoint and the tangent vector (towards hi end of segment) at that point. If the nearest point is farther away than tolerance units, this procedure may opt to return success = FALSE. If a valid point is returned, then success = TRUE. The proc should fill in slice.hitData, which is class-specific data describing the actual part of the slice that was closest. For some classes, this data will be a joint number, if the class objects have joints.
SliceClosestSegmentProc:
TYPE =
PROC [sliceD: SliceDescriptor, testPoint: Point, tolerance:
REAL]
RETURNS [bestPoint: Point, bestDist:
REAL, hitData:
REF
ANY, success:
BOOL];
Used for hit testing. Find the nearest segment of the parts of sliceD to testPoint. If the nearest point is farther away than tolerance units, this procedure may opt to return success = FALSE. If the nearest point is farther away than tolerance units, this procedure may opt to return success = FALSE. If a valid point is returned, then success = TRUE. The proc should fill in slice.hitData, which is class-specific data describing the actual part of the slice that was closest. For some classes, this data will be a segment number, if the class objects has segments.
SliceLineIntersectionProc:
TYPE =
PROC [sliceD: SliceDescriptor, line: Line]
RETURNS [points:
LIST
OF Point, pointCount:
NAT];
Finds the intersection of the line with those slice parts mentioned in sliceD.
SliceCircleIntersectionProc:
TYPE =
PROC [sliceD: SliceDescriptor, circle: Circle]
RETURNS [points:
LIST
OF Point, pointCount:
NAT];
Finds the intersection of the circle with those slice parts mentioned in sliceD.
SliceHitDataAsSimpleCurveProc:
TYPE =
PROC [slice: Slice, hitData:
REF
ANY]
RETURNS [simpleCurve:
REF
ANY];
simpleCurve will be of type Edge, Arc, etc. There will be Conic and Bezier types as well.
Style
SliceSetStrokeWidthProc:
TYPE =
PROC [slice: Slice, parts: SliceParts, strokeWidth:
REAL];
Sets the stroke width of the named parts of slice to be strokeWidth.
SliceGetStrokeWidthProc:
TYPE =
PROC [slice: Slice, parts: SliceParts]
RETURNS [strokeWidth:
REAL];
Get the stroke width of the named parts of slice.
SliceSetStrokeColorProc:
TYPE =
PROC [slice: Slice, parts: SliceParts, color: Imager.Color];
Sets the stroke color of the named parts of slice to be color.
SliceGetStrokeColorProc:
TYPE =
PROC [slice: Slice, parts: SliceParts]
RETURNS [color: Imager.Color];
Get the stroke color of the named parts of slice.
SliceSetFillColorProc:
TYPE =
PROC [slice: Slice, color: Imager.Color];
Sets the fill color of the slice to be color.
SliceGetFillColorProc:
TYPE =
PROC [slice: Slice]
RETURNS [color: Imager.Color];
Get the fill color of the slice.
SliceSetArrowsProc:
TYPE =
PROC [slice: Slice, parts: SliceParts, leftDown, rightUp:
BOOL];
Sets the arrow ends of the named parts of the slice.
SliceGetArrowsProc:
TYPE =
PROC [slice: Slice]
RETURNS [leftDown, rightUp:
BOOL];
Get the arrow ends of the named parts of the slice.
SliceSetDashedProc: TYPE = PROC [slice: Slice, parts: SliceParts, dashed: BOOL, pattern: SequenceOfReal ← NIL, offset: REAL ← 0.0, length: REAL ← -1.0];
SliceGetDashedProc: TYPE = PROC [slice: Slice, parts: SliceParts] RETURNS [dashed: BOOL, pattern: SequenceOfReal, offset, length: REAL];
Outlines
OutlineDescriptor: TYPE = REF OutlineDescriptorObj;
OutlineDescriptorObj:
TYPE =
RECORD [
slice: Outline,
parts: SliceParts
];
Outline: TYPE = REF OutlineObj;
OutlineObj:
TYPE =
RECORD [
class: OutlineClass,
data: REF ANY,
fillColor: Imager.Color, -- store in data
lineEnds: Imager.StrokeEnd, -- store in data
children: LIST OF Traj, -- store in data
parent: Slice, -- for when slices can be part of clusters
selectedInFull: SelectedObjectData,
normalSelectedParts: SliceParts, -- maintained by GGSelect to improve performance
hotSelectedParts: SliceParts, -- maintained by GGSelect to improve performance
activeSelectedParts: SliceParts, -- maintained by GGSelect to improve performance
boundBox: BoundBox,
onOverlay: BOOL ← FALSE,
extraPoints: LIST OF Joint,
priority: INT ← 0, -- scene order priority. 0 => in back
mark: BOOL ← FALSE -- for sweeping thru scenes by Undelete mechanism
];
A Temporary Class Type (until Outlines become real Slices)
OutlineClass: TYPE = REF OutlineClassObj;
OutlineClassObj:
TYPE =
RECORD [
getBoundBox: OutlineBoundBoxProc,
getTightBox: OutlineTightBoxProc,
copy: OutlineCopyProc,
Drawing
drawParts: OutlineDrawPartsProc,
drawTransform: OutlineDrawTransformProc,
drawSelectionFeedback: OutlineDrawSelectionFeedbackProc,
drawAttractorFeedback: OutlineDrawAttractorFeedbackProc,
Transforming
transform: OutlineTransformProc,
Textual Description
describe: OutlineDescribeProc,
fileout: OutlineFileoutProc,
filein: OutlineFileinProc,
Parts
emptyParts: OutlineEmptyPartsProc,
newParts: OutlineNewPartsProc,
unionParts: OutlineUnionPartsProc,
differenceParts: OutlineDifferencePartsProc,
movingParts: OutlineMovingPartsProc,
fixedParts: OutlineFixedPartsProc,
augmentParts: OutlineAugmentPartsProc,
setSelectedFields: OutlineSetSelectedFieldsProc,
Hit Testing
pointsInDescriptor: OutlinePointsInDescriptorProc,
pointPairsInDescriptor: OutlinePointPairsInDescriptorProc,
nextPoint: OutlineNextPointProc,
nextPointPair: OutlineNextPointPairProc,
closestPoint: OutlineClosestPointProc,
closestPointAndTangent: OutlineClosestPointAndTangentProc,
closestSegment: OutlineClosestSegmentProc,
lineIntersection: OutlineLineIntersectionProc,
circleIntersection: OutlineCircleIntersectionProc,
hitDataAsSimpleCurve: OutlineHitDataAsSimpleCurveProc,
Style
setStrokeWidth: OutlineSetStrokeWidthProc,
getStrokeWidth: OutlineGetStrokeWidthProc,
setStrokeColor: OutlineSetStrokeColorProc,
getStrokeColor: OutlineGetStrokeColorProc,
setFillColor: OutlineSetFillColorProc,
getFillColor: OutlineGetFillColorProc,
setArrows: OutlineSetArrowsProc,
getArrows: OutlineGetArrowsProc,
setDashed: OutlineSetDashedProc,
getDashed: OutlineGetDashedProc
];
Fundamental Outline Routines
OutlineBoundBoxProc:
TYPE =
PROC [slice: Outline, parts: SliceParts]
RETURNS [box: BoundBox];
Returns the geometric bounds the named parts of the outline. If parts = NIL, return the boundbox of the whole outline. Allows space for control points and stroke width.
OutlineTightBoxProc:
TYPE =
PROC [slice: Outline, parts: SliceParts]
RETURNS [box: BoundBox];
Returns the tight geometric bounds the named parts of the outline. If parts = NIL, return the boundbox of the whole outline.
OutlineCopyProc: TYPE = PROC [slice: Outline] RETURNS [copy: Outline];
OutlineDrawPartsProc: TYPE = PROC [slice: Outline, parts: SliceParts, dc: Imager.Context, camera: CameraData, quick: BOOL];
OutlineDrawTransformProc: TYPE = PROC [slice: Outline, parts: SliceParts, dc: Imager.Context, camera: CameraData, transform: ImagerTransformation.Transformation];
OutlineDrawSelectionFeedbackProc: TYPE = PROC [slice: Outline, selectedParts: SliceParts, hotParts: SliceParts, dc: Imager.Context, camera: CameraData, dragInProgress, caretIsMoving, hideHot, quick: BOOL];
OutlineDrawAttractorFeedbackProc:
TYPE =
PROC [sliceD: OutlineDescriptor, selectedParts: SliceParts, dragInProgress:
BOOL, dc: Imager.Context, camera: CameraData];
sliceD is a simple SliceDescriptor describing where on the slice, the caret has been placed. The slice should draw appropriate feedback.
OutlineTransformProc:
TYPE =
PROC [slice: Outline, parts: SliceParts, transform: ImagerTransformation.Transformation];
Apply the given transformation to internal data of the slice as specified by parts. It is now in a new position, orientation, scaling, or skewing.
OutlineDescribeProc:
TYPE =
PROC [slice: Outline, parts: SliceParts]
RETURNS [rope: Rope.
ROPE];
Return a short description of slice and parts suitable for feedback line.
OutlineFileoutProc:
TYPE =
PROC [slice: Outline, f:
IO.
STREAM];
Write a description of yourself onto stream f.
OutlineFileinProc:
TYPE =
PROC [f:
IO.
STREAM, version:
REAL, feedback: Viewer]
RETURNS [slice: Outline];
Read a description of yourself from stream f.
Describing Parts of the Outline
OutlinePointsInDescriptorProc: TYPE = PROC [sliceD: OutlineDescriptor] RETURNS [pointGen: OutlinePointGenerator];
OutlinePointPairsInDescriptorProc: TYPE = PROC [sliceD: OutlineDescriptor] RETURNS [pointPairGen: OutlinePointPairGenerator];
OutlineNextPointProc: TYPE = PROC [pointGen: OutlinePointGenerator] RETURNS [pointAndDone: PointAndDone];
OutlineNextPointPairProc: TYPE = PROC [pointPairGen: OutlinePointPairGenerator] RETURNS [pointPairAndDone: PointPairAndDone];
OutlineEmptyPartsProc: TYPE = PROC [slice: Outline, parts: SliceParts] RETURNS [BOOL];
OutlineNewPartsProc: TYPE = PROC [slice: Outline, hitData: REF ANY, mode: SelectMode] RETURNS [parts: SliceParts];
OutlineUnionPartsProc:
TYPE =
PROC [slice: Outline, partsA: SliceParts, partsB: SliceParts]
RETURNS [aPlusB: SliceParts];
Takes two parts descriptions and returns their union. This routine is used by the ExtendSelection routines.
OutlineDifferencePartsProc:
TYPE =
PROC [slice: Outline, partsA: SliceParts, partsB: SliceParts]
RETURNS [aMinusB: SliceParts];
Takes two parts descriptions and returns their difference. This routine is used by the Deselection routines.
OutlineMovingPartsProc:
TYPE =
PROC [slice: Outline, parts: SliceParts]
RETURNS [moving: SliceParts];
Takes a parts description (usually the selected parts just before a Drag operation) and returns a parts descriptor which describes everything in the slice that will move when the input parts are moved.
OutlineFixedPartsProc:
TYPE =
PROC [slice: Outline, parts: SliceParts, selectedList:
LIST
OF
REF
ANY]
RETURNS [fixed: SliceParts];
Takes a parts description (usually the selected parts just before a Drag operation) and returns a parts descriptor which describes everything in the slice that will NOT move when the input parts are moved.
OutlineAugmentPartsProc: TYPE = PROC [slice: Outline, parts: SliceParts, selectClass: SelectionClass] RETURNS [more: SliceParts];
OutlineSetSelectedFieldsProc: TYPE = PROC [sliceD: OutlineDescriptor, selected: BOOL, selectClass: SelectionClass];
Hit Testing
OutlineClosestPointProc:
TYPE =
PROC [sliceD: OutlineDescriptor, testPoint: Point, tolerance:
REAL]
RETURNS [bestPoint: Point, bestDist:
REAL, hitData:
REF
ANY, success:
BOOL];
Used for hit testing. Find the nearest point on the parts of sliceD to testPoint. If the nearest point is farther away than tolerance units, this procedure may opt to return success = FALSE. If a valid point is returned, then success = TRUE. The proc should fill in slice.hitData, which is class-specific data describing the actual part of the slice that was closest. For some classes, this data will be a joint number, if the class objects have joints.
OutlineClosestPointAndTangentProc:
TYPE =
PROC [sliceD: OutlineDescriptor, testPoint: Point, tolerance:
REAL]
RETURNS [bestPoint: Point, bestDist:
REAL, tangent: Vector, hitData:
REF
ANY, success:
BOOL];
Used for hit testing. Find the nearest point on the parts of sliceD to testPoint and the tangent vector (towards hi end of segment) at that point. If the nearest point is farther away than tolerance units, this procedure may opt to return success = FALSE. If a valid point is returned, then success = TRUE. The proc should fill in slice.hitData, which is class-specific data describing the actual part of the slice that was closest. For some classes, this data will be a joint number, if the class objects have joints.
OutlineClosestSegmentProc:
TYPE =
PROC [sliceD: OutlineDescriptor, testPoint: Point, tolerance:
REAL]
RETURNS [bestPoint: Point, bestDist:
REAL, hitData:
REF
ANY, success:
BOOL];
Used for hit testing. Find the nearest segment of the parts of sliceD to testPoint. If the nearest point is farther away than tolerance units, this procedure may opt to return success = FALSE. If the nearest point is farther away than tolerance units, this procedure may opt to return success = FALSE. If a valid point is returned, then success = TRUE. The proc should fill in slice.hitData, which is class-specific data describing the actual part of the slice that was closest. For some classes, this data will be a segment number, if the class objects has segments.
OutlineLineIntersectionProc:
TYPE =
PROC [sliceD: OutlineDescriptor, line: Line]
RETURNS [points:
LIST
OF Point, pointCount:
NAT];
Finds the intersection of the line with those slice parts mentioned in sliceD.
OutlineCircleIntersectionProc:
TYPE =
PROC [sliceD: OutlineDescriptor, circle: Circle]
RETURNS [points:
LIST
OF Point, pointCount:
NAT];
Finds the intersection of the circle with those slice parts mentioned in sliceD.
OutlineHitDataAsSimpleCurveProc:
TYPE =
PROC [slice: Outline, hitData:
REF
ANY]
RETURNS [simpleCurve:
REF
ANY];
simpleCurve will be of type Edge, Arc, etc. There will be Conic and Bezier types as well.
Style
OutlineSetStrokeWidthProc:
TYPE =
PROC [slice: Outline, parts: SliceParts, strokeWidth:
REAL];
Sets the stroke width of the named parts of slice to be strokeWidth.
OutlineGetStrokeWidthProc:
TYPE =
PROC [slice: Outline, parts: SliceParts]
RETURNS [strokeWidth:
REAL];
Get the stroke width of the named parts of slice.
OutlineSetStrokeColorProc:
TYPE =
PROC [slice: Outline, parts: SliceParts, color: Imager.Color];
Sets the stroke color of the named parts of slice to be color.
OutlineGetStrokeColorProc:
TYPE =
PROC [slice: Outline, parts: SliceParts]
RETURNS [color: Imager.Color];
Get the stroke color of the named parts of slice.
OutlineSetFillColorProc:
TYPE =
PROC [slice: Outline, color: Imager.Color];
Sets the fill color of the slice to be color.
OutlineGetFillColorProc:
TYPE =
PROC [slice: Outline]
RETURNS [color: Imager.Color];
Get the fill color of the slice.
OutlineSetArrowsProc:
TYPE =
PROC [slice: Outline, parts: SliceParts, leftDown, rightUp:
BOOL];
Sets the arrow ends of the named parts of the slice.
OutlineGetArrowsProc:
TYPE =
PROC [slice: Outline]
RETURNS [leftDown, rightUp:
BOOL];
Get the arrow ends of the named parts of the slice.
OutlineSetDashedProc: TYPE = PROC [slice: Outline, parts: SliceParts, dashed: BOOL, pattern: SequenceOfReal ← NIL, offset: REAL ← 0.0, length: REAL ← -1.0];
OutlineGetDashedProc: TYPE = PROC [slice: Outline, parts: SliceParts] RETURNS [dashed: BOOL, pattern: SequenceOfReal, offset, length: REAL];
Outline Parts
Traj: TYPE = REF TrajObj;
TrajObj:
TYPE =
RECORD [
role: FenceHoleOpen,
segCount: NAT, -- the number of segments currently in this trajectory
segments: Rosary.
ROSARY,
-- the segments themselves
Segments refer to joints (and other control points), and have drawing styles.
joints: Rosary.
ROSARY,
-- the segCount+1 joints at which the segments meet
Joints have a position and a continuity constraint
extraPoints: LIST OF Joint,
parent: Outline, -- the parent outline of this trajectory,
boundBox: BoundBox,
visibleJoints: BOOL ← TRUE,
strokeJoint: Imager.StrokeJoint ← round,
loArrow, hiArrow: BOOL ← FALSE,
selectedInPart: SelectedObjectData
];
FenceHoleOpen: TYPE = {fence, hole, open};
TrajEnd: TYPE = {lo, hi};
Sequence: TYPE = REF SequenceObj;
SequenceObj:
TYPE =
RECORD [
traj: Traj,
boundBox: BoundBox, -- bounding box of this sequence. May =seq.traj.boundBox or be tighter.
segments: BitVector,
joints: BitVector,
controlPoints: BitMatrix, -- one BitVector per segment, one bit per CP per BitVector
segCount: NAT, -- the number of segments represented by this sequence
jointCount: NAT, -- the number of joints represented by this sequence
controlPointCount: NAT
];
Generators
EntityGenerator: TYPE = REF EntityGeneratorObj;
EntityGeneratorObj:
TYPE =
RECORD [
list: LIST OF REF ANY,
countValid: BOOL ← FALSE,
count: NAT
];
TrajGenerator: TYPE = REF TrajGeneratorObj;
TrajGeneratorObj:
TYPE =
RECORD [
list: LIST OF Traj
];
OutlineGenerator: TYPE = REF OutlineGeneratorObj;
OutlineGeneratorObj:
TYPE =
RECORD [
list: LIST OF Outline
];
OutlineDescriptorGenerator: TYPE = REF OutlineDescriptorGeneratorObj;
OutlineDescriptorGeneratorObj:
TYPE =
RECORD [
list: LIST OF OutlineDescriptor
];
SliceGenerator: TYPE = REF SliceGeneratorObj;
SliceGeneratorObj:
TYPE =
RECORD [
list: LIST OF Slice
];
SliceDescriptorGenerator: TYPE = REF SliceDescriptorGeneratorObj;
SliceDescriptorGeneratorObj:
TYPE =
RECORD [
list: LIST OF SliceDescriptor
];
SequenceGenerator: TYPE = REF SequenceGeneratorObj;
SequenceGeneratorObj:
TYPE =
RECORD [
list: LIST OF Sequence
];
SegmentGenerator: TYPE = REF SegmentGeneratorObj;
SegmentGeneratorObj:
TYPE =
RECORD [
traj: Traj,
toGo: NAT,
index: NAT ← 0,
touched: NAT ← 0, -- how many segments have we considered returning (should be <= segCount).
seq: Sequence,
completeSeq: BOOL
];
JointGenerator:
TYPE =
REF JointGeneratorObj;
JointGeneratorObj:
TYPE =
RECORD [
traj: Traj,
toGo: NAT,
index: NAT,
seq: Sequence,
completeSeq: BOOL ← FALSE
];
ControlPointGenerator:
TYPE =
REF ControlPointGeneratorObj;
ControlPointGeneratorObj:
TYPE =
RECORD [
seq: Sequence,
toGo: NAT,
segIndex: NAT, -- together [segIndex, cpIndex] name the next control point to consider
cpIndex: NAT
];
PointGenerator:
TYPE =
REF PointGeneratorObj;
PointGeneratorObj:
TYPE =
RECORD [
sliceD: SliceDescriptor,
toGo: NAT,
index: NAT,
classSpecific: REF ANY
];
PointPairGenerator:
TYPE =
REF PointPairGeneratorObj;
PointPairGeneratorObj:
TYPE =
RECORD [
sliceD: SliceDescriptor,
toGo: NAT,
index: NAT,
classSpecific: REF ANY
];
OutlinePointGenerator:
TYPE =
REF OutlinePointGeneratorObj;
OutlinePointGeneratorObj:
TYPE =
RECORD [
outlineD: OutlineDescriptor,
toGo: NAT,
index: NAT,
classSpecific: REF ANY
];
OutlinePointPairGenerator:
TYPE =
REF OutlinePointPairGeneratorObj;
OutlinePointPairGeneratorObj:
TYPE =
RECORD [
outlineD: OutlineDescriptor,
toGo: NAT,
index: NAT,
classSpecific: REF ANY
];
BoundBoxGenerator: TYPE = REF BoundBoxGeneratorObj;
BoundBoxGeneratorObj:
TYPE =
RECORD [
list: LIST OF BoundBox
];
Gravity and Alignments
AlignmentObject: TYPE = REF ANY; -- types: AlignmentLine, AlignmentCircle, AlignmentPoint, SliceDescriptor, Sequence
FeatureData: TYPE = REF FeatureDataObj;
FeatureDataObj:
TYPE =
RECORD [
type: FeatureType,
shape: AlignmentObject,
resultType: ResultFeatureType,
hitPart: REF ANY, -- types: SequencePart, BoxHitData, CircleHitData, ...
visible: BOOL ← FALSE
];
FeatureType: TYPE = {outline, slice, distanceLine, slopeLine, angleLine, symmetryLine, radiiCircle, intersectionPoint, midpoint, anchor};
ResultFeatureType: TYPE = {outline, slice, distanceLine, slopeLine, angleLine, symmetryLine, radiiCircle, intersectionPoint, midpoint, anchor};
TrajPartType:
TYPE = {none, joint, controlPoint, segment};
END.