/// <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);
 }
Example #6
0
 /// <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);
 }
Example #7
0
 /// <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)
 {
 }
Example #8
0
 public static System.Delegate Remove(object rcw, System.Guid iid, int dispid, System.Delegate d)
 {
     throw new PlatformNotSupportedException(SR.PlatformNotSupported_ComInterop);
 }
Example #9
0
 /// <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)
 {
 }
Example #10
0
 /// <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)
 {
 }
Example #11
0
 /// <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;
	}
Example #14
0
 public virtual object Invoke(System.Delegate method, object[] args)
 {
 }
Example #15
0
 /// <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;
	}
Example #17
0
 /// <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;
 }
Example #19
0
 public static void InvokeOnEventsThread(System.Delegate method)
 {
 }
 public static T ConvertTo <T>(this System.Delegate self)
 {
     return((T)(object)self.ConvertTo(typeof(T)));
 }
Example #21
0
 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)
 {
 }
Example #23
0
 /// <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)
 {
 }
Example #25
0
 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)
 {
 }
Example #27
0
 /// <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)
 {
 }
Example #28
0
 /// <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)
 {
 }
Example #29
0
 /// <summary>
 /// Register a post-processor function.
 /// </summary>
 /// <param name="name">
 /// </param>
 /// <param name="postprocessor">
 /// </param>
 private static void registerPostprocessor(JsString name, System.Delegate postprocessor)
 {
 }
Example #30
0
 public virtual System.IAsyncResult BeginInvoke(System.Delegate method, object[] args)
 {
 }
Example #31
0
 /// <summary>
 /// Constuctor
 /// </summary>
 /// <param name="d"></param>
 public DelegateHolder(System.Delegate d)
 {
     Action = d;
 }
Example #32
0
 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;
 }