public TypeViewModel(TypeInfo typeInfo) { _isExpanded = true; _typeInfo = typeInfo; if (_typeInfo.BaseType != null) { BaseType = new TypeViewModel(_typeInfo.BaseType); } _fields = _typeInfo.Fields .OrderBy(f => f.Name) .Select(f => new FieldViewModel(f)) .OfType<MemberViewModel>() .ToArray(); _properties = _typeInfo.Properties .OrderBy(p => p.Name) .Select(p => new PropertyViewModel(p)) .OfType<MemberViewModel>() .ToArray(); _events = _typeInfo.Events .OrderBy(e => e.Name) .Select(e => new EventViewModel(e)) .OfType<MemberViewModel>() .ToArray(); _methods = _typeInfo.Methods .OrderBy(m => m.Name) .Select(m => new MethodViewModel(m)) .OfType<MemberViewModel>() .ToArray(); NavigateCommand = new DelegateCommand(NavigateCommandHandler); BrowseInteractionsCommand = new DelegateCommand(BrowseInteractionsCommandHandler); }
public AssemblyBrowserWindowViewModel(IEnumerable<AssemblyInfo> assemblyDefinitions, TypeInfo type, Dispatcher dispatcher) { _dispatcher = dispatcher; _assemblies = new ObservableCollection<AssemblyViewModel>( assemblyDefinitions.Select(a => new AssemblyViewModel(a, this))); OnAssembliesChanged(); NavigateBackCommand = new DelegateCommand(NavigateBackCommandHandler); NavigateForwardCommand = new DelegateCommand(NavigateForwardCommandHandler); ShowInnerSearchCommand = new DelegateCommand(ShowInnerSearchCommandHandler); ToggleAssembliesCommand = new DelegateCommand(ToggleAssembliesCommandHandler); RefreshNavigationCommands(); IsColorized = true; _searchScreen = new SearchScreen(this); if (type == null) { Screen = _searchScreen; } else { var typeViewModel = Types.Single(t => t.TypeInfo == type); CurrentNavigationItem = new NavigationItem(typeViewModel); } }
public AncestryBrowserWindow(TypeInfo typeInfo) { InitializeComponent(); ViewModel = new AncestryBrowserWindowViewModel(typeInfo); WindowManager.AddAncestryBrowser(this); }
public static void BrowseAncestry(TypeInfo type) { var window = new AncestryBrowserWindow(type); #if ILSpy window.Owner = MainWindow; #elif Reflector System.Windows.Forms.Integration.ElementHost.EnableModelessKeyboardInterop(window); #endif window.Show(); }
public AncestryBrowserWindowViewModel(TypeInfo typeInfo) { _typeInfo = typeInfo; ExpandCollapseAllCommand = new DelegateCommand(ExpandCollapseAllCommandHandler); _options = new MemberOptions { ShowProperties = true, ShowEvents = true, ShowMethods = true, ShowProtected = true, ShowProtectedInternal = true, ShowPublic = true }; _typeViewModel = new TypeViewModel(_typeInfo); _ancestry = _typeViewModel.Ancestry.ToList(); _ancestry.Last().IsLast = true; _assemblies = _ancestry .GroupBy(t => t.TypeInfo.Module.Assembly) .Select(g => new AssemblyViewModel(g.Key, g)) .ToList(); int currentIndex = 0; foreach (var assembly in _assemblies) { var brush = BrushProvider.BrushPairs[currentIndex].Background as SolidColorBrush; brush = new SolidColorBrush( new Color { A = 72, R = brush.Color.R, G = brush.Color.G, B = brush.Color.B}); assembly.BackgroundBrush = brush; assembly.CaptionBrush = BrushProvider.BrushPairs[currentIndex].Caption; currentIndex++; if (currentIndex == BrushProvider.BrushPairs.Count) { currentIndex = 0; } } KindGroup = new CommandsGroupViewModel( Resources.Members, new List<GroupedUserCommand> { new GroupedUserCommand(Resources.All, ShowAllMemberKinds, true), new GroupedUserCommand(Resources.Virtual, ShowVirtualMembers) }); UpdateMembers(); FillToolTips(); }
public AssemblyBrowserWindow(IEnumerable<AssemblyInfo> assemblies, TypeInfo typeInfo) { InitializeComponent(); ViewModel = new AssemblyBrowserWindowViewModel(assemblies, typeInfo, Dispatcher); CommandBindings.Add(new CommandBinding(NavigationCommands.BrowseForward, (s, e) => ViewModel.NavigateForwardCommand.Execute(null))); CommandBindings.Add(new CommandBinding(NavigationCommands.BrowseBack, (s, e) => ViewModel.NavigateBackCommand.Execute(null))); WindowManager.AddAssemblyBrowser(this); }
public TypeInfo Type(ITypeDeclaration type, ModuleInfo module) { if (type == null) { return null; } if (_typeCorrespondence.ContainsKey(type)) { return _typeCorrespondence[type]; } var methods = type.Methods.OfType<IMethodDeclaration>() .Where(m => !m.Name.Contains("get_") && !m.Name.Contains("set_") && !m.Name.Contains("add_") && !m.Name.Contains("remove_")) .ToArray(); var typeInfo = new TypeInfo { BaseTypeRetriever = () => Type(type.BaseType), Name = type.Name, Events = type.Events.OfType<IEventDeclaration>().Select(e => Event(e)), Properties = type.Properties.OfType<IPropertyDeclaration>().Select(p => Property(p)), MembersCount = methods.Count() + type.Events.Count + type.Properties.Count + type.Fields.Count, IsInternal = type.Visibility == TypeVisibility.Private || type.Visibility == TypeVisibility.NestedPrivate || type.Visibility == TypeVisibility.NestedFamilyAndAssembly || type.Visibility == TypeVisibility.NestedAssembly, IsPublic = type.Visibility == TypeVisibility.Public || type.Visibility == TypeVisibility.NestedPublic || type.Visibility == TypeVisibility.NestedFamilyOrAssembly || type.Visibility == TypeVisibility.NestedFamily, MemberReference = type, IsEnum = IsEnum(type), IsInterface = type.Interface, IsValueType = type.ValueType, IsSealed = type.Sealed, IsAbstract = type.Abstract }; typeInfo.FullName = GetFullName(type.Namespace, typeInfo.Name); typeInfo.Methods = methods.Select(m => Method(m, typeInfo)); typeInfo.Accessors = type.Methods.OfType<IMethodDeclaration>().Except(methods).Select(m => Method(m, typeInfo)); typeInfo.Fields = type.Fields.OfType<IFieldDeclaration>().Select(f => Field(f, typeInfo)); foreach (var eventInfo in typeInfo.Events) { eventInfo.DeclaringType = typeInfo; } foreach (var propertyInfo in typeInfo.Properties) { propertyInfo.DeclaringType = typeInfo; } _typeCorrespondence.Add(type, typeInfo); typeInfo.Module = module ?? Module(GetModuleForType(type)); typeInfo.Icon = Images.Images.GetTypeIcon(typeInfo); return typeInfo; }
public MethodInfo Method(IMethodDeclaration method, TypeInfo type) { if (_methodCorrespondence.ContainsKey(method)) { return _methodCorrespondence[method]; } var methodInfo = new MethodInfo { Text = method.ToString(), Name = method.Name, FullName = method.Name, IsInternal = method.Visibility == MethodVisibility.Assembly, IsPrivate = method.Visibility == MethodVisibility.Private, IsPublic = method.Visibility == MethodVisibility.Public, IsProtected = method.Visibility == MethodVisibility.Family, IsProtectedAndInternal = method.Visibility == MethodVisibility.FamilyAndAssembly, IsProtectedOrInternal = method.Visibility == MethodVisibility.FamilyOrAssembly, IsVirtual = method.Virtual, IsOverride = method.Virtual && !method.NewSlot, IsSpecialName = method.SpecialName, IsStatic = method.Static, IsFinal = method.Final, MemberReference = method, DeclaringType = type }; _methodCorrespondence.Add(method, methodInfo); if (method.Overrides.Count > 0) { var overridden = method.Overrides[0]; var declaringType = overridden.DeclaringType as ITypeReference; if (declaringType.Resolve().Interface) { methodInfo.IsOverride = false; } } int correction = methodInfo.Text.Contains(".ctor") || methodInfo.Text.Contains(".cctor") ? 0 : 1; methodInfo.Text = methodInfo.Text.Substring(methodInfo.Text.LastIndexOf('.') + correction); methodInfo.Name = methodInfo.Name.Substring(methodInfo.Name.LastIndexOf('.') + correction); methodInfo.Icon = Images.Images.GetMethodIcon(methodInfo); return methodInfo; }
public FieldInfo Field(IFieldDeclaration fieldDefinition, TypeInfo type) { if (_fieldCorrespondence.ContainsKey(fieldDefinition)) { return _fieldCorrespondence[fieldDefinition]; } var fieldInfo = new FieldInfo { Text = fieldDefinition.ToString(), Name = fieldDefinition.Name, FullName = fieldDefinition.Name, IsInternal = fieldDefinition.Visibility == FieldVisibility.Assembly, IsPrivate = fieldDefinition.Visibility == FieldVisibility.Private, IsPublic = fieldDefinition.Visibility == FieldVisibility.Public, IsProtected = fieldDefinition.Visibility == FieldVisibility.Family, IsProtectedAndInternal = fieldDefinition.Visibility == FieldVisibility.FamilyAndAssembly, IsProtectedOrInternal = fieldDefinition.Visibility == FieldVisibility.FamilyOrAssembly, IsStatic = fieldDefinition.Static, IsLiteral = fieldDefinition.Literal, IsInitOnly = fieldDefinition.ReadOnly, IsSpecialName = fieldDefinition.SpecialName, MemberReference = fieldDefinition, DeclaringType = type }; _fieldCorrespondence.Add(fieldDefinition, fieldInfo); fieldInfo.Text = fieldInfo.Text.Substring(fieldInfo.Text.LastIndexOf('.') + 1); fieldInfo.Name = fieldInfo.Name.Substring(fieldInfo.Name.LastIndexOf('.') + 1); fieldInfo.Icon = Images.Images.GetFieldIcon(fieldInfo); return fieldInfo; }
private TypeViewModel GetViewModelForType(TypeInfo typeInfo) { if (_viewModelCorrespondence.ContainsKey(typeInfo)) { return _viewModelCorrespondence[typeInfo]; } var viewModel = new TypeViewModel(typeInfo, this); _viewModelCorrespondence.Add(typeInfo, viewModel); return viewModel; }
private HierarchyViewModel GetHierarchy(TypeInfo typeInfo) { var hierarchyList = new List<TypeInfo>(); var currentType = typeInfo; hierarchyList.Add(typeInfo); while (currentType.BaseType != null) { var t = currentType.BaseType; hierarchyList.Add(t); currentType = t; } return new HierarchyViewModel(hierarchyList.Select(GetViewModelForType).ToArray()); }
private IEnumerable<FieldInfo> FixDeclaringTypes(FieldInfo[] fields, TypeInfo[] types) { var fixedFields = new List<FieldInfo>(); var typeFullNames = types.Select(t => t.FullName).ToArray(); foreach (var field in fields) { if (types.Contains(field.DeclaringType)) { fixedFields.Add(field); continue; } if (typeFullNames.Contains(field.DeclaringType.FullName)) { var type = types.Single(t => t.FullName == field.DeclaringType.FullName); var realField = type.Fields.Single(m => m.Name == field.Name); fixedFields.Add(realField); } } return fixedFields; }
private IEnumerable<MethodInfo> FixDeclaringTypes(MethodInfo[] methods, TypeInfo[] types) { var fixedMethods = new List<MethodInfo>(); var typeFullNames = types.Select(t => t.FullName).ToArray(); foreach (var method in methods) { if (types.Contains(method.DeclaringType)) { fixedMethods.Add(method); continue; } if (typeFullNames.Contains(method.DeclaringType.FullName)) { var type = types.Single(t => t.FullName == method.DeclaringType.FullName); var realMethod = type.Methods.SingleOrDefault(m => m.MemberReference.ToString() == method.MemberReference.ToString()); if (realMethod == null) { realMethod = type.Accessors.Single(m => m.MemberReference.ToString() == method.MemberReference.ToString()); } fixedMethods.Add(realMethod); } } return fixedMethods; }
public TypeViewModel(TypeInfo typeInfo, AssemblyViewModel assemblyViewModel, AssemblyBrowserWindowViewModel windowViewModel) { _typeInfo = typeInfo; _windowViewModel = windowViewModel; _assemblyViewModel = assemblyViewModel; _name = typeInfo.Name; _fullName = typeInfo.FullName; _extendedInfo = IsInternal ? string.Format("{0}\n{1}", FullName, Resources.Internal) : FullName; if (_typeInfo.IsEnum) { var enumValues = _typeInfo.Fields.Where(f => f.Name != "value__").Select(f => f.Name); if (enumValues.Count() > 0) { var values = string.Join("\n", _typeInfo.Fields.Where(f => f.Name != "value__").Select(f => f.Name)); _extendedInfo = string.Format("{0}\n\n{1}", _extendedInfo, values); } } else if (_typeInfo.IsInterface) { var members = _typeInfo.Events.Select(m => m.Text) .Concat(_typeInfo.Properties.Select(p => p.Text)) .Concat(_typeInfo.Methods.Select(p => p.Text)); if (members.Count() > 0) { var values = string.Join("\n", members); _extendedInfo = string.Format("{0}\n\n{1}", _extendedInfo, values); } } if (HasBaseType) { var baseType = _typeInfo.BaseType; _baseTypeName = baseType.Name; _baseTypeFullName = baseType.FullName; if (baseType == null) { _baseTypeFullName = _baseTypeFullName + "\n" + Resources.NotAvailable; _isBaseTypeAvailable = false; } } var properties = typeInfo.Properties .Where(p => p.IsPublic) .Select(p => new PropertyViewModel(p)) .OfType<MemberViewModel>(); var events = typeInfo.Events .Where(e => e.IsPublic) .Select(e => new EventViewModel(e)) .OfType<MemberViewModel>(); var methods = typeInfo.Methods .Where(m => m.IsPublic) .Select(m => new MethodViewModel(m)) .OfType<MemberViewModel>(); Members = properties.Concat(events).Concat(methods); _membersCount = typeInfo.MembersCount; VisualizeCommand = new DelegateCommand(VisualizeCommandHandler); NavigateCommand = new DelegateCommand(NavigateCommandHandler); NavigateToBaseCommand = new DelegateCommand(NavigateToBaseCommandHandler); ShowMembersCommand = new DelegateCommand(ShowMembersCommandHandler); BrowseAncestryCommand = new DelegateCommand(BrowseAncestryCommandHandler); BrowseInteractionsCommand = new DelegateCommand(BrowseInteractionsCommandHandler); ExpandCommand = new DelegateCommand(ExpandCommandHandler); RefreshBackground(); ResetName(); }