/// <summary>
/// Creates new instance of the T object.
/// </summary>
/// <returns>New T instance.</returns>
protected virtual T OnCreateNew()
{
AddingNewEventHandler eventHandler = AddingNew;
if (eventHandler == null)
{
if (default(T) == null)
{
return(Activator.CreateInstance <T>());
}
else
{
return(default(T));
}
}
AddingNewEventArgs eventArgs = new AddingNewEventArgs();
eventHandler(this, eventArgs);
if (eventArgs.NewObject == null)
{
return(Activator.CreateInstance <T>());
}
UndoRedoWrapper wrapper = eventArgs.NewObject as UndoRedoWrapper;
if (wrapper != null)
{
return((T)wrapper.Instance);
}
return((T)eventArgs.NewObject);
}
public void AddingNew_RemoveWithNotAllowNewByDefault_CallsListChanged()
{
var bindingList = new BindingList <string>();
bool calledAddingNew = false;
AddingNewEventHandler handler = (object sender, AddingNewEventArgs e) => calledAddingNew = true;
bindingList.AddingNew += handler;
bool calledListChanged = false;
bindingList.ListChanged += (object sender, ListChangedEventArgs e) =>
{
calledListChanged = true;
Assert.Equal(ListChangedType.Reset, e.ListChangedType);
Assert.Equal(-1, e.NewIndex);
};
// Make sure removing the handler was successful.
bindingList.AddingNew -= handler;
Assert.True(calledListChanged);
Assert.Throws <MissingMethodException>(() => bindingList.AddNew());
Assert.False(calledAddingNew);
}
/// <summary>
/// Raises the <see cref="AddingNew"/> event.
/// </summary>
/// <param name="e">The <see cref="AddingNewEventArgs"/> instance containing the event data.</param>
protected virtual void OnAddingNew(AddingNewEventArgs e)
{
AddingNewEventHandler handler = _addingNew;
if (handler != null)
{
handler(this, e);
}
}
protected virtual void OnAddingNew(AddingNewEventArgs e)
{
AddingNewEventHandler eh = (AddingNewEventHandler)Events[AddingNewEvent];
if (eh != null)
{
eh(this, e);
}
}
protected virtual void OnAddingNew(AddingNewEventArgs e)
{
AddingNewEventHandler addingNewEventHandler = this._addingNew;
if (addingNewEventHandler != null)
{
addingNewEventHandler(this, e);
}
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// addingneweventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this AddingNewEventHandler addingneweventhandler, Object sender, AddingNewEventArgs e, AsyncCallback callback)
{
if (addingneweventhandler == null)
{
throw new ArgumentNullException("addingneweventhandler");
}
return(addingneweventhandler.BeginInvoke(sender, e, callback, null));
}
// Token: 0x060011CB RID: 4555 RVA: 0x000579DC File Offset: 0x00055BDC
protected virtual void tmethod_3192(AddingNewEventArgs arg_0)
{
AddingNewEventHandler addingNewEventHandler = this.field_1;
if (addingNewEventHandler != null)
{
addingNewEventHandler(this, arg_0);
}
}
// Token: 0x06001243 RID: 4675 RVA: 0x00063F24 File Offset: 0x00062124
protected virtual void OnAddingNew(AddingNewEventArgs e)
{
AddingNewEventHandler addingNew = this._addingNew;
if (addingNew == null)
{
return;
}
addingNew(this, e);
}
public void Add(T item)
{
PreProcess(item);
items.Add(item);
AddingNewEventHandler addingNew = this.AddingNew;
if (addingNew != null)
{
addingNew(this, new AddingNewEventArgs(item));
}
}
public VarietyItemsBindingSource(IContainer container)
: base(container)
{
AllowNew = true;
AddingNew += new AddingNewEventHandler(VarietyItemsBindingSource_AddingNew);
if (DesignMode)
{
DataSource = typeof(CropParameterItem);
}
else
{
DataSource = ProjectFile.This.FileContainer.VarietyFile.Items;
}
}
public void TestInterfaceProxyEvent()
{
Duck duck = new Duck();
IInterface proxy = DuckTyping.Cast <IInterface>(duck);
object sender = this;
AddingNewEventArgs e = new AddingNewEventArgs();
EventHandler eventHandler = new EventHandler(this.EventHandlerMethod);
AddingNewEventHandler addingNewEventHandler = new AddingNewEventHandler(this.AddingNewEventHandlerMethod);
m_Sender = null;
m_EventArgs = null;
proxy.Event += eventHandler;
duck.RaiseEvent(sender, e);
Assert.AreEqual(sender, m_Sender, "Proxy class did not properly forward adding of an event handler.");
m_Sender = null;
m_EventArgs = null;
proxy.Event -= eventHandler;
duck.RaiseEvent(sender, e);
Assert.IsNull(m_Sender, "Proxy class did not properly forward removing of an event handler.");
m_Sender = null;
m_EventArgs = null;
proxy.CovariantEvent += addingNewEventHandler;
duck.RaiseCovariantEvent(sender, e);
Assert.AreEqual(sender, m_Sender, "Proxy class did not properly forward adding of an event handler to a covariant event.");
m_Sender = null;
m_EventArgs = null;
proxy.CovariantEvent -= addingNewEventHandler;
duck.RaiseCovariantEvent(sender, e);
Assert.IsNull(m_Sender, "Proxy class did not properly forward removing of an event handler from a covariant event.");
m_Sender = null;
m_EventArgs = null;
proxy.ContravariantEvent += eventHandler;
duck.RaiseContravariantEvent(sender, e);
Assert.AreEqual(sender, m_Sender, "Proxy class did not properly forward adding of an event handler to a contravariant event.");
m_Sender = null;
m_EventArgs = null;
proxy.ContravariantEvent -= eventHandler;
duck.RaiseContravariantEvent(sender, e);
Assert.IsNull(m_Sender, "Proxy class did not properly forward removing of an event handler from a contravariant event.");
}
public void AddingNew_RemoveWithAllowNewByDefault_Success()
{
var bindingList = new BindingList <int>();
bool calledAddingNew = false;
AddingNewEventHandler handler = (object sender, AddingNewEventArgs e) => calledAddingNew = true;
bindingList.AddingNew += handler;
bool calledListChanged = false;
bindingList.ListChanged += (object sender, ListChangedEventArgs e) => calledListChanged = true;
// Make sure removing the handler was successful.
bindingList.AddingNew -= handler;
Assert.False(calledListChanged);
bindingList.AddNew();
Assert.False(calledAddingNew);
// Make sure removing multiple times is a nop.
bindingList.AddingNew -= handler;
}
public void TestInterfaceProxyEvent()
{
Duck duck = new Duck();
IInterface proxy = DuckTyping.Cast<IInterface>(duck);
object sender = this;
AddingNewEventArgs e = new AddingNewEventArgs();
EventHandler eventHandler = new EventHandler(this.EventHandlerMethod);
AddingNewEventHandler addingNewEventHandler = new AddingNewEventHandler(this.AddingNewEventHandlerMethod);
m_Sender = null;
m_EventArgs = null;
proxy.Event += eventHandler;
duck.RaiseEvent(sender, e);
Assert.AreEqual(sender, m_Sender, "Proxy class did not properly forward adding of an event handler.");
m_Sender = null;
m_EventArgs = null;
proxy.Event -= eventHandler;
duck.RaiseEvent(sender, e);
Assert.IsNull(m_Sender, "Proxy class did not properly forward removing of an event handler.");
m_Sender = null;
m_EventArgs = null;
proxy.CovariantEvent += addingNewEventHandler;
duck.RaiseCovariantEvent(sender, e);
Assert.AreEqual(sender, m_Sender, "Proxy class did not properly forward adding of an event handler to a covariant event.");
m_Sender = null;
m_EventArgs = null;
proxy.CovariantEvent -= addingNewEventHandler;
duck.RaiseCovariantEvent(sender, e);
Assert.IsNull(m_Sender, "Proxy class did not properly forward removing of an event handler from a covariant event.");
m_Sender = null;
m_EventArgs = null;
proxy.ContravariantEvent += eventHandler;
duck.RaiseContravariantEvent(sender, e);
Assert.AreEqual(sender, m_Sender, "Proxy class did not properly forward adding of an event handler to a contravariant event.");
m_Sender = null;
m_EventArgs = null;
proxy.ContravariantEvent -= eventHandler;
duck.RaiseContravariantEvent(sender, e);
Assert.IsNull(m_Sender, "Proxy class did not properly forward removing of an event handler from a contravariant event.");
}
