- BalloonBezierSimulation: This class is a simulation of the code that's run by the Balloon engine
- BalloonBuffer: BalloonBuffer is a repository for primitive data used by the BalloonEngine
- BalloonEdgeData: BalloonEdgeData defines an entry in the internal edge table of the Balloon engine
- BalloonEngine: BalloonEngine is the representative for the Balloon engine inside Squeak
- BalloonFillData: This class is a simulation of the code that's run by the Balloon engine
- BalloonLineSimulation: This class is a simulation of the code that's run by the Balloon engine
- BalloonSolidFillSimulation: This class is a simulation of the code that's run by the Balloon engine
- BalloonState: This class is a repository for data which needs to be preserved during certain operations of BalloonCanvas
- Bezier2Segment: This class represents a quadratic bezier segment between two points Instance variables: via <Point> The additional control point
- Bezier3Segment: This class represents a cubic bezier segment between two points Instance variables: via1, via2 <Point> The additional control points
- BitmapFillStyle: A BitmapFillStyle fills using any kind of form
- CompressedBoundaryShape: This class represents a very compact representation of a boundary shape
- FillStyle: FillStyle is an abstract base class for fills in the BalloonEngine
- GradientFillStyle: A gradient fill style is a fill which interpolates smoothly between any number of colors
- LineSegment: This class represents a straight line segment between two points Instance variables: start <Point> start point of the line end <Point> end point of the line
- OrientedFillStyle: OrientedFill is an abstract superclass for fills which can be aligned appropriately
- PointArray: This class stores 32bit Integer points in place
- ShortIntegerArray: ShortIntegerArray is an array for efficiently representing integers in the 16bit range
- ShortPointArray: This class stores points that are in short integer range
- ShortRunArray: This class is run-length encoded representation of short integer
- SolidFillStyle: SolidFillStyle is a fill which represents a color for the BalloonEngine

BalloonBezierSimulation

This class is a simulation of the code that's run by the Balloon engine. For debugging purposes only.

absoluteSquared8Dot24:

Compute the squared value of a 8.24 number with 0.0 <= value < 1.0,

e.g., compute (value * value) bitShift: -24

e.g., compute (value * value) bitShift: -24

computeInitialStateFrom:with:

Compute the initial state in the receiver.

computeSplitAt:

Split the receiver at the parametric value t

debugDraw

debugDraw2

debugDrawWide:

end

end:

floatStepToFirstScanLineAt:in:

Float version of forward differencing

floatStepToNextScanLineAt:in:

Float version of forward differencing

inTangent

Return the tangent at the start point

initialX

initialY

initialZ

initialize

Subclasses should redefine this method to perform initializations on instance creation

intStepToFirstScanLineAt:in:

Scaled integer version of forward differencing

intStepToNextScanLineAt:in:

Scaled integer version of forward differencing

isMonoton

Return true if the receiver is monoton along the y-axis,

e.g., check if the tangents have the same sign

e.g., check if the tangents have the same sign

outTangent

Return the tangent at the end point

printOn:

Append to the argument, aStream, a sequence of characters that

identifies the receiver.

identifies the receiver.

printOnStream:

quickPrint:

quickPrint:first:

start

start:

stepToFirst

stepToFirstInt

Scaled integer version of forward differencing

stepToFirstScanLineAt:in:

Compute the initial x value for the scan line at yValue

stepToNext

stepToNextInt

Scaled integer version of forward differencing

stepToNextScanLineAt:in:

Compute the next x value for the scan line at yValue.

This message is sent during incremental updates.

The yValue parameter is passed in here for edges

that have more complicated computations,

This message is sent during incremental updates.

The yValue parameter is passed in here for edges

that have more complicated computations,

subdivide

Subdivide the receiver

subdivideAt:

Subdivide the receiver at the given parameter

subdivideToBeLine

Not a true subdivision.

Just return a line representing the receiver and fake me to be of zero height

Just return a line representing the receiver and fake me to be of zero height

subdivideToBeMonoton

Subdivide the receiver at it's extreme point

validateIntegerRange

valueAt:

Return the point at the value parameter:

p(t) = (1-t)^2 * p1 +

2*t*(1-t) * p2 +

t^2 * p3.

p(t) = (1-t)^2 * p1 +

2*t*(1-t) * p2 +

t^2 * p3.

via

via:

BalloonBuffer

BalloonBuffer is a repository for primitive data used by the BalloonEngine.

at:

For simulation only

at:put:

For simulation only

floatAt:

For simulation only

floatAt:put:

For simulation only

new

BalloonEdgeData

BalloonEdgeData defines an entry in the internal edge table of the Balloon engine.

Instance Variables:

index <Integer> The index into the external objects array of the associated graphics engine

xValue <Integer> The computed x-value of the requested operation

yValue <Integer> The y-value for the requested operation

height <Integer> The (remaining) height of the edge

source <Object> The object from the external objects array

Instance Variables:

index <Integer> The index into the external objects array of the associated graphics engine

xValue <Integer> The computed x-value of the requested operation

yValue <Integer> The y-value for the requested operation

height <Integer> The (remaining) height of the edge

source <Object> The object from the external objects array

index

index:

lines

lines:

source

source:

stepToFirstScanLine

stepToNextScanLine

xValue

xValue:

yValue

yValue:

zValue

zValue:

BalloonEngine

BalloonEngine is the representative for the Balloon engine inside Squeak. For most purposes it should not be used directly but via BalloonCanvas since this ensures proper initialization and is polymorphic with other canvas uses.

aaLevel

aaLevel:

aaTransform

Return a transformation for the current anti-aliasing level

allocateOrRecycleBuffer:

bitBlt

bitBlt:

canProceedAfter:

Check if we can proceed after the failureReason indicated.

clipRect

clipRect:

colorTransform

colorTransform:

copyBits

copyLoop

This is the basic rendering loop using as little primitive support as possible.

copyLoopFaster

This is a copy loop drawing one scan line at a time

copyLoopFastest

This is a copy loop drawing the entire image

debug:

deferred

deferred:

destOffset

destOffset:

doProfileStats:

drawBezierShape:fill:borderWidth:borderColor:transform:

drawCompressedShape:transform:

drawGeneralBezierShape:fill:borderWidth:borderColor:transform:

drawGeneralPolygon:fill:borderWidth:borderColor:transform:

drawOval:fill:borderWidth:borderColor:transform:

drawPolygon:fill:borderWidth:borderColor:transform:

drawRectangle:fill:borderWidth:borderColor:transform:

edgeTransform

edgeTransform:

flush

Force all pending primitives onscreen

fullTransformFrom:

initialize

Subclasses should redefine this method to perform initializations on instance creation

postFlushIfNeeded

Force all pending primitives onscreen

preFlushIfNeeded

Force all pending primitives onscreen

primAddActiveEdgeTableEntryFrom:

Add edge entry to the AET.

primAddBezierFrom:to:via:leftFillIndex:rightFillIndex:

primAddBezierShape:segments:fill:lineWidth:lineFill:

primAddBitmapFill:colormap:tile:from:along:normal:xIndex:

primAddCompressedShape:segments:leftFills:rightFills:lineWidths:lineFills:fillIndexList:

primAddExternalEdge:initialX:initialY:initialZ:leftFillIndex:rightFillIndex:

primAddExternalFill:

primAddGradientFill:from:along:normal:radial:

primAddLineFrom:to:leftFillIndex:rightFillIndex:

primAddOvalFrom:to:fillIndex:borderWidth:borderColor:

primAddPolygon:segments:fill:lineWidth:lineFill:

primAddRectFrom:to:fillIndex:borderWidth:borderColor:

primChangeActiveEdgeTableEntryFrom:

Change the entry in the active edge table from edgeEntry

primClipRectInto:

primCopyBufferFrom:to:

Copy the contents of oldBuffer into the (larger) newBuffer

primDisplaySpanBuffer

Display the current scan line if necessary

primFinishedProcessing

Return true if there are no more entries in AET and GET and the last scan line has been displayed

primFlushNeeded

primFlushNeeded:

primGetAALevel

Set the AA level

primGetBezierStats:

primGetClipRect:

primGetCounts:

primGetDepth

primGetFailureReason

primGetOffset

primGetTimes:

primInitializeBuffer:

primInitializeProcessing

Initialize processing in the GE.

Create the active edge table and sort it.

Create the active edge table and sort it.

primMergeFill:from:

Merge the filled bitmap into the current output buffer.

primNextActiveEdgeEntryInto:

Store the next entry of the AET at the current y-value in edgeEntry.

Return false if there is no entry, true otherwise.

Return false if there is no entry, true otherwise.

primNextFillEntryInto:

Store the next fill entry of the active edge table in fillEntry.

Return false if there is no such entry, true otherwise

Return false if there is no such entry, true otherwise

primNextGlobalEdgeEntryInto:

Store the next entry of the GET at the current y-value in edgeEntry.

Return false if there is no entry, true otherwise.

Return false if there is no entry, true otherwise.

primRenderImage:with:

Start/Proceed rendering the current scan line

primRenderScanline:with:

Start/Proceed rendering the current scan line

primSetAALevel:

Set the AA level

primSetClipRect:

primSetColorTransform:

primSetDepth:

primSetEdgeTransform:

primSetOffset:

primitiveSetBitBltPlugin:

printBezierStats

printStat:count:string:

printStats

processStopReason:edge:fill:

The engine has stopped because of some reason.

Try to figure out how to respond and do the necessary actions.

Try to figure out how to respond and do the necessary actions.

recycleBuffer:

registerFill:

Register the given fill style.

registerFill:and:

registerFills:

release

Remove references to objects that may refer to the receiver. This message

should be overridden by subclasses with any cycles, in which case the

subclass should also include the expression super release.

should be overridden by subclasses with any cycles, in which case the

subclass should also include the expression super release.

reset

resetBezierStats

resetIfNeeded

resetStats

BalloonEngineConstants

A BalloonEngineConstants is xxxxxxxxx.

Instance Variables

Instance Variables

initEdgeConstants

initFillConstants

initPrimitiveConstants

initStateConstants

initWorkBufferConstants

initialize

Subclasses should redefine this method to perform initializations on instance creation

initializeInstVarNames:prefixedBy:

BalloonFillData

This class is a simulation of the code that's run by the Balloon engine. For debugging purposes only.

computeFill

destForm

destForm:

index

index:

maxX

maxX:

minX

minX:

source

source:

width

yValue

yValue:

BalloonLineSimulation

This class is a simulation of the code that's run by the Balloon engine. For debugging purposes only.

computeInitialStateFrom:with:

Compute the initial state in the receiver.

end

end:

initialX

initialY

initialZ

printOn:

Append to the argument, aStream, a sequence of characters that

identifies the receiver.

identifies the receiver.

printOnStream:

start

start:

stepToFirstScanLineAt:in:

Compute the initial x value for the scan line at yValue

stepToNextScanLineAt:in:

Compute the next x value for the scan line at yValue.

This message is sent during incremental updates.

The yValue parameter is passed in here for edges

that have more complicated computations,

This message is sent during incremental updates.

The yValue parameter is passed in here for edges

that have more complicated computations,

subdivide

BalloonSolidFillSimulation

computeFillFrom:to:at:in:

computeInitialStateFrom:with:

BalloonState

This class is a repository for data which needs to be preserved during certain operations of BalloonCanvas.

aaLevel

aaLevel:

colorTransform

colorTransform:

transform

transform:

Bezier2Segment

This class represents a quadratic bezier segment between two points

Instance variables:

via <Point> The additional control point (OFF the curve)

Instance variables:

via <Point> The additional control point (OFF the curve)

asBezier2Points:

asBezier2Segment

Represent the receiver as quadratic bezier segment

asBezier3Segment

Represent the receiver as cubic bezier segment

asIntegerSegment

Convert the receiver into integer representation

asTangentSegment

bezierClipHeight:

bounds

Return the bounds containing the receiver

controlPoints

controlPointsDo:

curveFrom:to:

Return a new curve from param1 to param2

degree

from:to:

Initialize the receiver as straight line

from:to:via:

Initialize the receiver

from:to:withMidPoint:

Initialize the receiver with the pointOnCurve assumed at the parametric value 0.5

from:to:withMidPoint:at:

Initialize the receiver with the pointOnCurve at the given parametric value

from:via:to:

from:withMidPoint:at:to:

from:withMidPoint:to:

hasZeroLength

Return true if the receiver has zero length

initializeFrom:

isBezier2Segment

Return true if the receiver is a quadratic bezier segment

isStraight

Return true if the receiver represents a straight line

length

Return the length of the receiver

lineSegments:do:

Evaluate aBlock with the receiver's line segments

lineSegmentsDo:

Evaluate aBlock with the receiver's line segments

makeEllipseSegments:

outlineSegment:

parameterAtExtreme:

Compute the parameter value at which the tangent reaches tangentDirection.

We need to find the parameter value t at which the following holds

((t * dir + in) crossProduct: tangentDirection) = 0.

Since this is pretty ugly we use the normal direction rather than the tangent and compute the equivalent relation using the dot product as

((t * dir + in) dotProduct: nrm) = 0.

Reformulation yields

((t * dir x + in x) * nrm x) + ((t * dir y + in y) * nrm y) = 0.

(t * dir x * nrm x) + (in x * nrm x) + (t * dir y * nrm y) + (in y * nrm y) = 0.

(t * dir x * nrm x) + (t * dir y * nrm y) = 0 - ((in x * nrm x) + (in y * nrm y)).

(in x * nrm x) + (in y * nrm y)

t = 0 - ---------------------------------------

(dir x * nrm x) + (dir y * nrm y)

And that's that. Note that we can get rid of the negation by computing 'dir' the other way around (e.g., in the above it would read '-dir') which is trivial to do. Note also that the above does not generalize easily beyond 2D since its not clear how to express the 'normal direction' of a tangent plane.

We need to find the parameter value t at which the following holds

((t * dir + in) crossProduct: tangentDirection) = 0.

Since this is pretty ugly we use the normal direction rather than the tangent and compute the equivalent relation using the dot product as

((t * dir + in) dotProduct: nrm) = 0.

Reformulation yields

((t * dir x + in x) * nrm x) + ((t * dir y + in y) * nrm y) = 0.

(t * dir x * nrm x) + (in x * nrm x) + (t * dir y * nrm y) + (in y * nrm y) = 0.

(t * dir x * nrm x) + (t * dir y * nrm y) = 0 - ((in x * nrm x) + (in y * nrm y)).

(in x * nrm x) + (in y * nrm y)

t = 0 - ---------------------------------------

(dir x * nrm x) + (dir y * nrm y)

And that's that. Note that we can get rid of the negation by computing 'dir' the other way around (e.g., in the above it would read '-dir') which is trivial to do. Note also that the above does not generalize easily beyond 2D since its not clear how to express the 'normal direction' of a tangent plane.

parameterAtExtremeX

Note: Only valid for non-monoton receivers

parameterAtExtremeY

Note: Only valid for non-monoton receivers

printOn:

Print the receiver on aStream

printOnStream:

roundTo:

tangentAt:

Return the tangent at the given parametric value along the receiver

tangentAtEnd

Return the tangent for the last point

tangentAtMid

Return the tangent at the given parametric value along the receiver

tangentAtStart

Return the tangent for the first point

valueAt:

Evaluate the receiver at the given parametric value

via

Return the control point

Bezier3Segment

This class represents a cubic bezier segment between two points

Instance variables:

via1, via2 <Point> The additional control points (OFF the curve)

Instance variables:

via1, via2 <Point> The additional control points (OFF the curve)

asBezier2Points:

Demote a cubic bezier to a set of approximating quadratic beziers.

Should convert to forward differencing someday

Should convert to forward differencing someday

asBezier2Segments

Demote a cubic bezier to a set of approximating quadratic beziers.

asBezierShape

Demote a cubic bezier to a set of approximating quadratic beziers.

asBezierShape:

Demote a cubic bezier to a set of approximating quadratic beziers.

Should convert to forward differencing someday

Should convert to forward differencing someday

asPointArray

asTangentSegment

bezier2SegmentCount

Compute the number of quadratic bezier segments needed to approximate

this cubic with less than a 1-pixel error

this cubic with less than a 1-pixel error

bezier2SegmentCount:

Compute the number of quadratic bezier segments needed to approximate

this cubic with no more than a specified error

this cubic with no more than a specified error

bezierClipHeight:

Check if the argument overlaps the receiver somewhere

along the line from start to end. Optimized for speed.

along the line from start to end. Optimized for speed.

bounds

Return the bounds containing the receiver

controlPoints

controlPointsDo:

convertBezier3ToBezier2:

degree

example1

example2

from:to:

Initialize the receiver

from:via:and:to:

initializeFrom:

length

Answer a gross approximation of the length of the receiver

lineSegments:do:

Evaluate aBlock with the receiver's line segments

lineSegmentsDo:

Evaluate aBlock with the receiver's line segments

makeEllipseSegments:

makeEllipseSegments:count:

makePieSegment:from:to:

makePieSegments:from:to:

makeUnitPieSegmentFrom:to:

makeUnitPieSegmentWith:and:

outlineSegment:

tangentAt:

Return the tangent at the given parametric value along the receiver

tangentAtEnd

Return the tangent for the last point

tangentAtMid

Return the tangent for the last point

tangentAtStart

Return the tangent for the last point

valueAt:

| p1 p2 p3 |

p1 := start interpolateTo: via1 at: t.

p2 := via1 interpolateTo: via2 at: t.

p3 := via2 interpolateTo: end at: t.

p1 := p1 interpolateTo: p2 at: t.

p2 := p2 interpolateTo: p3 at: t.

^ p1 interpolateTo: p2 at: t

p1 := start interpolateTo: via1 at: t.

p2 := via1 interpolateTo: via2 at: t.

p3 := via2 interpolateTo: end at: t.

p1 := p1 interpolateTo: p2 at: t.

p2 := p2 interpolateTo: p3 at: t.

^ p1 interpolateTo: p2 at: t

via1

via1:

via2

via2:

BitmapFillStyle

A BitmapFillStyle fills using any kind of form.

Instance variables:

form <Form> The form to be used as fill.

tileFlag <Boolean> If true, then the form is repeatedly drawn to fill the area.

Instance variables:

form <Form> The form to be used as fill.

tileFlag <Boolean> If true, then the form is repeatedly drawn to fill the area.

asColor

direction

form

form:

fromForm:

fromUser

grabNewGraphicIn:event:

Used by any morph that can be represented by a graphic

isBitmapFill

isTiled

Return true if the receiver should be repeated if the fill shape is larger than the form

newForm:forMorph:

normal

tileFlag

tileFlag:

CompressedBoundaryShape

This class represents a very compact representation of a boundary shape. It consists of a number of compressed arrays that can be handled by the balloon engine directly. Due to this, there are certain restrictions (see below). Boundaries are always represented by three subsequent points that define a quadratic bezier segment. It is recommended that for straight line segments the control point is set either to the previous or the next point.

Instance variables:

points <PointArray | ShortPointArray> Point storage area

leftFills <ShortRunArray> Containing the "left" fill index of each segment

rightFills <ShortRunArray> Containing the "right" fill index of each segment

lineWidths <ShortRunArray> Containing the line width of each segment

lineFills <ShortRunArray> Containing the line fill (e.g., line color) of each segment

fillStyles <Collections> Contains the actual fill styles referenced by the indexes

RESTRICTIONS:

None of the ShortRunArrays may contain a run of length Zero.

Also, due to the use of ShortRunArrays

a) you cannot have more than 32768 different fill styles

b) you cannot have a line width that exceeds 32768

In case you have trouble with a), try to merge some of the fills into one. You might do so by converting colors to 32bit pixel values. In case you have trouble with b) you might change the general resolution of the compressed shape to have less accuracy.

Instance variables:

points <PointArray | ShortPointArray> Point storage area

leftFills <ShortRunArray> Containing the "left" fill index of each segment

rightFills <ShortRunArray> Containing the "right" fill index of each segment

lineWidths <ShortRunArray> Containing the line width of each segment

lineFills <ShortRunArray> Containing the line fill (e.g., line color) of each segment

fillStyles <Collections> Contains the actual fill styles referenced by the indexes

RESTRICTIONS:

None of the ShortRunArrays may contain a run of length Zero.

Also, due to the use of ShortRunArrays

a) you cannot have more than 32768 different fill styles

b) you cannot have a line width that exceeds 32768

In case you have trouble with a), try to merge some of the fills into one. You might do so by converting colors to 32bit pixel values. In case you have trouble with b) you might change the general resolution of the compressed shape to have less accuracy.

bounds

collectFills:

copyAndCollectFills:

fillStyles

leftFills

lineFills

lineWidths

morphFrom:to:at:

numSegments

points

points:leftFills:rightFills:fillStyles:lineWidths:lineFills:

rightFills

segments

Return all the segments in the receiver

segmentsDo:

Enumerate all segments in the receiver and execute aBlock

setPoints:leftFills:rightFills:fillStyles:lineWidths:lineFills:

FillStyle

FillStyle is an abstract base class for fills in the BalloonEngine.

asColor

fillRectangle:on:

Fill the given rectangle on the given canvas with the receiver.

isBitmapFill

isCompositeFill

Answer whether the receiver is a composite fill.

False by default.

False by default.

isGradientFill

isOrientedFill

Return true if the receiver keeps an orientation (e.g., origin, direction, and normal)

isSolidFill

isTranslucent

isTransparent

mixed:with:

scaledPixelValue32

Return a pixel value of depth 32 for the primary color in the fill style

GradientFillStyle

A gradient fill style is a fill which interpolates smoothly between any number of colors.

Instance variables:

colorRamp <Array of: Association> Contains the colors and their relative positions along the fill, which is a number between zero and one.

pixelRamp <Bitmap> A cached version of the colorRamp to avoid needless recomputations.

radial <Boolean> If true, this fill describes a radial gradient. If false, it is a linear gradient.

isTranslucent <Boolean> A (cached) flag determining if there are any translucent colors involved.

Class variables:

PixelRampCache <LRUCache> Recently used pixelRamps. They tend to have high temporal locality and this saves space and time.

Instance variables:

colorRamp <Array of: Association> Contains the colors and their relative positions along the fill, which is a number between zero and one.

pixelRamp <Bitmap> A cached version of the colorRamp to avoid needless recomputations.

radial <Boolean> If true, this fill describes a radial gradient. If false, it is a linear gradient.

isTranslucent <Boolean> A (cached) flag determining if there are any translucent colors involved.

Class variables:

PixelRampCache <LRUCache> Recently used pixelRamps. They tend to have high temporal locality and this saves space and time.

=

Answer whether equal.

addFillStyleMenuItems:hand:from:

Add the items for changing the current fill style of the receiver

addNewColorIn:event:

asColor

Guess...

beLinearGradientIn:

beRadialGradientIn:

changeColorSelector:hand:morph:originalColor:

Change either the firstColor or the lastColor (depending on aSymbol). Put up a color picker to hande it. We always use a modal picker so that the user can adjust both colors concurrently.

changeFirstColorIn:event:

changeSecondColorIn:event:

checkTranslucency

colorRamp

colorRamp:

colors:

computePixelRampOfSize:

Compute the pixel ramp in the receiver

display

firstColor:forMorph:hand:

hash

Hash is implemented because #= is implemented.

initPixelRampCache

isGradientFill

isRadialFill

isTranslucent

lastColor:forMorph:hand:

mixed:with:

pixelRamp

Compute a pixel ramp, and cache it for future accesses

pixelRamp:

pixelRampCache

radial

radial:

ramp:

sample

scaledAlphaMix:of:with:

Open-coded version of alpha mixing two 32bit pixel words and returning the scaled pixel value.

LineSegment

This class represents a straight line segment between two points

Instance variables:

start <Point> start point of the line

end <Point> end point of the line

Instance variables:

start <Point> start point of the line

end <Point> end point of the line

asBezier2Curves:

asBezier2Points:

asBezier2Segment

Represent the receiver as quadratic bezier segment

asBezier2Segments:

Demote a cubic bezier to a set of approximating quadratic beziers.

asIntegerSegment

Convert the receiver into integer representation

asLineSegment

Represent the receiver as a straight line segment

asTangentSegment

bezierClipCurve:

bezierClipCurve:epsilon:

Compute the intersection of the receiver (a line) with the given curve using bezier clipping.

bezierClipInterval:

Compute the new bezier clip interval for the argument,

based on the fat line (the direction aligned bounding box) of the receiver.

Note: This could be modified so that multiple clip intervals are returned.

The idea is that for a distance curve like

x x

tMax---- --\-----/---\-------

x x

tMin-------------------------

all the intersections intervals with tMin/tMax are reported, therefore

minimizing the iteration count. As it is, the process will slowly iterate

against tMax and then the curve will be split.

based on the fat line (the direction aligned bounding box) of the receiver.

Note: This could be modified so that multiple clip intervals are returned.

The idea is that for a distance curve like

x x

tMax---- --\-----/---\-------

x x

tMin-------------------------

all the intersections intervals with tMin/tMax are reported, therefore

minimizing the iteration count. As it is, the process will slowly iterate

against tMax and then the curve will be split.

bounds

Return the bounds containing the receiver

controlPoints

controlPoints:

controlPointsDo:

curveFrom:to:

Create a new segment like the receiver but starting/ending at the given parametric values

debugDraw

debugDrawAt:

degree

direction

end

Return the end point

end:

from:to:

Initialize the receiver

from:to:via:

fromPoints:

hasZeroLength

Return true if the receiver has zero length

initializeFrom:

intersectFrom:with:to:with:

intersectionWith:

Copied from LineIntersections>>intersectFrom:to:with:to:

isArcSegment

Answer whether I approximate an arc segment reasonably well

isBezier2Segment

Return true if the receiver is a quadratic bezier segment

isLineSegment

Return true if the receiver is a line segment

isStraight

Return true if the receiver represents a straight line

length

Return the length of the receiver

lineSegments:do:

Evaluate aBlock with the receiver's line segments

lineSegmentsDo:

Evaluate aBlock with the receiver's line segments

printOn:

Print the receiver on aStream

reversed

roundTo:

sideOfPoint:

Return the side of the receiver this point is on. The method returns

-1: if aPoint is left

0: if aPoint is on

+1: if a point is right

of the receiver.

-1: if aPoint is left

0: if aPoint is on

+1: if a point is right

of the receiver.

start

Return the start point

start:

tangentAt:

Return the tangent at the given parametric value along the receiver

tangentAtEnd

Return the tangent for the last point

tangentAtMid

Return the tangent for the last point

tangentAtStart

Return the tangent for the last point

valueAt:

Evaluate the receiver at the given parametric value

valueAtEnd

Evaluate the receiver at it's end point (e.g., self valueAtEnd = (self valueAt: 1.0))

valueAtStart

Evaluate the receiver at it's start point (e.g., self valueAtEnd = (self valueAt: 0.0))

OrientedFillStyle

OrientedFill is an abstract superclass for fills which can be aligned appropriately.

Instance variables:

origin <Point> The point at which to align the fill.

direction <Point> The direction in which the fill is defined

normal <Point> Typically, just the direction rotated by 90 degrees.

Instance variables:

origin <Point> The point at which to align the fill.

direction <Point> The direction in which the fill is defined

normal <Point> Typically, just the direction rotated by 90 degrees.

=

Answer whether equal.

addFillStyleMenuItems:hand:from:

Add the items for changing the current fill style of the receiver

changeOrientationIn:event:

Interactively change the origin of the receiver

changeOriginIn:event:

Interactively change the origin of the receiver

direction

direction:

hash

Hash is implemented because #= is implemented.

isOrientedFill

Return true if the receiver keeps an orientation (e.g., origin, direction, and normal)

normal

normal:

origin

origin:

PointArray

This class stores 32bit Integer points in place. It is used to pass data efficiently to the primitive level during high-bandwidth 2D graphics operations.

asPointArray

Answer an PointArray whose elements are the elements of the receiver, in

the same order.

the same order.

at:

Return the element (e.g., point) at the given index

at:put:

Store the argument aPoint at the given index

bounds

defaultElement

Return the default element of the receiver

new:

size

Return the number of elements in the receiver

ShortIntegerArray

ShortIntegerArray is an array for efficiently representing integers in the 16bit range.

at:

Return the 16-bit integer value at the given index of the receiver.

at:put:

Store the given 16-bit integer at the given index in the receiver.

bytesPerBasicElement

Answer the number of bytes that each of my basic elements requires.

In other words:

self basicSize * self bytesPerBasicElement

should equal the space required on disk by my variable sized representation.

In other words:

self basicSize * self bytesPerBasicElement

should equal the space required on disk by my variable sized representation.

bytesPerElement

defaultElement

initialize

Subclasses should redefine this method to perform initializations on instance creation

new:

pvtAt:

Private -- for swapping only

pvtAt:put:

Private -- for swapping only

restoreEndianness

This word object was just read in from a stream. It was stored in Big Endian (Mac) format. Swap each pair of bytes (16-bit word), if the current machine is Little Endian.

Why is this the right thing to do? We are using memory as a byteStream. High and low bytes are reversed in each 16-bit word, but the stream of words ascends through memory. Different from a Bitmap.

Why is this the right thing to do? We are using memory as a byteStream. High and low bytes are reversed in each 16-bit word, but the stream of words ascends through memory. Different from a Bitmap.

size

Answer how many elements the receiver contains.

startUp

startUpFrom:

swapShortObjects

Private -- swap all the short quantities in the receiver

writeOn:

Store the array of bits onto the argument, aStream. (leading byte ~= 16r80) identifies this as raw bits (uncompressed). Always store in Big Endian (Mac) byte order. Do the writing at BitBlt speeds. We only intend this for non-pointer arrays. Do nothing if I contain pointers.

ShortPointArray

This class stores points that are in short integer range (e.g., -32767 <= value <= 32768). It is used to pass data efficiently to the primitive level during high-bandwidth 2D graphics operations.

at:

Return the element (e.g., point) at the given index

at:put:

Store the argument aPoint at the given index

bounds

bytesPerElement

defaultElement

Return the default element of the receiver

new:

size

Answer how many elements the receiver contains.

ShortRunArray

This class is run-length encoded representation of short integer (e.g., 16bit signed integer values)

at:

Return the short value at the given index

at:put:

ShortRunArrays are read-only

bytesPerElement

compressionRatio

Return the compression ratio.

The compression ratio is computed based

on how much space would be needed to

store the receiver in a ShortIntegerArray

The compression ratio is computed based

on how much space would be needed to

store the receiver in a ShortIntegerArray

do:

Evaluate aBlock with all elements of the receiver

initialize

Subclasses should redefine this method to perform initializations on instance creation

lengthAtRun:

Return the length of the run starting at the given index

lengthsAndValuesDo:

Evaluate aBlock with the length and value of each run in the receiver

new:

newFrom:

printOn:

Append a sequence of characters that identify the receiver to aStream.

pvtAt:

Private -- for swapping only

pvtAt:put:

Private -- for swapping only

restoreEndianness

This word object was just read in from a stream. It was stored in Big Endian (Mac) format. Swap each pair of bytes (16-bit word), if the current machine is Little Endian.

Why is this the right thing to do? We are using memory as a byteStream. High and low bytes are reversed in each 16-bit word, but the stream of words ascends through memory. Different from a Bitmap.

Why is this the right thing to do? We are using memory as a byteStream. High and low bytes are reversed in each 16-bit word, but the stream of words ascends through memory. Different from a Bitmap.

runSize

Return the number of runs in the receiver

runs:values:

runsAndValuesDo:

Evaluate aBlock with the length and value of each run in the receiver

setRunAt:toLength:value:

setRuns:values:

size

Return the number of elements stored in the receiver

species

Answer the preferred class for reconstructing the receiver.

startUp

startUpFrom:

swapRuns

Private -- swap length/value pairs in the receiver

valueAtRun:

Return the value of the run starting at the given index

valuesCollect:

Evaluate aBlock with each of the receiver's values as the argument.

Collect the resulting values into a collection like the receiver. Answer

the new collection.

Collect the resulting values into a collection like the receiver. Answer

the new collection.

valuesDo:

SolidFillStyle

SolidFillStyle is a fill which represents a color for the BalloonEngine.

Instance variables:

color <Color> The color to use.

pixelValue32 <Integer> The cached pixel value to use.

Instance variables:

color <Color> The color to use.

pixelValue32 <Integer> The cached pixel value to use.

asColor

color:

display

isSolidFill

isTranslucent

isTransparent

printOn:

Append to the argument, aStream, a sequence of characters that

identifies the receiver.

identifies the receiver.

scaledPixelValue32

Return the alpha scaled pixel value for depth 32