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