Balloon

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
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
outTangent
Return the tangent at the end point
printOn:
Append to the argument, aStream, a sequence of characters that
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,
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
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.
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
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.
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.
primNextFillEntryInto:
Store the next fill entry of the active edge table in fillEntry.
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.
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.
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.
reset
resetBezierStats
resetIfNeeded
resetStats
BalloonEngineConstants
A BalloonEngineConstants is xxxxxxxxx.
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.
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,
subdivide
BalloonSolidFillSimulation
This class is a simulation of the code that's run by the Balloon engine. For debugging purposes only.
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)
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.
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)
asBezier2Points:
Demote a cubic bezier to a set of approximating quadratic beziers.
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
asPointArray
asTangentSegment
bezier2SegmentCount
Compute the number of quadratic bezier segments needed to approximate
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
bezierClipHeight:
Check if the argument overlaps the receiver somewhere
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
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.
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.
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.
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.
=
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
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.
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.
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.
=
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.
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.
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.
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
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.
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.
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.
asColor
color:
display
isSolidFill
isTranslucent
isTransparent
printOn:
Append to the argument, aStream, a sequence of characters that
identifies the receiver.
scaledPixelValue32
Return the alpha scaled pixel value for depth 32