/// <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) { }