private CodeDomDelegateMetadata(CodeDelegate2 codeDelegate, CodeDomFileMetadata file)
{
this.codeDelegate = codeDelegate;
this.file = file;
}
internal static IDelegateMetadata FromCodeDelegate(CodeDelegate2 codeElement, CodeDomFileMetadata file)
{
return new CodeDomDelegateMetadata(codeElement, file);
}
private CodeDomDelegateMetadata(CodeDelegate2 codeDelegate, CodeDomFileMetadata file)
{
this.codeDelegate = codeDelegate;
this.file = file;
}
internal static IDelegateMetadata FromCodeDelegate(CodeDelegate2 codeElement, CodeDomFileMetadata file)
{
return(new CodeDomDelegateMetadata(codeElement, file));
}
public static ITypeMetadata FromCodeElement(CodeDelegate2 codeVariable, CodeDomFileMetadata file)
{
return GetType(codeVariable, file);
}
private void AddEvent(Project currentAssembly,
CodeTypeDeclaration proxyClass, CodeClass interopFormClass,
CodeEvent evt, CodeTypeDeclaration proxyClassEventSinkInterface)
{
CodeDelegate2 delegate1 = null;
try
{
delegate1 = (CodeDelegate2)currentAssembly.CodeModel.CodeTypeFromFullName(evt.Type.AsFullName);
}
catch (Exception exception2)
{
foreach (CodeElement element1 in evt.ProjectItem.FileCodeModel.CodeElements)
{
if (element1.IsCodeType)
{
CodeType type1 = (CodeType)element1;
foreach (CodeElement element2 in type1.Children)
{
if ((element2.Kind == vsCMElement.vsCMElementDelegate) &
(String.Compare(element2.FullName, evt.Type.AsFullName, false) == 0))
{
delegate1 = (CodeDelegate2)element2;
}
}
continue;
}
}
}
if (delegate1 == null)
{
this.DisplayWarning(string.Format(Resource.EventErrMsg, evt.Name, evt.Type.AsFullName));
}
else
{
CodeMemberMethod method1 = null;
foreach (CodeTypeMember member1 in proxyClass.Members)
{
if (String.Compare(member1.Name, "HookCustomEvents", false) == 0)
{
method1 = (CodeMemberMethod)member1;
}
}
if (method1 == null)
{
method1 = new CodeMemberMethod();
method1.Name = "HookCustomEvents";
method1.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method1.Statements.Add(this.GetStatementCastFormInstance(interopFormClass));
proxyClass.Members.Add(method1);
}
CodeMemberEvent event1 = new CodeMemberEvent();
event1.Attributes = MemberAttributes.Public;
event1.Type = new CodeTypeReference(evt.Type.AsFullName);
event1.Name = evt.Name;
CodeMemberMethod method3 = new CodeMemberMethod();
method3.Name = evt.Name;
CodeTypeDelegate delegate2 = new CodeTypeDelegate(evt.Name + "Handler");
bool flag1 = false;
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "castFormInstance_" + evt.Name;
CodeDelegateInvokeExpression expression1 = new CodeDelegateInvokeExpression(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), event1.Name));
foreach (CodeParameter parameter1 in delegate1.Parameters)
{
CodeParameterDeclarationExpression expression2;
CodeArgumentReferenceExpression expression3;
CodeParameterDeclarationExpression expression4;
if ((parameter1.Type.CodeType != null) && this.IsEventArgs(parameter1.Type.CodeType))
{
if (!flag1)
{
proxyClass.Members.Add(delegate2);
event1.Type = new CodeTypeReference(delegate2.Name);
}
expression4 = new CodeParameterDeclarationExpression("System.EventArgs", parameter1.Name);
expression2 = new CodeParameterDeclarationExpression(parameter1.Type.AsFullName, parameter1.Name);
expression3 = new CodeArgumentReferenceExpression(expression4.Name);
event1.Comments.Add(new CodeCommentStatement(this.EVENT_ARGS_COMMENT));
method3.Comments.Add(new CodeCommentStatement(this.EVENT_ARGS_COMMENT));
}
else
{
if (!this.IsSupported(parameter1.Type))
{
this.DisplayWarning(String.Format(Resource.EventErrMsg2, parameter1.Type.AsFullName, evt.Name));
return;
}
expression4 = new CodeParameterDeclarationExpression(parameter1.Type.AsFullName, parameter1.Name);
expression2 = new CodeParameterDeclarationExpression(parameter1.Type.AsFullName, parameter1.Name);
expression3 = new CodeArgumentReferenceExpression(expression4.Name);
}
method3.Parameters.Add(expression4);
delegate2.Parameters.Add(expression4);
method2.Parameters.Add(expression2);
expression1.Parameters.Add(expression3);
}
method2.Statements.Add(expression1);
method1.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new CodeVariableReferenceExpression("castFormInstance"), event1.Name), new CodeDelegateCreateExpression(event1.Type, new CodeThisReferenceExpression(), method2.Name)));
proxyClassEventSinkInterface.Members.Add(method3);
proxyClass.Members.Add(method2);
proxyClass.Members.Add(event1);
}
}
public CodeDelegateNodeFactory(CodeDelegate2 element) : base(element as CodeElement)
{
_element = element;
}
internal ShellCodeDelegate(CodeDelegate2 @delegate) : base(@delegate as CodeElement2)
{
_delegate = @delegate;
}
public static ITypeMetadata FromCodeElement(CodeDelegate2 codeVariable, CodeDomFileMetadata file)
{
return(GetType(codeVariable, file));
}
internal ShellCodeDelegate(CodeDelegate2 @delegate) : base(@delegate as CodeElement2)
{
_delegate = @delegate;
}
/// <summary>
/// Returns a flag indicating whether a CodeElement is a generic,
/// and also returns the element's generic name.
/// </summary>
/// <param name="element">The CodeElement to test.</param>
/// <param name="name">The returned generic name.</param>
/// <returns>true if the delegate is a generic, otherwise false.</returns>
public static bool IsGeneric(CodeElement element, out string name)
{
bool isGen = false;
string postfix = null;
if (element == null)
{
throw new ArgumentNullException("element");
}
switch (element.Kind)
{
case vsCMElement.vsCMElementClass:
CodeClass2 codeClass = element as CodeClass2;
if ((codeClass != null) && codeClass.IsGeneric)
{
isGen = true;
}
break;
//union declaration is used to represent variant types
case vsCMElement.vsCMElementUnion:
CodeClass2 codeVariant = element as CodeClass2;
if ((codeVariant != null) && codeVariant.IsGeneric)
{
isGen = true;
}
break;
case vsCMElement.vsCMElementInterface:
CodeInterface2 codeInterface = element as CodeInterface2;
if ((codeInterface != null) && codeInterface.IsGeneric)
{
isGen = true;
}
break;
case vsCMElement.vsCMElementFunction:
CodeFunction2 codeFunction = element as CodeFunction2;
if ((codeFunction != null) && codeFunction.IsGeneric)
{
// Get information about the parameters, which is appended to the function name later.
postfix = ExtractMethodParameters(codeFunction);
isGen = true;
}
break;
case vsCMElement.vsCMElementProperty:
CodeProperty2 codeProperty = element as CodeProperty2;
if ((codeProperty != null) && codeProperty.IsGeneric)
{
isGen = true;
}
break;
case vsCMElement.vsCMElementVariable:
CodeVariable2 codeVariable = element as CodeVariable2;
if ((codeVariable != null) && codeVariable.IsGeneric)
{
isGen = true;
}
break;
case vsCMElement.vsCMElementDelegate:
CodeDelegate2 codeDelegate = element as CodeDelegate2;
if ((codeDelegate != null) && codeDelegate.IsGeneric)
{
isGen = true;
}
break;
}
if (isGen)
{
// postfix is not null if the CodeElement is a generic function.
name = ExtractGenericNameFromFullName(element) + postfix;
}
else
{
name = null;
}
return(isGen);
}
public CodeDelegateNodeFactory(CodeDelegate2 element) : base(element as CodeElement)
{
_element = element;
}
public static bool IsCodeElementPrivate(CodeElement codeElement)
{
switch (codeElement.Kind)
{
case vsCMElement.vsCMElementVariable:
CodeVariable2 codeVariable = (CodeVariable2)codeElement;
if (codeVariable.Access == vsCMAccess.vsCMAccessPrivate)
{
return(true);
}
break;
case vsCMElement.vsCMElementFunction:
CodeFunction2 codeFunction = (CodeFunction2)codeElement;
if (codeFunction.Access == vsCMAccess.vsCMAccessPrivate)
{
return(true);
}
break;
case vsCMElement.vsCMElementProperty:
CodeProperty codeProperty = (CodeProperty)codeElement;
if (codeProperty.Access == vsCMAccess.vsCMAccessPrivate)
{
return(true);
}
break;
case vsCMElement.vsCMElementClass:
CodeClass2 codeClass = (CodeClass2)codeElement;
if (codeClass.Access == vsCMAccess.vsCMAccessPrivate)
{
return(true);
}
break;
case vsCMElement.vsCMElementDelegate:
CodeDelegate2 codeDelegate = (CodeDelegate2)codeElement;
if (codeDelegate.Access == vsCMAccess.vsCMAccessPrivate)
{
return(true);
}
break;
case vsCMElement.vsCMElementEvent:
CodeEvent codeEvent = (CodeEvent)codeElement;
if (codeEvent.Access == vsCMAccess.vsCMAccessPrivate)
{
return(true);
}
break;
case vsCMElement.vsCMElementInterface:
CodeInterface2 codeInterface = (CodeInterface2)codeElement;
if (codeInterface.Access == vsCMAccess.vsCMAccessPrivate)
{
return(true);
}
break;
case vsCMElement.vsCMElementStruct:
CodeStruct2 codeStruct = (CodeStruct2)codeElement;
if (codeStruct.Access == vsCMAccess.vsCMAccessPrivate)
{
return(true);
}
break;
}
return(false);
}
