Page History

...

When done, if a dimension is sized to content, the layout sets the size of that dimension.Note:

Layout Guidelines

ActionScript vs JavaScript

When creating your own layout, take advantage of the platform's abilities. Keep in mind that the ActionScript version of a layout mimics what you can do with HTML. The VerticalLayout, for example, just sets the HTML elements that back the FlexJS components to have a display style of 'block' so they appear on separate lines. 

The ActionScript version of a layout may be more complex since it has to do more work. The ActionScript version of VerticalLayout is more complex and provides a really good example of how to write a layout.

You may be able to create layouts which can be cross-compiled from ActionScript to JavaScript, but you may get better performance if you write native JavaScript layouts.

Composition

Layouts work within Containers. A Container has an area called the "contentView" where the items go that are being laid out. The contentView is managed by a Viewport which is responsible for the size and position of the contentView. If a Container is being scrolled, a ScrollableViewport is used instead of the plain Viewport.

Sizing

As mentioned above, Containers may be sized explicitly or by their content. This can happen in either or both dimensions (for example, a Container that specifies a width and not a height). When a Container is being sized by its content, the layout is used to determine the Container's size by calculating a bounding box that surrounds the children once the layout has been run. 

Some layouts need to know the amount of space they have to work with. The contentView can provide that through its width and height properties. When a Container is being sized by its content, the layout may not get valid width and/or height values from the contentView. In this case, the layout must assume the Container is infinitely wide or tall or the layout can make some assumptions and impose its own constraints.

Layouts such as VerticalLayout and HorizontalLayout do not depend on the Container having a size. These layouts simply follow an algorithm and position the children which makes them ideal candidates for Containers whose size must be determined by the content.

Padding and Margin

It is the responsibility of the layout to handle offsets introduced by padding and margin styles. Again, the JavaScript layout should probably default to letting HTML handle this.

If you look at the ActionScript version of VerticalLayout, you'll see how padding and margin values are obtained from the components and used to calculate the placement of the items in the layout. Your layout may need to do the same thing if it is to respect padding and margin when your application is run from Flash.

Custom Container Views

Using a Container as a base for a new component is often a good idea if you want to take advantage of layouts. In FlexJS, the majority of the work of a component is handled by its view bead. For Containers, this is the ContainerView bead. When creating components based on Container, you will most likely need to extend ContainerView. 

Use PanelView as a guide to building your own custom ContainerView.

If your component contains other elements which are not be affected by the layout, you may need to override some methods to adjust the placement of the contentView to allow room for your additional pieces. In FlexJS, these additional pieces are referred to as "chrome" and must implement the IChrome interface which merely declares them to be a chrome element. When chrome elements are added to a Container, they become children of the Container itself and not the content view.

These are the general steps for extending ContainerView and overriding some functions.

1. Create your custom view by extending org.apache.flex.html.beads.ContainerView.
2. Override the strand setter function if you need to keep a reference to the strand.
3. Override getChromeMetrics to return a org.apache.flex.geom.Rectangle that accounts for the additional chrome pieces you are adding.
4. Override layoutViewAfterContainerLayout to size and position your chrome pieces and then call the super function.

Custom Content

The Container class uses a simple component, ContainerContentArea, for the contentView, to hold the elements to be displayed and arranged by the layout. The FlexJS framework automatically adds any elements specified in MXML to the contentView. If your component needs to generate, or programmatically fill, the content of a container, you may want to consider creating a custom contentView.

The List and chart components are examples of doing this. The List extends Container, but it also provides a special contentView called DataGroup, which is designed to work with item renderers. The List then uses the VerticalLayout to present the item renderer instances.

The chart components use ChartDataGroup which is designed to work with the graphic elements of the chart; charts use their own layouts to make each chart type.

To replace a Container's content view:

1. Create the custom content view by extending org.apache.flex.html.supportClasses.ContainerContentArea. 
2. Add the functions you need to create the content.
3. In the CSS Style definition for your class, add IContentView with a ClassReference that names your custom content view.

Conclusion

FlexJS provides a number of ways to achieve a custom look in an application. You can use the common Container component with custom layouts or extend ContainerView and add more elements or use a combination of custom view, custom layout, and even a custom contentView. Use the FlexJS component library for examples As of May 18, 2015, lots of the views and layouts aren’t handling all three scenarios.  Also, most views and layouts are not listening for childrenRemoved events.