The LayoutBase class defines the base class for all Spark layouts.
To create a custom layout that works with the Spark containers,
you must extend LayoutBase or one of its subclasses.

At minimum, subclasses must implement the updateDisplayList()
method, which positions and sizes the target GroupBase's elements, and
the measure() method, which calculates the default
size of the target.

Subclasses may override methods like getElementBoundsAboveScrollRect()
and getElementBoundsBelowScrollRect() to customize the way
the target behaves when it's connected to scrollbars.

Subclasses that support virtualization must respect the
useVirtualLayout property and should only retrieve
layout elements within the scrollRect (the value of
getScrollRect()) using getVirtualElementAt()
from within updateDisplayList().

dropIndicator

The DisplayObject that this layout uses for
the drop indicator during a drag-and-drop operation.
Typically you do not set this property directly,
but instead define a dropIndicator skin part in the
skin class of the drop target.

The List control sets this property in response to a
DragEvent.DRAG_ENTER event.
The List initializes this property with an
instance of its dropIndicator skin part.
The List clears this property in response to a
DragEvent.DRAG_EXIT event.

horizontalScrollPosition

The x coordinate of the origin of the viewport in the component's coordinate system,
where the default value is (0,0) corresponding to the upper-left corner of the component.
If clipAndEnableScrolling is true, setting this property
typically causes the viewport to be set to:

useVirtualLayout

A container can hold any number of children.
However, each child requires an instance of an item renderer.
If the container has many children, you might notice performance degradation
as you add more children to the container.

Instead of creating an item renderer for each child,
you can configure the container to use a virtual layout.
With virtual layout, the container reuses item renderers so that it only creates
item renderers for the currently visible children of the container.
As a child is moved off the screen, possible by scrolling the container,
a new child being scrolled onto the screen can reuse its item renderer.

To configure a container to use virtual layout, set the useVirtualLayout property
to true for the layout associated with the container.
Only DataGroup or SkinnableDataContainer with layout set to VerticalLayout,
HorizontalLayout, or TileLayout supports virtual layout.
Layout subclasses that do not support virtualization must prevent changing
this property.

Note: The BasicLayout class throws a run-time error if you set
useVirtualLayout to true.

When true, layouts that support virtualization must use
the target.getVirtualElementAt() method,
rather than getElementAt(), and must only get the
elements they anticipate will be visible given the value of getScrollRect().

When true, the layout class must be able to compute
the indices of the layout elements that overlap the scrollRect in its
updateDisplayList() method based exclusively on cached information, not
by getting layout elements and examining their bounds.

Typically virtual layouts update their cached information
in the updateDisplayList() method,
based on the sizes and locations computed for the elements in view.

Similarly, in the measure() method, virtual layouts should update the target's
measured size properties based on the typicalLayoutElement and other
cached layout information, not by measuring elements.

Containers cooperate with layouts that have useVirtualLayout = true by
recycling item renderers that were previously constructed, but are no longer in use.
An item is considered to be no longer in use if its index is not
within the range of getVirtualElementAt() indices requested during
the container's most recent updateDisplayList() invocation.

The default value is false.

Implementation public function get useVirtualLayout():Boolean public function set useVirtualLayout(value:Boolean):void

verticalScrollPosition

The y coordinate of the origin of the viewport in the component's coordinate system,
where the default value is (0,0) corresponding to the upper-left corner of the component.
If clipAndEnableScrolling is true, setting this property
typically causes the viewport to be set to:

calculateDropIndex

Returns the index where a new item should be inserted if
the user releases the mouse at the specified coordinates
while completing a drag and drop gesture.
Called by the calculatedDropLocation() method.

Parameters

x:Number — The x coordinate of the drag and drop gesture, in
local coordinates.

y:Number — The y coordinate of the drag and drop gesture, in
the drop target's local coordinates.

Returns

int — The drop index or -1 if the drop operation is not available
at the specified coordinates.

calculateDropIndicatorBounds

Calculates the bounds for the drop indicator that provides visual feedback
to the user of where the items will be inserted at the end of a drag and drop
gesture.
Called by the showDropIndicator() method.

Parameters

dropLocation:DropLocation — A valid DropLocation object previously returned
by the calculateDropLocation() method.

elementAdded

Called by the target after a layout element
has been added and before the target's size and display list are
validated.
Layouts that cache per element state, like virtual layouts, can
override this method to update their cache.

If the target calls this method, it's only guaranteeing that a
a layout element will exist at the specified index at
updateDisplayList() time, for example a DataGroup
with a virtual layout will call this method when an item is added
to the targets dataProvider.

elementRemoved

This method must is called by the target after a layout element
has been removed and before the target's size and display list are
validated.
Layouts that cache per element state, like virtual layouts, can
override this method to update their cache.

If the target calls this method, it's only guaranteeing that a
a layout element will no longer exist at the specified index at
updateDisplayList() time.
For example, a DataGroup
with a virtual layout calls this method when an item is added to
the dataProvider property.

getElementBoundsAboveScrollRect

Returns the bounds of the first layout element that either spans or
is above the scrollRect's top edge.

This is a convenience method that is used by the default
implementation of the getVerticalScrollPositionDelta() method.
Subclasses that rely on the default implementation of
getVerticalScrollPositionDelta() should override this method to
provide an accurate bounding rectangle that has valid top and
bottom properties.

By default this method returns a Rectangle with width=0, height=1,
whose top edge is one less than the top edge of the scrollRect,
and left=0.

Subclasses should override this method to provide an accurate
bounding rectangle that has valid top and
bottom properties.

getElementBoundsBelowScrollRect

Returns the bounds of the first layout element that either spans or
is below the scrollRect's bottom edge.

This is a convenience method that is used by the default
implementation of the getVerticalScrollPositionDelta() method.
Subclasses that rely on the default implementation of
getVerticalScrollPositionDelta() should override this method to
provide an accurate bounding rectangle that has valid top and
bottom properties.

By default this method returns a Rectangle with width=0, height=1,
whose bottom edge is one more than the bottom edge of the scrollRect,
and left=0.

getElementBoundsLeftOfScrollRect

Returns the bounds of the first layout element that either spans or
is to the left of the scrollRect's left edge.

This is a convenience method that is used by the default
implementation of the getHorizontalScrollPositionDelta() method.
Subclasses that rely on the default implementation of
getHorizontalScrollPositionDelta() should override this method to
provide an accurate bounding rectangle that has valid left and
right properties.

By default this method returns a Rectangle with width=1, height=0,
whose left edge is one less than the left edge of the scrollRect,
and top=0.

getElementBoundsRightOfScrollRect

Returns the bounds of the first layout element that either spans or
is to the right of the scrollRect's right edge.

This is a convenience method that is used by the default
implementation of the getHorizontalScrollPositionDelta() method.
Subclasses that rely on the default implementation of
getHorizontalScrollPositionDelta() should override this method to
provide an accurate bounding rectangle that has valid left and
right properties.

By default this method returns a Rectangle with width=1, height=0,
whose right edge is one more than the right edge of the scrollRect,
and top=0.

END
Returns scroll delta that will right justify the scrollRect
to the content area.

HOME
Returns scroll delta that will left justify the scrollRect
to the content area.

LEFT
Returns scroll delta that will left justify the scrollRect
with the first element that spans or is to the left of the
scrollRect's left edge.

PAGE_LEFT
Returns scroll delta that will right justify the scrollRect
with the first element that spans or is to the left of the
scrollRect's left edge.

PAGE_RIGHT
Returns scroll delta that will left justify the scrollRect
with the first element that spans or is to the right of the
scrollRect's right edge.

RIGHT
Returns scroll delta that will right justify the scrollRect
with the first element that spans or is to the right of the
scrollRect's right edge.

The implementation calls getElementBoundsLeftOfScrollRect() and
getElementBoundsRightOfScrollRect() to determine the bounds of
the elements. Layout classes usually override those methods instead of
the getHorizontalScrollPositionDelta() method.

Delegation method that determines which item
to navigate to based on the current item in focus
and user input in terms of NavigationUnit. This method
is used by subclasses of ListBase to handle
keyboard navigation. ListBase maps user input to
NavigationUnit constants.

Subclasses can override this method to compute other
values that are based on the current index and key
stroke encountered.

getScrollPositionDeltaToElement

Computes the verticalScrollPosition and
horizontalScrollPosition deltas needed to
scroll the element at the specified index into view.

This method attempts to minimize the change to verticalScrollPosition
and horizontalScrollPosition.

If clipAndEnableScrolling is true
and the element at the specified index is not
entirely visible relative to the target's scroll rectangle, then
return the delta to be added to horizontalScrollPosition and
verticalScrollPosition that scrolls the element completely
within the scroll rectangle's bounds.

Point — A Point that contains offsets to horizontalScrollPosition
and verticalScrollPosition that will scroll the specified
element into view, or null if no change is needed.
If the specified element is partially visible and larger than the
scroll rectangle, meaning it is already the only element visible, then
return null.
If the specified index is invalid, or target is null, then
return null.
If the element at the specified index is null or includeInLayout
false, then return null.

DOWN
Returns scroll delta that will bottom justify the scrollRect
with the first element that spans or is below the scrollRect's
bottom edge.

END
Returns scroll delta that will bottom justify the scrollRect
to the content area.

HOME
Returns scroll delta that will top justify the scrollRect
to the content area.

PAGE_DOWN
Returns scroll delta that will top justify the scrollRect
with the first element that spans or is below the scrollRect's
bottom edge.

PAGE_UP

Returns scroll delta that will bottom justify the scrollRect
with the first element that spans or is above the scrollRect's
top edge.

UP
Returns scroll delta that will top justify the scrollRect
with the first element that spans or is above the scrollRect's
top edge.

The implementation calls getElementBoundsAboveScrollRect() and
getElementBoundsBelowScrollRect() to determine the bounds of
the elements. Layout classes usually override those methods instead of
the getVerticalScrollPositionDelta() method.

measure

Measures the target's default size based on its content, and optionally
measures the target's default minimum size.

This is one of the methods that you must override when creating a
subclass of LayoutBase. The other method is updateDisplayList().
You do not call these methods directly. Flex calls this method as part
of a layout pass. A layout pass consists of three phases.

First, if the target's properties are invalid, the LayoutManager calls
the target's commitProperties method.

Second, if the target's size is invalid, LayoutManager calls the target's
validateSize() method. The target's validateSize()
will in turn call the layout's measure() to calculate the
target's default size unless it was explicitly specified by both target's
explicitWidth and explicitHeight properties.
If the default size changes, Flex will invalidate the target's display list.

Last, if the target's display list is invalid, LayoutManager calls the target's
validateDisplayList. The target's validateDisplayList
will in turn call the layout's updateDisplayList method to
size and position the target's elements.

When implementing this method, you must set the target's
measuredWidth and measuredHeight properties
to define the target's default size. You may optionally set the
measuredMinWidth and measuredMinHeight
properties to define the default minimum size.
A typical implementation iterates through the target's elements
and uses the methods defined by the ILayoutElement to
accumulate the preferred and/or minimum sizes of the elements and then sets
the target's measuredWidth, measuredHeight,
measuredMinWidth and measuredMinHeight.

scrollPositionChanged

Called when the verticalScrollPosition or
horizontalScrollPosition properties change.

The default implementation updates the target's scrollRect property by
calling updateScrollRect().
Subclasses can override this method to compute other values that are
based on the current scrollPosition or scrollRect.

This is one of the methods that you must override when creating a
subclass of LayoutBase. The other method is measure().
You do not call these methods directly. Flex calls this method as part
of a layout pass. A layout pass consists of three phases.

First, if the target's properties are invalid, the LayoutManager calls
the target's commitProperties method.

Second, if the target's size is invalid, LayoutManager calls the target's
validateSize() method. The target's validateSize()
will in turn call the layout's measure() to calculate the
target's default size unless it was explicitly specified by both target's
explicitWidth and explicitHeight properties.
If the default size changes, Flex will invalidate the target's display list.

Last, if the target's display list is invalid, LayoutManager calls the target's
validateDisplayList. The target's validateDisplayList
will in turn call the layout's updateDisplayList method to
size and position the target's elements.

A typical implementation iterates through the target's elements
and uses the methods defined by the ILayoutElement to
position and resize the elements. Then the layout must also calculate and set
the target's contentWidth and contentHeight
properties to define the target's scrolling region.

Parameters

width:Number — Specifies the width of the target, in pixels,
in the targets's coordinates.

height:Number — Specifies the height of the component, in pixels,
in the target's coordinates.

updateScrollRect

Called by the target at the end of its updateDisplayList
to have the layout update its scrollRect.

If clipAndEnableScrolling is true,
the default implementation sets the origin of the target's scrollRect
to verticalScrollPosition, horizontalScrollPosition.
It sets its size to the width, height
parameters (the target's unscaled width and height).

If clipAndEnableScrolling is false,
the default implementation sets the scrollRect to null.