public KernelEventSupport(SerializationInfo info, StreamingContext context)
{
events = new EventHandlerList();
events[HandlerRegisteredEvent] = (Delegate)
info.GetValue("HandlerRegisteredEvent", typeof(Delegate));
}
public void AddHandlers(EventHandlerList listToAddFrom)
{
for (ListEntry entry = listToAddFrom.head; entry != null; entry = entry.next)
{
this.AddHandler(entry.key, entry.handler);
}
}
public void AddHandlers(EventHandlerList listToAddFrom)
{
for (ListEntry entry = listToAddFrom.head; entry != null; entry = entry.next)
{
this.AddHandler(entry.key, entry.handler);
}
}
/// <summary>
/// Cleans up the COM object references.
/// </summary>
/// <param name="disposing">
/// <see langword="true"/> if this was called from the
/// <see cref="IDisposable"/> interface.
/// </param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_owner = null;
_unmappedEventKeys = null;
if (null != _events)
{
_events.Dispose();
_events = null;
}
}
if (null != _connectionPoint)
{
if (0 != _connectionCookie)
{
_connectionPoint.Unadvise(_connectionCookie);
_connectionCookie = 0;
}
while( Marshal.ReleaseComObject(_connectionPoint) > 0 );
_connectionPoint = null;
}
}
public DeviceContextWpf(DeviceSettings settings)
{
Contract.Requires(settings != null);
Settings = settings;
LogEvent.Engine.Log(settings.ToString());
eventHandlerList = new EventHandlerList();
LogEvent.Engine.Log(Resources.INFO_OE_DeviceCreating);
//SwapChainDescription swapChainDesc = new SwapChainDescription
// {
// BufferCount = 1,
// ModeDescription =
// new ModeDescription(Settings.ScreenWidth, Settings.ScreenHeight,
// new Rational(120, 1), Settings.Format),
// IsWindowed = true,
// OutputHandle =(new System.Windows.Interop.WindowInteropHelper(Global.Window)).Handle,
// SampleDescription = Settings.SampleDescription,
// SwapEffect = SwapEffect.Discard,
// Usage = Usage.RenderTargetOutput,
// };
//LogEvent.Engine.Log(Resources.INFO_OE_DeviceCreating);
//Device.CreateWithSwapChain(DriverType.Hardware, Settings.CreationFlags, swapChainDesc, out device, out swapChain);
device = new Device(DriverType.Hardware, Settings.CreationFlags, FeatureLevel.Level_11_0);
//if (!Settings.IsWindowed)
immediate = device.ImmediateContext;
CreateTargets();
LogEvent.Engine.Log(Resources.INFO_OE_DeviceCreated);
device.ImmediateContext.Flush();
}
public DesignerHost(DesignSurface surface)
{
this._surface = surface;
this._state = new BitVector32();
this._designers = new Hashtable();
this._events = new EventHandlerList();
DesignSurfaceServiceContainer service = this.GetService(typeof(DesignSurfaceServiceContainer)) as DesignSurfaceServiceContainer;
if (service != null)
{
foreach (Type type in DefaultServices)
{
service.AddFixedService(type, this);
}
}
else
{
IServiceContainer container2 = this.GetService(typeof(IServiceContainer)) as IServiceContainer;
if (container2 != null)
{
foreach (Type type2 in DefaultServices)
{
container2.AddService(type2, this);
}
}
}
}
internal DOMObject (WebBrowser control)
{
this.control = control;
IntPtr p = Base.StringInit ();
storage = new HandleRef (this, p);
resources = new Hashtable ();
event_handlers = null;
}
/// <devdoc> allows you to add a list of events to this list </devdoc>
public void AddHandlers(EventHandlerList listToAddFrom) {
ListEntry currentListEntry = listToAddFrom.head;
while (currentListEntry != null) {
AddHandler(currentListEntry.key, currentListEntry.handler);
currentListEntry = currentListEntry.next;
}
}
public AbstractKernelEvents()
{
m_events = new EventHandlerList();
m_service2Key = new Hashtable();
m_dependencyToSatisfy = new Hashtable();
m_proxy2ComponentWrapper = new Hashtable();
InterceptedComponentBuilder = new DefaultInterceptedComponentBuilder();
}
protected void RemoveClickEvent(Button b)
{
System.Reflection.FieldInfo f1 = typeof(Button).GetField("EventClick", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
object obj = f1.GetValue(b);
System.Reflection.PropertyInfo pi = typeof(Button).GetProperty("Events", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
System.ComponentModel.EventHandlerList list = (System.ComponentModel.EventHandlerList)pi.GetValue(b, null);
list.RemoveHandler(obj, list[obj]);
}
public void Add(EventPrivateKey key, Delegate handler)
{
if (_directEventHandlers == null)
{
_directEventHandlers = new EventHandlerList();
}
_directEventHandlers.AddHandler(key, handler);
}
public EventPropertyDescriptor(object component, EventInfo eventInfo, EventHandlerList eventHandlerList)
: base(eventInfo.Name)
{
this.component = component;
this.eventInfo = eventInfo;
this.eventHandlerList = eventHandlerList;
this.converter = new EventInfoConverter(this);
}
public void AddHandlers (EventHandlerList listToAddFrom)
{
if (listToAddFrom == null) {
return;
}
for (ListNode entry = listToAddFrom.head; entry != null; entry = entry.next) {
AddHandler (entry.key, entry.value);
}
}
public BaseFileConfigurationSourceImplementation(string configurationFilepath)
{
this.lockMe = new object();
this.refresh = true;
this.eventHandlersLock = new object();
this.eventHandlers = new EventHandlerList();
this.configurationFilepath = configurationFilepath;
this.watchedConfigSourceMapping = new Dictionary<string, ConfigurationSourceWatcher>();
this.watchedSectionMapping = new Dictionary<string, ConfigurationSourceWatcher>();
}
/// <summary> allows you to add a list of events to this list </summary>
public void AddHandlers(EventHandlerList listToAddFrom)
{
ListEntry currentListEntry = listToAddFrom._head;
while (currentListEntry != null)
{
AddHandler(currentListEntry.key, currentListEntry.handler);
currentListEntry = currentListEntry.next;
}
}
/// <summary>Adds a list of delegates to the current list.</summary>
/// <param name="listToAddFrom">The list to add.</param>
public void AddHandlers(EventHandlerList listToAddFrom)
{
if (listToAddFrom == null)
{
return;
}
for (ListEntry next = listToAddFrom.entries; next != null; next = next.next)
{
this.AddHandler(next.key, next.value);
}
}
/// <include file='CodeDoc\DockContentHandler.xml' path='//CodeDoc/Class[@name="DockContentHandler"]/Constructor[@name="(Form, GetPersistStringDelegate)"]/*'/>
public DockContentHandler(Form form, GetPersistStringDelegate getPersistStringDelegate) {
if (!(form is IDockContent))
throw new ArgumentException();
m_form = form;
m_getPersistStringDelegate = getPersistStringDelegate;
m_events = new EventHandlerList();
Form.Disposed += new EventHandler(Form_Disposed);
Form.TextChanged += new EventHandler(Form_TextChanged);
}
public DockContentHandler(Form form, GetPersistStringCallback getPersistStringCallback) {
if (!(form is IDockContent))
throw new ArgumentException(Strings.DockContent_Constructor_InvalidForm, "form");
m_form = form;
m_getPersistStringCallback = getPersistStringCallback;
m_events = new EventHandlerList();
Form.Disposed += new EventHandler(Form_Disposed);
Form.TextChanged += new EventHandler(Form_TextChanged);
}
public EventSuppressor(Component source)
{
if (source == null)
throw new ArgumentNullException("control", "An instance of a control must be provided.");
_source = source;
_sourceType = _source.GetType();
_sourceEventsInfo = _sourceType.GetProperty("Events", BindingFlags.Instance | BindingFlags.NonPublic);
_sourceEventHandlerList = (EventHandlerList)_sourceEventsInfo.GetValue(_source, null);
_eventHandlerListType = _sourceEventHandlerList.GetType();
_headFI = _eventHandlerListType.GetField("head", BindingFlags.Instance | BindingFlags.NonPublic);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
this.DisconnectFromEvents();
if (this.events != null)
{
this.events.Dispose();
this.events = null;
}
}
}
public DockContentHandler(Form form, GetPersistStringCallback getPersistStringCallback)
{
if (!(form is IDockContent))
throw new ArgumentException(Strings.DockContent_Constructor_InvalidForm, "form");
this._mForm = form;
this.m_getPersistStringCallback = getPersistStringCallback;
(form as DockContent).Size = form.Size;
this._mEvents = new EventHandlerList();
this.Form.Disposed += this.Form_Disposed;
this.Form.TextChanged += this.Form_TextChanged;
}
public UIHierarchy(IServiceProvider serviceProvider, ConfigurationContext configurationContext)
{
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
this.serviceProvider = serviceProvider;
this.configurationContext = configurationContext;
this.configDomain = new ConfigurationDesignManagerDomain(serviceProvider);
nodesByType = new Hashtable(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
nodesById = new Hashtable(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
nodesByName = new Hashtable(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
storageTable = new StorageTable();
handlerList = new EventHandlerList();
}
public void AddHandlers(EventHandlerList listToAddFrom)
{
if (listToAddFrom == null)
{
return;
}
ListEntry entry = listToAddFrom.entries;
while (entry != null)
{
AddHandler(entry.key, entry.value);
entry = entry.next;
}
}
public DeviceContext11(IntPtr handle, DeviceSettings settings)
{
Contract.Requires(handle != IntPtr.Zero);
Contract.Requires(settings != null);
Settings = settings;
LogEvent.Engine.Log(settings.ToString());
eventHandlerList = new EventHandlerList();
SwapChainDescription swapChainDesc = new SwapChainDescription
{
BufferCount = 1,
IsWindowed = Settings.IsWindowed,
ModeDescription =
new ModeDescription{
Width = Settings.ScreenWidth,
Height = Settings.ScreenHeight,
RefreshRate= new Rational(0, 1),
Format = Settings.Format,
Scaling = DisplayModeScaling.Unspecified,
ScanlineOrdering = DisplayModeScanlineOrdering.Unspecified,
},
//new Rational(120, 1), Settings.Format),
OutputHandle = handle,
SampleDescription = Settings.SampleDescription,
Flags = SwapChainFlags.AllowModeSwitch,
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
};
FeatureLevel[] featureLevels = new FeatureLevel[] { FeatureLevel.Level_11_0, FeatureLevel.Level_10_1, FeatureLevel.Level_10_0 };
LogEvent.Engine.Log(Resources.INFO_OE_DeviceCreating);
Device.CreateWithSwapChain(DriverType.Hardware, Settings.CreationFlags, featureLevels, swapChainDesc, out device, out swapChain);
factory = swapChain.GetParent<Factory>();
factory.SetWindowAssociation(handle, WindowAssociationFlags.IgnoreAltEnter | WindowAssociationFlags.IgnoreAll);
immediate = device.ImmediateContext;
CreateTargets();
LogEvent.Engine.Log(Resources.INFO_OE_DeviceCreated);
}
/// <summary>
/// Initialize a new instance of the <see cref="ConfigurationUIHierarchy"/> class.
/// </summary>
/// <param name="rootNode">The root node of the hierarchy.</param>
/// <param name="serviceProvider">The a mechanism for retrieving a service object; that is, an object that provides custom support to other objects.</param>
public ConfigurationUIHierarchy(ConfigurationApplicationNode rootNode, IServiceProvider serviceProvider)
{
if (rootNode == null) throw new ArgumentNullException("rootNode");
if (serviceProvider == null) throw new ArgumentNullException("serviceProvider");
this.storageSerivce = new StorageService();
this.configDomain = new ConfigurationDesignManagerDomain(serviceProvider);
this.serviceProvider = serviceProvider;
nodesByType = new Dictionary<Guid,NodeTypeEntryArrayList>();
nodesById = new Dictionary<Guid, ConfigurationNode>();
nodesByName = new Dictionary<Guid, Dictionary<string, ConfigurationNode>>();
handlerList = new EventHandlerList();
this.rootNode = rootNode;
this.storageSerivce.ConfigurationFile = this.rootNode.ConfigurationFile;
this.rootNode.Renamed += new EventHandler<ConfigurationNodeChangedEventArgs>(OnConfigurationFileChanged);
selectedNode = rootNode;
AddNode(rootNode);
if (null != rootNode.FirstNode) rootNode.UpdateHierarchy(rootNode.FirstNode);
}
/// <summary>
/// Initializes a new instance of the <see cref="FileBasedConfigurationSource"/> class.
/// </summary>
/// <param name="configurationFilepath">The path for the main configuration file.</param>
/// <param name="refresh"><b>true</b>if runtime changes should be refreshed, <b>false</b> otherwise.</param>
/// <param name="refreshInterval">The poll interval in milliseconds.</param>
protected FileBasedConfigurationSource(string configurationFilepath, bool refresh, int refreshInterval)
{
this.configurationFilepath = configurationFilepath;
this.refresh = refresh && !string.IsNullOrEmpty(configurationFilepath);
this.refreshInterval = refreshInterval;
this.refreshLock = new object();
this.eventHandlersLock = new object();
this.eventHandlers = new EventHandlerList();
this.watchersLock = new object();
this.watchedConfigSourceMapping = new Dictionary<string, ConfigurationSourceWatcher>();
this.watchedSectionMapping = new Dictionary<string, ConfigurationSourceWatcher>();
CompositeConfigurationHandler = new CompositeConfigurationSourceHandler(this);
CompositeConfigurationHandler.ConfigurationSectionChanged += new ConfigurationChangedEventHandler(handler_ConfigurationSectionChanged);
CompositeConfigurationHandler.ConfigurationSourceChanged += new EventHandler<ConfigurationSourceChangedEventArgs>(handler_ConfigurationSourceChanged);
HierarchicalConfigurationHandler = new HierarchicalConfigurationSourceHandler(this);
HierarchicalConfigurationHandler.ConfigurationSectionChanged += new ConfigurationChangedEventHandler(handler_ConfigurationSectionChanged);
HierarchicalConfigurationHandler.ConfigurationSourceChanged += new EventHandler<ConfigurationSourceChangedEventArgs>(handler_ConfigurationSourceChanged);
}
/// <summary>
/// Constructs a new PNode.
/// </summary>
/// <Remarks>
/// By default a node's brush is null, and bounds are empty. These values
/// must be set for the node to show up on the screen once it's added to
/// a scene graph.
/// </Remarks>
public PNode() {
bounds = RectangleF.Empty;
fullBoundsCache = RectangleF.Empty;
pickable = true;
childrenPickable = true;
matrix = new PMatrix();
handlers = new EventHandlerList();
Visible = true;
}
static EventManager()
{
events = new EventHandlerList();
}
public Component()
{
event_handlers = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="NuGenDEHEventInitiator"/> class.
/// </summary>
public NuGenDEHEventInitiator(object eventSender, EventHandlerList eventHandlers)
: base(eventSender, eventHandlers)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.Component" /> class. </summary>
public Component()
{
this.event_handlers = null;
}
/// <devdoc>
/// <para>Enables a control to perform final cleanup.</para>
/// </devdoc>
public virtual void Dispose() {
IContainer container = null;
if (Site != null) {
container = (IContainer)Site.GetService(typeof(IContainer));
if (container != null) {
container.Remove(this);
EventHandler disp = Events[EventDisposed] as EventHandler;
if (disp != null)
disp(this, EventArgs.Empty);
}
}
if (_occasionalFields != null) {
_occasionalFields.Dispose();
//do not null out for backwards compat, VSWhidbey 475940
//_occasionalFields = null;
}
if (_events != null) {
_events.Dispose();
_events = null;
}
}
/// <summary>
/// Initialize a new instance of the <see cref="ConfigurationUIHierarchyService"/> class.
/// </summary>
public ConfigurationUIHierarchyService()
{
hierarchies = new Dictionary<Guid,IConfigurationUIHierarchy>();
handlerList = new EventHandlerList();
}
public EventPropertyDescriptor(object component, System.Reflection.EventInfo eventInfo, System.ComponentModel.EventHandlerList eventHandlerList) : base(eventInfo.Name)
{
this.component = component;
this.eventInfo = eventInfo;
this.eventHandlerList = eventHandlerList;
this.converter = new EventInfoConverter(this);
}
void AddEventHandler (object key, EventHandler handler)
{
if (events == null)
events = new EventHandlerList ();
events.AddHandler (key, handler);
}
public void All ()
{
EventHandlerList list = new EventHandlerList ();
string i1 = "i1";
string i2 = "i2";
EventHandler one = new EventHandler (Deleg1);
EventHandler two = new EventHandler (Deleg2);
EventHandler d;
Assertion.AssertEquals ("All #01", null, list [i1]);
Assertion.AssertEquals ("All #02", null, list [i2]);
list.AddHandler (i1, one);
d = list [i1] as EventHandler;
Assertion.Assert ("All #03", d != null);
d (this, EventArgs.Empty);
Assertion.AssertEquals ("All #04", 1, calls);
list.AddHandler (i2, two);
d = list [i1] as EventHandler;
Assertion.Assert ("All #05", d != null);
d (this, EventArgs.Empty);
Assertion.AssertEquals ("All #06", 2, calls);
d = list [i2] as EventHandler;
Assertion.Assert ("All #07", d != null);
d (this, EventArgs.Empty);
Assertion.AssertEquals ("All #08", 4, calls);
list.AddHandler (i2, two);
d = list [i2] as EventHandler;
Assertion.Assert ("All #08", d != null);
d (this, EventArgs.Empty);
Assertion.AssertEquals ("All #09", 16, calls);
list.RemoveHandler (i1, one);
d = list [i1] as EventHandler;
Assertion.Assert ("All #10", d == null);
list.RemoveHandler (i2, two);
d = list [i2] as EventHandler;
Assertion.Assert ("All #11", d != null);
list.RemoveHandler (i2, two);
d = list [i2] as EventHandler;
Assertion.Assert ("All #12", d == null);
list.AddHandler (i1, one);
d = list [i1] as EventHandler;
Assertion.Assert ("All #13", d != null);
list.AddHandler (i2, two);
d = list [i2] as EventHandler;
Assertion.Assert ("All #14", d != null);
list.AddHandler (i1, null);
Assertion.Assert ("All #15", list [i1] != null);
list.AddHandler (i2, null);
Assertion.Assert ("All #16", list [i2] != null);
list.Dispose ();
}
internal ChoicePropertyFilter(
DeviceSpecificChoice choice,
IDeviceSpecificDesigner designer,
ISite site
) {
_events = new EventHandlerList();
_choice = choice;
_site = site;
_designer = designer;
CreateLocalCopiesOfObjects();
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
if (_events != null)
{
_events.Dispose();
_events = null;
}
}
public Sample()
{
Events = new EventHandlerList();
}
public void AddHandlers(EventHandlerList listToAddFrom)
{
throw new NotImplementedException();
}
