/// <summary></summary> /// <param name="config">The configuration options.</param> /// <returns></returns> public extern SplitButton(Ext.Element config);
public Action(Ext.ActionConfig config){}
public Date(Ext.DateConfig config){}
public ProgressBar(Ext.ProgressBarConfig config){}
/// <summary></summary> /// <param name="config">The configuration options.</param> /// <returns></returns> public extern BoxComponent(Ext.Element config);
/// <summary>
/// Removes the docked item from the panel.
/// </summary>
/// <param name="item"><p>. The Component to remove.</p>
/// </param>
/// <param name="autoDestroy"><p>Destroy the component after removal.</p>
/// </param>
public static void removeDocked(Ext.Component item, object autoDestroy=null){}
/// <summary>
/// Changes the data store bound to this LoadMask. ...
/// </summary>
public object bindStore(Ext.data.Store store, object initial){return null;}
/// <summary>
/// Cancels layout of a component.
/// </summary>
/// <param name="comp">
/// </param>
public static void cancelLayout(Ext.Component comp){}
/// <summary>
/// Inserts a Component into this Container at a specified index. Fires the
/// beforeadd event before inserting, then fires the add
/// event after the Component has been inserted.
/// </summary>
/// <param name="index"><p>The index at which the Component will be inserted
/// into the Container's items collection</p>
/// </param>
/// <param name="component"><p>The child Component to insert.</p>
/// <p>Ext uses lazy rendering, and will only render the inserted Component should
/// it become necessary.</p>
/// <p>A Component config object may be passed in order to avoid the overhead of
/// constructing a real Component object if lazy rendering might mean that the
/// inserted Component will not be rendered immediately. To take advantage of
/// this 'lazy instantiation', set the <see cref="Ext.ComponentConfig.xtype">Ext.Component.xtype</see> config
/// property to the registered type of the Component wanted.</p>
/// <p>For a list of all available xtypes, see <see cref="Ext.Component">Ext.Component</see>.</p>
/// </param>
/// <returns>
/// <span><see cref="Ext.Component">Ext.Component</see></span><div><p>component The Component (or config object) that was
/// inserted with the Container's default config values applied.</p>
/// </div>
/// </returns>
public static Ext.Component insert(JsNumber index, Ext.Component component){return null;}
/// <summary>
/// Binds listeners for this component to the store. By default it will add
/// anything bound by the getStoreListeners method, however it can be overridden
/// in a subclass to provide any more complicated handling.
/// </summary>
/// <param name="store"><p>The store to bind to</p>
/// </param>
public virtual void bindStoreListeners(Ext.data.AbstractStore store){}
/// <summary>
/// Invoked after the Container has laid out (and rendered if necessary)
/// its child Components.
/// <p>This is a <i>template method</i>.
/// a hook into the functionality of this class.
/// Feel free to override it in child classes.</p>
/// </summary>
/// <param name="layout">
/// </param>
protected static void afterLayout(Ext.layout.container.Container layout){}
/// <summary>
/// Changes the data store bound to this LoadMask.
/// </summary>
/// <param name="store"><p>The store to bind to this LoadMask</p>
/// </param>
public void bindStore(Ext.data.Store store){}
/// <summary>
/// Creates new LoadMask.
/// </summary>
/// <param name="comp"><p>The Component you wish to mask. The the mask will be automatically sized
/// upon Component resize, and the message box will be kept centered.</p><p>
/// </param>
/// <param name="config"><p>The config object</p>
/// </param>
/// <returns>
/// <span><see cref="Object">Object</see></span><div>
/// </div>
/// </returns>
public LoadMask(Ext.Component comp, object config=null){}
/// <summary>
/// Template method, it is called when an existing store is unbound
/// from the current instance.
/// </summary>
/// <param name="store"><p>The store being unbound</p>
/// </param>
/// <param name="initial"><p>True if this store is being bound as initialization of the instance.</p>
/// </param>
public virtual void onUnbindStore(Ext.data.AbstractStore store, bool initial){}
/// <summary>
/// This method is invoked after a new Component has been
/// removed. It is passed the Component which has been
/// removed. This method may be used to update any internal
/// structure which may depend upon the state of the child items.
/// <p>This is a <i>template method</i>.
/// a hook into the functionality of this class.
/// Feel free to override it in child classes.</p>
/// </summary>
/// <param name="component">
/// </param>
/// <param name="autoDestroy">
/// </param>
protected static void onRemove(Ext.Component component, bool autoDestroy){}
/// <summary>
/// Determines whether this Container is an ancestor of the passed Component.
/// This will return true if the passed Component is anywhere within the subtree
/// beneath this Container.
/// </summary>
/// <param name="possibleDescendant"><p>The Component to test for presence
/// within this Container's subtree.</p>
/// </param>
public static void isAncestor(Ext.Component possibleDescendant){}
/// <summary>
/// Template method called when this Component's DOM structure is created.
/// At this point, this Component's (and all descendants') DOM structure <em>exists</em> but it has not
/// been layed out (positioned and sized).
/// Subclasses which override this to gain access to the structure at render time should
/// call the parent class's method before attempting to access any child elements of the Component.
/// <p>This is a <i>template method</i>.
/// a hook into the functionality of this class.
/// Feel free to override it in child classes.</p>
/// </summary>
/// <param name="parentNode"><p>The parent Element in which this Component's encapsulating element is contained.</p>
/// </param>
/// <param name="containerIdx"><p>The index within the parent Container's child collection of this Component.</p>
/// </param>
protected static void onRender(Ext.dom.Element parentNode, JsNumber containerIdx){}
/// <summary>
/// Determines whether this component is the descendant of a particular container.
/// </summary>
/// <param name="container">
/// </param>
/// <returns>
/// <span><see cref="bool">Boolean</see></span><div><p>True if it is.</p>
/// </div>
/// </returns>
public static bool isDescendantOf(Ext.container.Container container){return false;}
public MessageBox(Ext.MessageBoxConfig config){}
/// <summary>
/// This method is invoked after a new Component has been added. It
/// is passed the Component which has been added. This method may
/// be used to update any internal structure which may depend upon
/// the state of the child items.
/// <p>This is a <i>template method</i>.
/// a hook into the functionality of this class.
/// Feel free to override it in child classes.</p>
/// </summary>
/// <param name="component">
/// </param>
/// <param name="position">
/// </param>
protected static void onAdd(Ext.Component component, JsNumber position){}
/// <summary>
/// Fires after a component becomes focused.
/// </summary>
/// <param name="fm"><p>A reference to the FocusManager singleton</p>
/// </param>
/// <param name="cmp"><p>The component that has been focused</p>
/// </param>
/// <param name="previousCmp"><p>The component that was previously focused,
/// or <c>undefined</c> if there was no previously focused component.</p>
/// </param>
/// <param name="eOpts"><p>The options object passed to <see cref="Ext.util.Observable.addListener">Ext.util.Observable.addListener</see>.</p>
/// </param>
public void componentfocus(FocusManager fm, Ext.Component cmp, Ext.Component previousCmp, object eOpts){}
/// <summary>
/// Method to manage awareness of when components are added to their
/// respective Container, firing an added event. References are
/// established at add time rather than at render time.
/// Allows addition of behavior when a Component is added to a
/// Container. At this stage, the Component is in the parent
/// Container's collection of child items. After calling the
/// superclass's onAdded, the ownerCt reference will be present,
/// and if configured with a ref, the refOwner will be set.
/// <p>This is a <i>template method</i>.
/// a hook into the functionality of this class.
/// Feel free to override it in child classes.</p>
/// </summary>
/// <param name="container"><p>Container which holds the component</p>
/// </param>
/// <param name="pos"><p>Position at which the component was added</p>
/// </param>
protected static void onAdded(Ext.container.Container container, JsNumber pos){}
/// <summary>
/// Fires after each update interval
/// </summary>
/// <param name="this">
/// </param>
/// <param name="value"><p>The current progress value</p>
/// </param>
/// <param name="text"><p>The current progress text</p>
/// </param>
/// <param name="eOpts"><p>The options object passed to <see cref="Ext.util.Observable.addListener">Ext.util.Observable.addListener</see>.</p>
/// </param>
public void update(Ext.ProgressBar @this, JsNumber value, JsString text, object eOpts){}
/// <summary>
/// This method is invoked before adding a new child Component. It
/// is passed the new Component, and may be used to modify the
/// Component, or prepare the Container in some way. Returning
/// false aborts the add operation.
/// <p>This is a <i>template method</i>.
/// a hook into the functionality of this class.
/// Feel free to override it in child classes.</p>
/// </summary>
/// <param name="item">
/// </param>
protected static void onBeforeAdd(Ext.Component item){}
/// <summary>
/// Registers an association where one of the models defined doesn't exist yet.
/// The ModelManager will check when new models are registered if it can link them
/// together
/// </summary>
/// <param name="association"><p>The association</p>
/// </param>
private static void registerDeferredAssociation(Ext.data.association.Association association){}
/// <summary>
/// Invoked after a docked item is added to the Panel.
/// <p>This is a <i>template method</i>.
/// a hook into the functionality of this class.
/// Feel free to override it in child classes.</p>
/// </summary>
/// <param name="component">
/// </param>
protected static void onDockedAdd(Ext.Component component){}
public Array( Ext.ArrayConfig config ) { }
/// <summary>
/// Invoked after a docked item is removed from the Panel.
/// <p>This is a <i>template method</i>.
/// a hook into the functionality of this class.
/// Feel free to override it in child classes.</p>
/// </summary>
/// <param name="component">
/// </param>
protected static void onDockedRemove(Ext.Component component){}
public Template(Ext.TemplateConfig config){}
/// <summary>
/// The init method is invoked after initComponent method has been run for the client Component.
/// The supplied implementation is empty. Subclasses should perform plugin initialization, and set up bidirectional
/// links between the plugin and its client Component in their own implementation of this method.
/// </summary>
/// <param name="client"><p>The client Component which owns this plugin.</p>
/// </param>
public void init(Ext.Component client){}
