public System.Collections.ICollection GetCompatibleMethods(System.ComponentModel.EventDescriptor e) { MethodInfo mi = e.EventType.GetMethod("Invoke"); CodeMemberMethod methodSignature = MonoDevelop.DesignerSupport.BindingService.ReflectionToCodeDomMethod(mi); return(proxy.GetCompatibleMethodsInCodeBehind(methodSignature)); }
internal DataItemEventDescriptor( DataItemTypeDescriptor owner, EventDescriptor parent, Type componentType, Type eventType, Action<object, object> addHandler, Action<object, object> removeHandler ) : base( owner, parent ) { if( componentType == null ) throw new ArgumentNullException( "componentType" ); if( eventType == null ) throw new ArgumentNullException( "eventType" ); if( addHandler == null ) throw new ArgumentNullException( "addHandler" ); if( removeHandler == null ) throw new ArgumentNullException( "removeHandler" ); m_componentType = componentType; m_eventType = eventType; m_addHandler = addHandler; m_removeHandler = removeHandler; }
public int Add(EventDescriptor value) { Contract.Ensures(0 <= Contract.Result<int>()); Contract.Ensures(Contract.Result<int>() <= 2147483646); return default(int); }
protected override ICollection GetCompatibleMethods(EventDescriptor e) { ITypeDefinition definition = loader.GetPrimaryTypeDefinition(); ArrayList compatibleMethods = new ArrayList(); MethodInfo methodInfo = e.EventType.GetMethod("Invoke"); var methodInfoParameters = methodInfo.GetParameters(); foreach (IMethod method in definition.Methods) { if (method.Parameters.Count == methodInfoParameters.Length) { bool found = true; for (int i = 0; i < methodInfoParameters.Length; ++i) { ParameterInfo pInfo = methodInfoParameters[i]; IParameter p = method.Parameters[i]; if (p.Type.ReflectionName != pInfo.ParameterType.ToString()) { found = false; break; } } if (found) { compatibleMethods.Add(method.Name); } } } return compatibleMethods; }
public System.ComponentModel.PropertyDescriptor GetEventProperty(System.ComponentModel.EventDescriptor e) { if (e == null) { throw new ArgumentNullException("e"); } return(new EventPropertyDescriptor(e)); }
protected override bool ShowCode(IComponent component, EventDescriptor edesc, string methodName) { if (formDesigner != null) { formDesigner.ShowSourceCode(component, edesc, methodName); return true; } return false; }
protected DataItemEventDescriptorBase( DataItemTypeDescriptor owner, EventDescriptor parent ) : base( parent ) { if( owner == null ) throw new ArgumentNullException( "owner" ); m_owner = owner; }
ICollection IEventBindingService.GetCompatibleMethods(EventDescriptor e) { if (e == null) { throw new ArgumentNullException("e"); } return this.GetCompatibleMethods(e); }
string IEventBindingService.CreateUniqueMethodName (IComponent component, EventDescriptor eventDescriptor) { if (eventDescriptor == null) throw new ArgumentNullException ("eventDescriptor"); if (component == null) throw new ArgumentNullException ("component"); return this.CreateUniqueMethodName (component, eventDescriptor); }
public ReflectionEventDescriptor (Type componentType, EventDescriptor oldEventDescriptor, Attribute[] attrs) : base (oldEventDescriptor, attrs) { _componentType = componentType; _eventType = oldEventDescriptor.EventType; EventInfo event_info = componentType.GetEvent (oldEventDescriptor.Name); add_method = event_info.GetAddMethod (); remove_method = event_info.GetRemoveMethod (); }
EventDescriptorCollection (EventDescriptor[] events, bool readOnly) { this.isReadOnly = readOnly; if (events == null) return; for (int i = 0; i < events.Length; i++) this.Add (events[i]); }
public int Add(EventDescriptor value) { if (this.readOnly) { throw new NotSupportedException(); } this.EnsureSize(this.eventCount + 1); this.events[this.eventCount++] = value; return (this.eventCount - 1); }
private string GetEventDescriptorHashCode(EventDescriptor eventDesc) { StringBuilder builder = new StringBuilder(eventDesc.Name); builder.Append(eventDesc.EventType.GetHashCode().ToString(CultureInfo.InvariantCulture)); foreach (Attribute attribute in eventDesc.Attributes) { builder.Append(attribute.GetHashCode().ToString(CultureInfo.InvariantCulture)); } return builder.ToString(); }
public string CreateUniqueMethodName (IComponent component, EventDescriptor e) { if (component.Site == null || component.Site.Name == null) throw new ArgumentException ("IComponent must be sited and named"); //TODO: check component.Site.Name is valid as start of method name string trialPrefix = component.Site.Name + "_" + e.Name; return proxy.GenerateIdentifierUniqueInCodeBehind (trialPrefix); }
// Constructors. public EventDescriptorCollection(EventDescriptor[] events) { list = new ArrayList(); if(events != null) { foreach(EventDescriptor descr in events) { list.Add(descr); } } }
/// <devdoc> /// <para> /// Initializes a new instance of the <see cref='System.ComponentModel.EventDescriptorCollection'/> class. /// </para> /// </devdoc> public EventDescriptorCollection(EventDescriptor[] events) { this.events = events; if (events == null) { this.events = new EventDescriptor[0]; this.eventCount = 0; } else { this.eventCount = this.events.Length; } this.eventsOwned = true; }
protected override bool ShowCode(IComponent component, EventDescriptor edesc, string methodName) { // There were reports of an ArgumentNullException caused by edesc==null. // Looking at the .NET code calling this method, this can happen when there are two calls to ShowCode() before the Application.Idle // event gets raised. In that case, ShowCode() already was called for the second set of arguments, and we can safely ignore // the call with edesc==null. if (formDesigner != null && edesc != null) { formDesigner.ShowSourceCode(component, edesc, methodName); return true; } return false; }
private EventDescriptorCollection(EventDescriptor[] events, int eventCount, string[] namedSort, IComparer comparer) { _eventsOwned = false; if (namedSort != null) { _namedSort = (string[])namedSort.Clone(); } _comparer = comparer; _events = events; _eventCount = eventCount; _needSort = true; }
public EventPropertyDescriptor(EventDescriptor eventDesc, IServiceProvider serviceProvider) : base(eventDesc) { _eventDescriptor = eventDesc; _serviceProvider = serviceProvider; FieldInfo eventFieldInfo = _eventDescriptor.ComponentType.GetField(_eventDescriptor.Name + "Event"); if (eventFieldInfo != null) { _eventProperty = eventFieldInfo.GetValue(_eventDescriptor.ComponentType) as DependencyProperty; } }
public ReflectEventDescriptor(Type componentType, EventDescriptor oldReflectEventDescriptor, Attribute[] attributes) : base(oldReflectEventDescriptor, attributes) { this.componentClass = componentType; this.type = oldReflectEventDescriptor.EventType; ReflectEventDescriptor descriptor = oldReflectEventDescriptor as ReflectEventDescriptor; if (descriptor != null) { this.addMethod = descriptor.addMethod; this.removeMethod = descriptor.removeMethod; this.filledMethods = true; } }
/// <summary> /// <para> /// Initializes a new instance of the <see cref='System.ComponentModel.EventDescriptorCollection'/> class. /// </para> /// </summary> public EventDescriptorCollection(EventDescriptor[] events) { if (events == null) { _events = Array.Empty<EventDescriptor>(); } else { _events = events; Count = events.Length; } _eventsOwned = true; }
public override EventDescriptorCollection GetEvents() { var coll = base.GetEvents(); var list = new EventDescriptor[coll.Count]; for (int i = 0; i < coll.Count; i++) if (coll[i].Name == "TextChanged")//instead of TextChanged slip BindingTextChanged for binding list[i] = new FooTextChangedDescriptor(coll[i]); else list[i] = coll[i]; return new EventDescriptorCollection(list); }
private List<Attribute> CopyAttributes(EventDescriptor descriptor, params Type[] exclusions) { List<Attribute> ret = new List<Attribute>(); List<Type> exclusionList = new List<Type>(exclusions); foreach (Attribute att in descriptor.Attributes) { if (!exclusionList.Contains(att.GetType())) { ret.Add(att); } } return ret; }
public System.Collections.ICollection GetCompatibleMethods(System.ComponentModel.EventDescriptor e) { ParameterInfo[] pi = GetEventParameters(e); ArrayList arr = new ArrayList(); foreach (DictionaryEntry de in eventHandlers) { if ((ParameterInfo[])de.Value == pi) { arr.Add(de.Key); } } return(arr.ToArray(typeof(string))); }
internal ValueChangeDataItemPropertyDescriptor( DataItemTypeDescriptor owner, PropertyDescriptor parent, Type componentType, Type propertyType, Func<object, object> getter, Action<object, object> setter, Action<object> resetter, EventDescriptor eventDescriptor ) : base( owner, parent, componentType, propertyType, getter, setter, resetter ) { if( eventDescriptor == null ) throw new ArgumentNullException( "eventDescriptor" ); m_eventDescriptor = eventDescriptor; m_eventProxy = new EventProxy( this, eventDescriptor ); }
public Delegate CreateActionDelegate(Type genericEventHandlerType, EventDescriptor eventDescriptor, BindingContext context) { Type eventArgsType = EventUtil.GetEventArgsType(eventDescriptor); EventHandlerInfo eventHandlerInfo = GetEventHandlerInfo(genericEventHandlerType, eventArgsType); if (eventHandlerInfo != null) { object eventHandler = Activator.CreateInstance( eventHandlerInfo.EventHandlerType, new object[] {context}); return Delegate.CreateDelegate(eventDescriptor.EventType, eventHandler, eventHandlerInfo.EventMethod); } return null; }
public string CreateUniqueMethodName(IComponent component, EventDescriptor e) { if (component.Site == null || component.Site.Name == null) throw new ArgumentException ("IComponent must be sited and named"); //TODO: check component.Site.Name is valid as start of method name string trialPrefix = component.Site.Name + "_" + e.Name; string trialValue = trialPrefix; for (int suffix = 1; suffix <= int.MaxValue; suffix++) { if (!eventHandlers.ContainsKey (trialValue)) return trialValue; trialValue = trialPrefix + suffix.ToString (); } throw new Exception ("Tried method names up to " + trialValue + " and all already existed"); }
public bool ShowCode(System.ComponentModel.IComponent component, System.ComponentModel.EventDescriptor e) { PropertyDescriptor pd = GetEventProperty(e); string name = (string)pd.GetValue(component); if (name == null) { name = CreateUniqueMethodName(component, e); pd.SetValue(component, name); } MethodInfo mi = e.EventType.GetMethod("Invoke"); CodeMemberMethod methodSignature = MonoDevelop.DesignerSupport.BindingService.ReflectionToCodeDomMethod(mi); methodSignature.Name = name; methodSignature.Attributes = MemberAttributes.Family; return(proxy.ShowMethod(methodSignature)); }
public ICollection GetCompatibleMethods(EventDescriptor e) { List<String> compatibleMethods = new List<string>(); IDesignerHost designerHost = _serviceProvider.GetService(typeof(IDesignerHost)) as IDesignerHost; if (designerHost == null || designerHost.RootComponent == null) { return compatibleMethods; } EventInfo eventInfo = e.ComponentType.GetEvent(e.Name); ParameterInfo[] eventParameters = null; if (eventInfo != null) { MethodInfo invokeMethod = eventInfo.EventHandlerType.GetMethod("Invoke"); if (invokeMethod != null) { eventParameters = invokeMethod.GetParameters(); } } if (eventParameters != null) { Type rootType = designerHost.RootComponent.GetType(); MethodInfo[] methods = rootType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); foreach (MethodInfo method in methods) { ParameterInfo[] parameters = method.GetParameters(); if (parameters.Length == eventParameters.Length) { if (IsCandidateMethod(eventParameters, parameters)) { compatibleMethods.Add(method.Name); } } } compatibleMethods.Add("[Clear]"); } return compatibleMethods; }
protected override string CreateUniqueMethodName (IComponent component, EventDescriptor eventDescriptor) { string name = component.Site.Name + eventDescriptor.Name; ICollection compatibleMethodNames = this.GetCompatibleMethods (eventDescriptor); bool interrupt = false; int i = 0; while (!interrupt) { string tmpName = name; foreach (string existingName in compatibleMethodNames) { if (existingName == tmpName) tmpName += i.ToString (); else { name = tmpName; interrupt = true; } } i++; } return null; }
internal void SetDataSource (object new_data_source) { if (changed_event != null) changed_event.RemoveEventHandler (data_source, property_value_changed_handler); data_source = new_data_source; if (property_name != null) { prop_desc = TypeDescriptor.GetProperties (data_source).Find (property_name, true); if (prop_desc == null) return; changed_event = TypeDescriptor.GetEvents (data_source).Find (property_name + "Changed", false); if (changed_event != null) { property_value_changed_handler = new EventHandler (PropertyValueChanged); changed_event.AddEventHandler (data_source, property_value_changed_handler); } } }
string IEventBindingService.CreateUniqueMethodName(IComponent component, EventDescriptor e) { TextBuffer buffer; ICodeBehindDocumentLanguage codeDocumentLanguage = this.GetCodeDocumentLanguage() as ICodeBehindDocumentLanguage; if (codeDocumentLanguage == null) { return string.Empty; } IMultiViewDocumentWindow documentWindow = this.GetDocumentWindow(); CodeView codeView = this.GetCodeView(documentWindow); if (codeView.Text.Length != 0) { buffer = codeView.Buffer; } else { IDocumentWithCode code = base.Component as IDocumentWithCode; buffer = new TextBuffer(code.Code.Text); } return codeDocumentLanguage.GenerateEventHandlerName(buffer, component, e); }
ICollection IEventBindingService.GetCompatibleMethods(EventDescriptor e) { TextBuffer buffer; ICodeBehindDocumentLanguage codeDocumentLanguage = this.GetCodeDocumentLanguage() as ICodeBehindDocumentLanguage; if (codeDocumentLanguage == null) { return new string[0]; } IMultiViewDocumentWindow documentWindow = this.GetDocumentWindow(); CodeView codeView = this.GetCodeView(documentWindow); if (codeView.Text.Length != 0) { buffer = codeView.Buffer; } else { IDocumentWithCode component = base.Component as IDocumentWithCode; buffer = new TextBuffer(component.Code.Text); } return codeDocumentLanguage.GetEventHandlers(buffer, e); }
string ICodeBehindDocumentLanguage.GenerateEventHandlerName(TextBuffer buffer, IComponent component, EventDescriptor eventDescriptor) { bool flag = false; if (buffer == null) { throw new ArgumentNullException("buffer"); } if (component == null) { throw new ArgumentNullException("component"); } if (component.Site == null) { throw new ArgumentException("Invalid component", "component"); } if (eventDescriptor == null) { throw new ArgumentNullException("eventDescriptor"); } string str = component.Site.Name + "_" + eventDescriptor.Name; ArrayList eventHandlers = (ArrayList) ((ICodeBehindDocumentLanguage) this).GetEventHandlers(buffer, eventDescriptor); if (eventHandlers.Count == 0) { return str; } string item = str; int num = 0; do { if (eventHandlers.Contains(item)) { num++; item = str + "_" + num; } } while (!flag); return item; }
//TODO: actually show code and return true if exists public bool ShowCode(System.ComponentModel.IComponent component, System.ComponentModel.EventDescriptor e) { PropertyDescriptor pd = GetEventProperty(e); string name = (string)pd.GetValue(component); if (name == null) { name = CreateUniqueMethodName(component, e); pd.SetValue(component, name); } if (eventHandlers.ContainsKey(name)) { ShowMessage("In an IDE this would show the existing CodeBehind method \"" + name + "\"."); } else { eventHandlers.Add(name, GetEventParameters(e)); ShowMessage("In an IDE this would create and show the CodeBehind method \"" + name + "\"."); } return(true); }
public void Remove(EventDescriptor value) { throw new NotImplementedException(); }
// Insert a descriptor into this collection. public void Insert(int index, EventDescriptor value) { list.Insert(index, value); }
// Remove a descriptor from this collection. public void Remove(EventDescriptor value) { list.Remove(value); }
// Add an descriptor to this collection. public int Add(EventDescriptor value) { return(list.Add(value)); }
public int IndexOf(EventDescriptor value) => Array.IndexOf(_events, value, 0, Count);
public bool Contains(EventDescriptor value) { return(default(bool)); }
public bool Contains(EventDescriptor value) => IndexOf(value) >= 0;
// Get the index of a specific descriptor within the collection. public int IndexOf(EventDescriptor value) { return(list.IndexOf(value)); }
/// <include file='doc\EventDescriptorCollection.uex' path='docs/doc[@for="EventDescriptorCollection.IndexOf"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public int IndexOf(EventDescriptor value) { return(Array.IndexOf(events, value, 0, eventCount)); }
public System.Collections.ICollection GetCompatibleMethods(System.ComponentModel.EventDescriptor e) { MethodInfo mi = e.EventType.GetMethod("Invoke"); return(proxy.GetCompatibleMethodsInCodeBehind(mi)); }
public int IndexOf(EventDescriptor value) { return(Array.IndexOf <EventDescriptor>(this.events, value, 0, this.eventCount)); }
public void Insert(int index, EventDescriptor value) { throw new NotImplementedException(); }
public int IndexOf(EventDescriptor value) { return(default(int)); }
public bool Contains(EventDescriptor value) { return(this.IndexOf(value) >= 0); }
public int IndexOf(EventDescriptor value) { throw new NotImplementedException(); }
public void Remove(EventDescriptor value) { }
public bool Contains(EventDescriptor value) { throw new NotImplementedException(); }
public void Insert(int index, EventDescriptor value) { Contract.Requires(0 <= index); }
public bool InsertComponentEvent(IComponent component, System.ComponentModel.EventDescriptor edesc, string eventMethodName, string body, out string file, out int position) { throw new NotImplementedException(); }
// Determine if this collection contains a particular descriptor. public bool Contains(EventDescriptor value) { return(list.Contains(value)); }