/// <summary>
/// This method is called after all layouts are complete and their calculations flushed
/// to the DOM. No further layouts will be run and this method is only called once per
/// layout run. The base component layout caches lastComponentSize.
/// This is a write phase and DOM reads should be avoided if possible when overridding
/// this method.
/// This method need not be implemented by derived classes and, in fact, should only be
/// implemented when needed.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void finishedLayout(ContextItem ownerContext){}
/// <summary>
/// Queues a ContextItem for the next flush to the DOM. This should only be called by
/// the Ext.layout.ContextItem class.
/// </summary>
/// <param name="item">
/// </param>
private void queueFlush(ContextItem item){}
/// <summary>
/// This method (if implemented) is called after all layouts have completed. In most
/// ways this is similar to completeLayout. This call can cause this (or any
/// layout) to be become invalid (see Ext.layout.Context.invalidate), but this
/// is best avoided. This method is intended to be where final reads are made and so it
/// is best to avoid invalidating layouts at this point whenever possible. Even so, this
/// method can be used to perform final checks that may require all other layouts to be
/// complete and then invalidate some results.
/// This is a read phase and DOM writes should be strictly avoided in derived classes.
/// Instead, DOM writes need to be written to <see cref="Ext.layout.ContextItem">Ext.layout.ContextItem</see> objects to
/// be flushed at the next opportunity.
/// This method need not be implemented by derived classes and, in fact, should only be
/// implemented when needed.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void finalizeLayout(ContextItem ownerContext){}
/// <summary>
/// Invalidates one or more components' layouts (component and container). This can be
/// called before run to identify the components that need layout or during the run to
/// restart the layout of a component. This is called internally to flush any queued
/// invalidations at the start of a cycle. If called during a run, it is not expected
/// that new components will be introduced to the layout.
/// </summary>
/// <param name="components"><p>An array of Components or a single Component.</p>
/// </param>
/// <param name="ownerCtContext"><p>The ownerCt's ContextItem.</p>
/// </param>
/// <param name="full"><p>True if all properties should be invalidated, otherwise only
/// those calculated by the component should be invalidated.</p>
/// </param>
public void invalidate(object components, ContextItem ownerCtContext, bool full){}
/// <summary>
/// Queues a ContextItem to have its Ext.layout.ContextItem.flushAnimations method called.
/// </summary>
/// <param name="item">
/// </param>
private void queueAnimation(ContextItem item){}
/// <summary>
/// Called to perform the calculations for this layout. This method will be called at
/// least once and may be called repeatedly if the done property is cleared
/// before return to indicate that this layout is not yet done. The done property
/// is always set to true before entering this method.
/// This is a read phase and DOM writes should be strictly avoided in derived classes.
/// Instead, DOM writes need to be written to <see cref="Ext.layout.ContextItem">Ext.layout.ContextItem</see> objects to
/// be flushed at the next opportunity.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void calculate(ContextItem ownerContext){}
/// <summary>
/// This method is called after all layouts are complete and their calculations flushed
/// to the DOM. No further layouts will be run and this method is only called once per
/// layout run. The base component layout caches lastComponentSize.
/// This is a write phase and DOM reads should be avoided if possible when overridding
/// this method.
/// This method need not be implemented by derived classes and, in fact, should only be
/// implemented when needed.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void finishedLayout(ContextItem ownerContext)
{
}
/// <summary>
/// Invalidates one or more components' layouts (component and container). This can be
/// called before run to identify the components that need layout or during the run to
/// restart the layout of a component. This is called internally to flush any queued
/// invalidations at the start of a cycle. If called during a run, it is not expected
/// that new components will be introduced to the layout.
/// </summary>
/// <param name="components"><p>An array of Components or a single Component.</p>
/// </param>
/// <param name="ownerCtContext"><p>The ownerCt's ContextItem.</p>
/// </param>
/// <param name="full"><p>True if all properties should be invalidated, otherwise only
/// those calculated by the component should be invalidated.</p>
/// </param>
public void invalidate(object components, ContextItem ownerCtContext, bool full)
{
}
/// <summary>
/// Queues a ContextItem to have its Ext.layout.ContextItem.flushAnimations method called.
/// </summary>
/// <param name="item">
/// </param>
private void queueAnimation(ContextItem item)
{
}
/// <summary>
/// This method (if implemented) is called at the end of the cycle in which this layout
/// completes (by not setting done to false in calculate). It is
/// possible for the layout to complete and yet become invalid before the end of the cycle,
/// in which case, this method will not be called. It is also possible for this method to
/// be called and then later the layout becomes invalidated. This will result in
/// calculate being called again, followed by another call to this method.
/// This is a read phase and DOM writes should be strictly avoided in derived classes.
/// Instead, DOM writes need to be written to <see cref="Ext.layout.ContextItem">Ext.layout.ContextItem</see> objects to
/// be flushed at the next opportunity.
/// This method need not be implemented by derived classes and, in fact, should only be
/// implemented when needed.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void completeLayout(ContextItem ownerContext)
{
}
/// <summary>
/// Returns the ContextItem for an element.
/// </summary>
/// <param name="parent">
/// </param>
/// <param name="el">
/// </param>
public void getEl(ContextItem parent, Ext.dom.Element el)
{
}
/// <summary>
/// Called to perform the calculations for this layout. This method will be called at
/// least once and may be called repeatedly if the done property is cleared
/// before return to indicate that this layout is not yet done. The done property
/// is always set to true before entering this method.
/// This is a read phase and DOM writes should be strictly avoided in derived classes.
/// Instead, DOM writes need to be written to <see cref="Ext.layout.ContextItem">Ext.layout.ContextItem</see> objects to
/// be flushed at the next opportunity.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void calculate(ContextItem ownerContext)
{
}
/// <summary>
/// Called before any calculation cycles to reset DOM values and prepare for calculation.
/// This is a write phase and DOM reads should be strictly avoided when overridding
/// this method.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void beginLayoutCycle(ContextItem ownerContext)
{
}
/// <summary>
/// This method (if implemented) is called after all layouts are finished, and all have
/// a lastComponentSize cached. No further layouts will be run and this method is only
/// called once per layout run. It is the bookend to beginLayout.
/// This is a write phase and DOM reads should be avoided if possible when overridding
/// this method. This is the catch-all tail method to a layout and so the rules are more
/// relaxed. Even so, for performance reasons, it is best to avoid reading the DOM. If
/// a read is necessary, consider implementing a <see cref="Ext.layout.Layout.finalizeLayout">finalizeLayout</see> method to do the
/// required reads.
/// This method need not be implemented by derived classes and, in fact, should only be
/// implemented when needed.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void notifyOwner(ContextItem ownerContext)
{
}
/// <summary>
/// This method (if implemented) is called after all layouts are finished, and all have
/// a lastComponentSize cached. No further layouts will be run and this method is only
/// called once per layout run. It is the bookend to beginLayout.
/// This is a write phase and DOM reads should be avoided if possible when overridding
/// this method. This is the catch-all tail method to a layout and so the rules are more
/// relaxed. Even so, for performance reasons, it is best to avoid reading the DOM. If
/// a read is necessary, consider implementing a <see cref="Ext.layout.Layout.finalizeLayout">finalizeLayout</see> method to do the
/// required reads.
/// This method need not be implemented by derived classes and, in fact, should only be
/// implemented when needed.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void notifyOwner(ContextItem ownerContext){}
/// <summary>
/// Queues a ContextItem for the next flush to the DOM. This should only be called by
/// the Ext.layout.ContextItem class.
/// </summary>
/// <param name="item">
/// </param>
private void queueFlush(ContextItem item)
{
}
/// <summary>
/// Called before any calculation cycles to reset DOM values and prepare for calculation.
/// This is a write phase and DOM reads should be strictly avoided when overridding
/// this method.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void beginLayoutCycle(ContextItem ownerContext){}
/// <summary>
/// Returns the ContextItem for an element.
/// </summary>
/// <param name="parent">
/// </param>
/// <param name="el">
/// </param>
public void getEl(ContextItem parent, Ext.dom.Element el){}
/// <summary>
/// This method (if implemented) is called at the end of the cycle in which this layout
/// completes (by not setting done to false in calculate). It is
/// possible for the layout to complete and yet become invalid before the end of the cycle,
/// in which case, this method will not be called. It is also possible for this method to
/// be called and then later the layout becomes invalidated. This will result in
/// calculate being called again, followed by another call to this method.
/// This is a read phase and DOM writes should be strictly avoided in derived classes.
/// Instead, DOM writes need to be written to <see cref="Ext.layout.ContextItem">Ext.layout.ContextItem</see> objects to
/// be flushed at the next opportunity.
/// This method need not be implemented by derived classes and, in fact, should only be
/// implemented when needed.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void completeLayout(ContextItem ownerContext){}
/// <summary>
/// This method (if implemented) is called after all layouts have completed. In most
/// ways this is similar to completeLayout. This call can cause this (or any
/// layout) to be become invalid (see Ext.layout.Context.invalidate), but this
/// is best avoided. This method is intended to be where final reads are made and so it
/// is best to avoid invalidating layouts at this point whenever possible. Even so, this
/// method can be used to perform final checks that may require all other layouts to be
/// complete and then invalidate some results.
/// This is a read phase and DOM writes should be strictly avoided in derived classes.
/// Instead, DOM writes need to be written to <see cref="Ext.layout.ContextItem">Ext.layout.ContextItem</see> objects to
/// be flushed at the next opportunity.
/// This method need not be implemented by derived classes and, in fact, should only be
/// implemented when needed.
/// </summary>
/// <param name="ownerContext"><p>The context item for the layout's owner
/// component.</p>
/// </param>
public void finalizeLayout(ContextItem ownerContext)
{
}
