/// <summary> /// AddEventHandler /// </summary> protected override void AddEventHandler(System.Reflection.EventInfo eventInfo, object target, System.Delegate handler) { eventInfo.AddEventHandler(target, handler); }
public object Invoke(System.Delegate method) { }
/// <summary> /// Cascades down the tree from this node, calling the specified function with each node. The arguments to the function /// will be the args provided or the current node. If the function returns false at any point, /// the cascade is stopped on that branch. /// </summary> /// <param name="fn"><p>The function to call</p> /// </param> /// <param name="scope"><p>The scope (this reference) in which the function is executed. Defaults to the current Node.</p> /// </param> /// <param name="args"><p>The args to call the function with. Defaults to passing the current Node.</p> /// </param> public void cascadeBy(System.Delegate fn, object scope = null, object args = null) { }
/// <summary> /// Finds the first child by a custom function. The child matches if the function passed returns true. /// </summary> /// <param name="fn"><p>A function which must return true if the passed Node is the required Node.</p> /// </param> /// <param name="scope"><p>The scope (this reference) in which the function is executed. Defaults to the Node being tested.</p> /// </param> /// <param name="deep"><p>True to search through nodes deeper than the immediate children</p> /// <p>Defaults to: <c>false</c></p></param> /// <returns> /// <span><see cref="Ext.data.NodeInterface">Ext.data.NodeInterface</see></span><div><p>The found child or null if none was found</p> /// </div> /// </returns> public NodeInterface findChildBy(System.Delegate fn, object scope = null, object deep = null) { return(null); }
public void RegisterProcessHandler(string name, System.Delegate handler) { ProcessHandlers.Add(name, handler); }
/// <summary> /// Displays a standard read-only message box with an OK button (comparable to the basic JavaScript alert prompt). ... /// </summary> public MessageBox alert(JsString title, JsString msg, System.Delegate fn = null) { return(null); }
/// <summary> /// Creates new MixedCollection. /// </summary> /// <param name="allowFunctions"><p>Specify <tt>true</tt> if the <see cref="Ext.util.MixedCollection.addAll">addAll</see> /// function should add function references to the collection. Defaults to /// <tt>false</tt>.</p> /// </param> /// <param name="keyFn"><p>A function that can accept an item of the type(s) stored in this MixedCollection /// and return the key value for that item. This is used when available to look up the key on items that /// were passed without an explicit key parameter to a MixedCollection method. Passing this parameter is /// equivalent to providing an implementation for the <see cref="Ext.util.MixedCollection.getKey">getKey</see> method.</p> /// </param> /// <returns> /// <span><see cref="Object">Object</see></span><div> /// </div> /// </returns> public MixedCollection(bool allowFunctions, System.Delegate keyFn) { }
public static System.Delegate Remove(object rcw, System.Guid iid, int dispid, System.Delegate d) { throw new PlatformNotSupportedException(SR.PlatformNotSupported_ComInterop); }
/// <summary> /// Sorts the collection by a single sorter function /// </summary> /// <param name="sorterFn"><p>The function to sort by</p> /// </param> public void sortBy(System.Delegate sorterFn) { }
/// <summary> /// Sorts this collection by keys. /// </summary> /// <param name="direction"><p>'ASC' or 'DESC'. Defaults to 'ASC'.</p> /// </param> /// <param name="fn"><p>Comparison function that defines the sort order. /// Defaults to sorting by case insensitive string.</p> /// </param> public void sortByKey(object direction = null, System.Delegate fn = null) { }
/// <summary> /// Removes items in the childEls array based on the return value of a supplied test /// function. The function is called with a entry in childEls and if the test function /// return true, that entry is removed. If false, that entry is kept. /// </summary> /// <param name="testFn"><p>The test function.</p> /// </param> public virtual void removeChildEls(System.Delegate testFn) { }
/// <summary> /// This event is fired through the GridView. Add listeners to the GridView object /// Fired when a drop gesture has been triggered by a mouseup event in a valid drop position in the GridView. /// </summary> /// <param name="node"><p>The GridView node <strong>if any</strong> over which the mouse was positioned.</p> /// <p>Returning <c>false</c> to this event signals that the drop gesture was invalid, and if the drag proxy will animate /// back to the point from which the drag began.</p> /// <p>Returning <c>0</c> To this event signals that the data transfer operation should not take place, but that the gesture /// was valid, and that the repair operation should not take place.</p> /// <p>Any other return value continues with the data transfer operation.</p> /// </param> /// <param name="data"><p>The data object gathered at mousedown time by the cooperating <see cref="Ext.dd.DragZone">DragZone</see>'s <see cref="Ext.dd.DragZone.getDragData">getDragData</see> method it contains the following properties:</p> /// <ul> /// <li><p>copy : Boolean</p> /// <p>The value of the GridView's <c>copy</c> property, or <c>true</c> if the GridView was configured with <c>allowCopy: true</c> and /// the control key was pressed when the drag operation was begun</p></li> /// <li><p>view : GridView</p> /// <p>The source GridView from which the drag originated.</p></li> /// <li><p>ddel : HtmlElement</p> /// <p>The drag proxy element which moves with the mouse</p></li> /// <li><p>item : HtmlElement</p> /// <p>The GridView node upon which the mousedown event was registered.</p></li> /// <li><p>records : Array</p> /// <p>An Array of <see cref="Ext.data.Model">Model</see>s representing the selected data being dragged from the source GridView.</p></li> /// </ul> /// </param> /// <param name="overModel"><p>The Model over which the drop gesture took place.</p> /// </param> /// <param name="dropPosition"><p><c>"before"</c> or <c>"after"</c> depending on whether the mouse is above or below the midline /// of the node.</p> /// </param> /// <param name="dropFunction"><p>A function to call to complete the data transfer operation and either move or copy Model instances from the /// source View's Store to the destination View's Store.</p> /// <p>This is useful when you want to perform some kind of asynchronous processing before confirming the drop, such as /// an <see cref="Ext.window.MessageBox.confirm">confirm</see> call, or an Ajax request.</p> /// <p>Return <c>0</c> from this event handler, and call the <c>dropFunction</c> at any time to perform the data transfer.</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 beforedrop(object node, object data, Ext.data.Model overModel, JsString dropPosition, System.Delegate dropFunction, object eOpts) { }
public OCDelegate Initialize(SerializationInfo info, StreamingContext context) { Type delType = (Type)info.GetValue("delegateType", typeof(Type)); //If it's a "simple" delegate we just read it straight off if(info.GetBoolean("isSerializable")) { _Delegate = (Delegate)info.GetValue("delegate", delType); _Name = _Delegate.Method.Name; } //otherwise, we need to read its anonymous class else { MethodInfo method = (MethodInfo)info.GetValue("method", typeof(MethodInfo)); OCAnonymousClassWrapper w = (OCAnonymousClassWrapper)info.GetValue("class", typeof(OCAnonymousClassWrapper)); _Delegate = Delegate.CreateDelegate(delType, w.obj, method); _Name = _Delegate.Method.Name; } return this; }
public virtual object Invoke(System.Delegate method, object[] args) { }
/// <summary> /// Performs the actual sorting based on a direction and a sorting function. Internally, /// this creates a temporary array of all items in the MixedCollection, sorts it and then writes /// the sorted array data back into this.items and this.keys /// </summary> /// <param name="property"><p>Property to sort by ('key', 'value', or 'index')</p> /// </param> /// <param name="dir"><p>Direction to sort 'ASC' or 'DESC'. Defaults to 'ASC'.</p> /// </param> /// <param name="fn"><p>Comparison function that defines the sort order. /// Defaults to sorting by numeric value.</p> /// </param> private void _sort(JsString property, object dir = null, System.Delegate fn = null) { }
//--------------------------------------------------------------------------- #endregion //--------------------------------------------------------------------------- #region Public Member Functions //--------------------------------------------------------------------------- public OCDelegate Initialize(Delegate del) { _Delegate = del; _Name = del.Method.Name; return this; }
/// <summary> /// A utility for grouping a set of modifications which may trigger value changes into a single transaction, to /// prevent excessive firing of change events. This is useful for instance if the field has sub-fields which /// are being updated as a group; you don't want the container field to check its own changed state for each subfield /// change. /// </summary> /// <param name="fn"><p>A function containing the transaction code</p> /// </param> public virtual void batchChanges(System.Delegate fn) { }
public static System.Diagnostics.RemoteExecutorTestBase.RemoteInvokeHandle RemoteInvokeRaw(System.Delegate method, string unparsedArg, System.Diagnostics.RemoteInvokeOptions options = null) { throw null; }
public static void InvokeOnEventsThread(System.Delegate method) { }
public static T ConvertTo <T>(this System.Delegate self) { return((T)(object)self.ConvertTo(typeof(T))); }
public static DelegateAssertions Should(this System.Delegate instance) { return(new DelegateAssertions(instance, new AggregateExceptionExtractor())); }
/// <summary> /// Bubbles up the tree from this node, calling the specified function with each node. The arguments to the function /// will be the args provided or the current node. If the function returns false at any point, /// the bubble is stopped. /// </summary> /// <param name="fn"><p>The function to call</p> /// </param> /// <param name="scope"><p>The scope (this reference) in which the function is executed. Defaults to the current Node.</p> /// </param> /// <param name="args"><p>The args to call the function with. Defaults to passing the current Node.</p> /// </param> public void bubble(System.Delegate fn, object scope = null, object args = null) { }
/// <summary> /// /// </summary> /// <param name="managedDelegate"></param> /// <param name="shouldDispose"></param> public UnmanagedFunction(System.Delegate managedDelegate, bool shouldDispose = true) : base(managedDelegate, shouldDispose) { }
/// <summary> /// Interates the child nodes of this node, calling the specified function with each node. The arguments to the function /// will be the args provided or the current node. If the function returns false at any point, /// the iteration stops. /// </summary> /// <param name="fn"><p>The function to call</p> /// </param> /// <param name="scope"><p>The scope (this reference) in which the function is executed. Defaults to the current Node in iteration.</p> /// </param> /// <param name="args"><p>The args to call the function with. Defaults to passing the current Node.</p> /// </param> public void eachChild(System.Delegate fn, object scope = null, object args = null) { }
internal FunctionPointerAllocation(bool shouldDispose, System.Delegate managedDelegate) : this(shouldDispose) { InstructionPointer = managedDelegate.Method.MethodHandle.GetFunctionPointer(); }
/// <summary> /// Sorts this nodes children using the supplied sort function. /// </summary> /// <param name="fn"><p>A function which, when passed two Nodes, returns -1, 0 or 1 depending upon required sort order.</p> /// </param> /// <param name="recursive"><p>True to apply this sort recursively</p> /// <p>Defaults to: <c>false</c></p></param> /// <param name="suppressEvent"><p>True to not fire a sort event.</p> /// <p>Defaults to: <c>false</c></p></param> public void sort(System.Delegate fn, object recursive = null, object suppressEvent = null) { }
/// <summary> /// Parameters<li><span>fn</span> : <see cref="Object">Object</see><div> /// </div></li><li><span>scope</span> : <see cref="Object">Object</see><div> /// </div></li><li><span>className</span> : <see cref="Object">Object</see><div> /// </div></li> /// </summary> /// <param name="fn"> /// </param> /// <param name="scope"> /// </param> /// <param name="className"> /// </param> private static void onCreated(System.Delegate fn, object scope, object className) { }
/// <summary> /// Iterates through an object and invokes the given callback function for each iteration. /// The iteration can be stopped by returning false in the callback function. For example: /// <code>var person = { /// name: 'Jacky' /// hairColor: 'black' /// loves: ['food', 'sleeping', 'wife'] /// }; /// <see cref="Ext.Object.each">Ext.Object.each</see>(person, function(key, value, myself) { /// console.log(key + ":" + value); /// if (key === 'hairColor') { /// return false; // stop the iteration /// } /// }); /// </code> /// </summary> /// <param name="object"><p>The object to iterate</p> /// </param> /// <param name="fn"><p>The callback function.</p> /// <h3>Parameters</h3><ul><li><span>key</span> : <see cref="String">String</see><div></div></li><li><span>value</span> : <see cref="Object">Object</see><div></div></li><li><span>object</span> : <see cref="Object">Object</see><div><p>The object itself</p> /// </div></li></ul></param> /// <param name="scope"><p>The execution scope (<c>this</c>) of the callback function</p> /// </param> public static void each(object @object, System.Delegate fn, object scope = null) { }
/// <summary> /// Register a post-processor function. /// </summary> /// <param name="name"> /// </param> /// <param name="postprocessor"> /// </param> private static void registerPostprocessor(JsString name, System.Delegate postprocessor) { }
public virtual System.IAsyncResult BeginInvoke(System.Delegate method, object[] args) { }
/// <summary> /// Constuctor /// </summary> /// <param name="d"></param> public DelegateHolder(System.Delegate d) { Action = d; }
public System.IAsyncResult BeginInvoke(System.Delegate method) { }
/// <summary> /// Initializes a new instance of the Subscription struct. /// </summary> /// <param name="eventDelegate">The event delegate.</param> /// <param name="eventKey">The event key.</param> public Subscription(System.Delegate eventDelegate, object eventKey) : this() { EventDelegate = eventDelegate; EventKey = eventKey; }