CODEWITHSUNDEEP
apache-flexactionscript
MetaChrome
MetaChrome

Reputation: 3220

Flex component setActualSize

I am a little confused about the setActualSize method. It appears from what I've read, that if it is not called on a component by its parent, the component will not be rendered.

So it appears that setActualSize is a critical method that is directly bound to rendering the UIComponent. It also appears that the width and height properties of UIComponent override the functionality of the width and height properties of flash.display.DisplayObject, in that they are not directly bound to the rendering of the object but are virtual values that are mainly used by the getExplicitOrMeasured when the parent of the component calls the component's setActualSize method.

So the question are:

1) Why isn't the default behavior of every component to just call setActualSize(getExplicitOrMeasuredWidth(),getExplicitOrMeasuredHeight()) on itself?

2) I guess this question stems from the above question and the behavior as I understand it as described above: does setActualSize change the visibility of the component?

It appears that that the behavior is that a component is not rendered until setActualSize is called, but if it contains display object children itself (expected behavior as it can calculate measure on itself) and is added to the display list, the only reason why flash isn't rendering it, is because its not visible.

Upvotes: 1

Views: 1376

Answers (2)

Danko Kozar
Danko Kozar

Reputation: 241

setActualSize() is one of the crutial and most interesting methods in Flex layout process:

1) Notice that setActualSize() is an entry point for parent's layout to set the component size, and it has to be called by parent (container) almost exclusively!

This is because only the parent knows the amount of space available for each child (this method is being called after all children are measured and the container knows it's own given size).

(note: the example of not calling it by layout posted below)

This method exists because if parent would set 'width' and 'height' on children directly, they would immediately turn into fixed size children, and they won't be measured anymore.

Using this method, only the rendering size is being changed - not the (explicit) width and height but _width and _height - meaning if for some reason the container resizes again, the children will be resized by given rules (percentage of the parent, expanding to child component's children size etc.)

2) Yes, because if this method isn't called at all, the component has a (rendering) size of (0, 0), so this is the reason of it's invisibility (not setting 'visible' to false)! ^_^

Note that THERE HAS TO BE A LAYOUT (even a non attractive one) to trigger this method call. By 'non attractive' I consider the layout that isn't supposed to do anything smart, like CHANGE THE WIDTH AND HEIGHT of children at all (like absolute layout)!

Now, look at the PopUpManagerImpl's class addPopUp() method: there is an interesting case of calling setActualSize():

IUIComponent(window).setActualSize(
            IUIComponent(window).getExplicitOrMeasuredWidth(),
            IUIComponent(window).getExplicitOrMeasuredHeight());

Explanation: PopUpManager does stuff that layout should normally do, because it WANTS TO KNOW THE POPUP DIMENSIONS IMMEDIATELY, so it could center the popup on stage. It has no time to wait for the layout pass!

If you comment those 3 lines in the framework code, you'll see that popup is being centered with it's top left corner - just like it's size is (0, 0). Anyway, it is rendered with proper width and height because at rendering time the dimensions are known.

Hope this makes things a bit clearer...

Cheers! ^_^

Danko Kozar

Upvotes: 1

Sunil D.
Sunil D.

Reputation: 18194

The answers to your questions are in the way the Flex component life cycle works, consider these two phases:

measurement: The Flex framework will call the measure() method of your component. You can override this method to set a default and/or minimum size for your component.

Flex components first measure themselves to provide a default and/or minimum size suggestion to the layout/container classes. Flex does this from a bottom up approach, so that the lowest level objects are measured first. Thus when each parent object measures itself, the preferred sizes of it's child objects has been established.

rendering: Later Flex calls the updateDisplayList() method of your component. You can override this to size/position your component's child objects. This is where setActualSize() is intended to be used: the parent calls setActualSize() on it's child objects, not on itself.

Note the method signature of updateDisplayList():

protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void

Measurement was done from the bottom up. However, rendering is done from the top down. So at render time, updateDisplayList(unscaledWidth, unscaledHeight) gets executed on your component. Flex is telling your component the space it has been allotted to render itself, and your component must size/position it's child objects accordingly and/or do programtic drawing.

The sizes passed in to updateDisplayList() are based on various factors:

  • how/if you override the measure() method (measure is not called when your component has a fixed width/height)
  • the types of sizing parameters (fixed, percent, constraint) and layouts that you use

An old but good resource on this topic

Upvotes: 4

Related Questions