static uint?GetOperandMDToken(InstructionOperandVM op) { switch (op.InstructionOperandType) { case InstructionOperandType.None: case InstructionOperandType.SByte: case InstructionOperandType.Byte: case InstructionOperandType.Int32: case InstructionOperandType.Int64: case InstructionOperandType.Single: case InstructionOperandType.Double: case InstructionOperandType.String: case InstructionOperandType.BranchTarget: case InstructionOperandType.SwitchTargets: case InstructionOperandType.Local: case InstructionOperandType.Parameter: return(null); case InstructionOperandType.Field: case InstructionOperandType.Method: case InstructionOperandType.Token: case InstructionOperandType.Type: var token = op.Other as IMDTokenProvider; return(token == null ? (uint?)null : token.MDToken.ToUInt32()); case InstructionOperandType.MethodSig: var msig = op.Other as MethodSig; return(msig == null ? (uint?)null : msig.OriginalToken); default: throw new InvalidOperationException(); } }
public InstructionVM(ModuleDef ownerModule) { this.ownerModule = ownerModule; this.instructionOperandVM = new InstructionOperandVM(); this.InstructionOperandVM.PropertyChanged += (a, b) => HasErrorUpdated(); this.codeVM = new ListVM<Code>(codeList, (a, b) => OnCodeUpdated()); }
public InstructionVM(ModuleDef ownerModule) { this.ownerModule = ownerModule; this.instructionOperandVM = new InstructionOperandVM(); this.InstructionOperandVM.PropertyChanged += (a, b) => HasErrorUpdated(); this.codeVM = new ListVM <Code>(codeList, (a, b) => OnCodeUpdated()); }
void AddType(InstructionOperandVM opvm) { var picker = new DnlibTypePicker(Window.GetWindow(listBox)); var type = picker.GetDnlibType(new FlagsTreeViewNodeFilter(VisibleMembersFlags.TypeDef), opvm.Other as ITypeDefOrRef, cilBodyVM.OwnerModule); if (type != null) { opvm.Other = type; } }
void AddMethodDef(InstructionOperandVM opvm) { var picker = new DnlibTypePicker(Window.GetWindow(listBox)); var method = picker.GetDnlibType(new FlagsTreeViewNodeFilter(VisibleMembersFlags.MethodDef), opvm.Other as IMethod, cilBodyVM.OwnerModule); if (method != null) { opvm.Other = method; } }
void OnInstructionOperandVMChanged(InstructionOperandVM oldValue, InstructionOperandVM newValue) { if (oldValue != null) { oldValue.PropertyChanged -= instructionOperandVM_PropertyChanged; } if (newValue != null) { newValue.PropertyChanged += instructionOperandVM_PropertyChanged; InitializeOperandType(newValue); } }
void EditMethodSig(InstructionOperandVM opvm) { var creator = new CreateMethodPropertySig(Window.GetWindow(listBox)); var opts = new MethodSigCreatorOptions(cilBodyVM.TypeSigCreatorOptions.Clone("Create MethodSig")); opts.CanHaveSentinel = true; var sig = (MethodSig)creator.Create(opts, opvm.Other as MethodSig); if (sig != null) { opvm.Other = sig; } }
public void InitializeFrom(InstructionOperandVM other) { this.InstructionOperandType = other.InstructionOperandType; this.SByte.StringValue = other.SByte.StringValue; this.Byte.StringValue = other.Byte.StringValue; this.Int32.StringValue = other.Int32.StringValue; this.Int64.StringValue = other.Int64.StringValue; this.Single.StringValue = other.Single.StringValue; this.Double.StringValue = other.Double.StringValue; this.String.StringValue = other.String.StringValue; this.Other = other.Other; this.OperandListItem = other.OperandListItem; }
void AddTypeSpec(InstructionOperandVM opvm) { var creator = new TypeSigCreator(Window.GetWindow(listBox)); var opts = cilBodyVM.TypeSigCreatorOptions.Clone("Create a TypeSpec"); bool canceled; var newSig = creator.Create(opts, (opvm.Other as ITypeDefOrRef).ToTypeSig(), out canceled); if (canceled) { return; } opvm.Other = newSig.ToTypeDefOrRef(); }
void EditSwitchOperand(InstructionOperandVM opvm) { var data = new SwitchOperandVM(cilBodyVM.InstructionsListVM, opvm.Other as InstructionVM[]); var win = new SwitchOperandDlg(); win.DataContext = data; win.Owner = Window.GetWindow(listBox) ?? MainWindow.Instance; if (win.ShowDialog() != true) { return; } opvm.Other = data.GetSwitchList(); }
void AddMemberRef(InstructionOperandVM opvm, MemberRef mr, bool isField) { var opts = mr == null ? new MemberRefOptions() : new MemberRefOptions(mr); var vm = new MemberRefVM(opts, cilBodyVM.TypeSigCreatorOptions, isField); var creator = new EditMemberRef(Window.GetWindow(listBox)); var title = isField ? "Edit Field MemberRef" : "Edit Method MemberRef"; vm = creator.Edit(title, vm); if (vm == null) { return; } opvm.Other = vm.CreateMemberRefOptions().Create(cilBodyVM.OwnerModule); }
void AddFieldMemberRef(InstructionOperandVM opvm) { MemberRef mr = opvm.Other as MemberRef; var fd = opvm.Other as FieldDef; if (fd != null) { mr = cilBodyVM.OwnerModule.Import(fd); } if (mr != null && mr.FieldSig == null) { mr = null; } AddMemberRef(opvm, mr, true); }
void AddMethodSpec(InstructionOperandVM opvm) { var ms = opvm.Other as MethodSpec; var opts = ms == null ? new MethodSpecOptions() : new MethodSpecOptions(ms); var vm = new MethodSpecVM(opts, cilBodyVM.TypeSigCreatorOptions); var creator = new EditMethodSpec(Window.GetWindow(listBox)); vm = creator.Edit("Edit MethodSpec", vm); if (vm == null) { return; } opvm.Other = vm.CreateMethodSpecOptions().Create(cilBodyVM.OwnerModule); }
void AddMethodMemberRef(InstructionOperandVM opvm) { MemberRef mr = opvm.Other as MemberRef; var md = opvm.Other as MethodDef; var ms = opvm.Other as MethodSpec; if (ms != null) { mr = ms.Method as MemberRef; md = ms.Method as MethodDef; } if (md != null) { mr = cilBodyVM.OwnerModule.Import(md); } if (mr != null && mr.MethodSig == null) { mr = null; } AddMemberRef(opvm, mr, false); }
void IEditOperand.Edit(object parameter, InstructionOperandVM opvm) { MenuCommandFlags flags; switch (opvm.InstructionOperandType) { case InstructionOperandType.Field: flags = MenuCommandFlags.FieldDef | MenuCommandFlags.FieldMemberRef; ShowMenu(parameter, opvm, flags); break; case InstructionOperandType.Method: flags = MenuCommandFlags.MethodDef | MenuCommandFlags.MethodMemberRef | MenuCommandFlags.MethodSpec; ShowMenu(parameter, opvm, flags); break; case InstructionOperandType.Token: flags = MenuCommandFlags.FieldDef | MenuCommandFlags.FieldMemberRef | MenuCommandFlags.MethodDef | MenuCommandFlags.MethodMemberRef | MenuCommandFlags.MethodSpec | MenuCommandFlags.TypeDef | MenuCommandFlags.TypeRef | MenuCommandFlags.TypeSpec; ShowMenu(parameter, opvm, flags); break; case InstructionOperandType.Type: flags = MenuCommandFlags.TypeDef | MenuCommandFlags.TypeRef | MenuCommandFlags.TypeSpec; ShowMenu(parameter, opvm, flags); break; case InstructionOperandType.MethodSig: EditMethodSig(opvm); break; case InstructionOperandType.SwitchTargets: EditSwitchOperand(opvm); break; default: throw new InvalidOperationException(); } }
static void Write(this ITextOutput output, InstructionOperandVM opvm) { switch (opvm.InstructionOperandType) { case MethodBody.InstructionOperandType.None: break; case MethodBody.InstructionOperandType.SByte: output.Write(opvm.SByte.StringValue, TextTokenType.Number); break; case MethodBody.InstructionOperandType.Byte: output.Write(opvm.Byte.StringValue, TextTokenType.Number); break; case MethodBody.InstructionOperandType.Int32: output.Write(opvm.Int32.StringValue, TextTokenType.Number); break;; case MethodBody.InstructionOperandType.Int64: output.Write(opvm.Int64.StringValue, TextTokenType.Number); break;; case MethodBody.InstructionOperandType.Single: output.Write(opvm.Single.StringValue, TextTokenType.Number); break;; case MethodBody.InstructionOperandType.Double: output.Write(opvm.Double.StringValue, TextTokenType.Number); break;; case MethodBody.InstructionOperandType.String: output.Write(opvm.String.StringValue, TextTokenType.String); break;; case MethodBody.InstructionOperandType.Field: case MethodBody.InstructionOperandType.Method: case MethodBody.InstructionOperandType.Token: case MethodBody.InstructionOperandType.Type: case MethodBody.InstructionOperandType.MethodSig: case MethodBody.InstructionOperandType.SwitchTargets: case MethodBody.InstructionOperandType.BranchTarget: case MethodBody.InstructionOperandType.Local: case MethodBody.InstructionOperandType.Parameter: WriteObject(output, opvm.Value, WriteObjectFlags.ShortInstruction); break; default: throw new InvalidOperationException(); } }
void OnCodeUpdated() { InstructionOperandVM.UpdateOperandType(Code); OnPropertyChanged("Code"); HasErrorUpdated(); }
void OnInstructionOperandVMChanged(InstructionOperandVM oldValue, InstructionOperandVM newValue) { if (oldValue != null) oldValue.PropertyChanged -= instructionOperandVM_PropertyChanged; if (newValue != null) { newValue.PropertyChanged += instructionOperandVM_PropertyChanged; InitializeOperandType(newValue); } }
void InitializeOperandType(InstructionOperandVM instructionOperandVM) { switch (instructionOperandVM.InstructionOperandType) { case InstructionOperandType.None: Content = null; break; case InstructionOperandType.SByte: case InstructionOperandType.Byte: case InstructionOperandType.Int32: case InstructionOperandType.Int64: case InstructionOperandType.Single: case InstructionOperandType.Double: case InstructionOperandType.String: // Don't cache the TextBox as a field in this class. The error border disappears when // switching from a textbox opcode to a non-textbox opcode and back to the textbox // again. Only solution seems to be to create a new textbox. var textBox = Content as TextBox; if (textBox == null) { textBox = new TextBox(); var binding = new Binding("InstructionOperandVM.Text.StringValue") { Source = this, ValidatesOnDataErrors = true, ValidatesOnExceptions = true, UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged, }; textBox.SetBinding(TextBox.TextProperty, binding); binding = new Binding("TextBoxStyle") { Source = this, }; textBox.SetBinding(TextBox.StyleProperty, binding); Content = textBox; } break; case InstructionOperandType.Field: case InstructionOperandType.Method: case InstructionOperandType.Token: case InstructionOperandType.Type: case InstructionOperandType.MethodSig: case InstructionOperandType.SwitchTargets: var button = Content as FastClickButton; if (button == null) { button = new FastClickButton(); var binding = new Binding("InstructionOperandVM.Other") { Source = this, Mode = BindingMode.OneWay, Converter = CilObjectConverter.Instance, ValidatesOnDataErrors = true, ValidatesOnExceptions = true, UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged, }; button.SetBinding(Button.ContentProperty, binding); binding = new Binding("ButtonStyle") { Source = this, }; button.SetBinding(Button.StyleProperty, binding); binding = new Binding("ButtonCommand") { Source = this, }; button.SetBinding(Button.CommandProperty, binding); button.CommandParameter = button; Content = button; } break; case InstructionOperandType.BranchTarget: case InstructionOperandType.Local: case InstructionOperandType.Parameter: var comboBox = Content as ComboBox; if (comboBox == null) { comboBox = new ComboBox(); comboBox.ItemTemplate = (DataTemplate)GetValue(ComboBoxItemTemplateProperty); ComboBoxAttachedProps.SetSelectionBoxItemTemplate(comboBox, (DataTemplate)GetValue(ComboBoxSelectionBoxItemTemplateProperty)); var binding = new Binding("InstructionOperandVM.OperandListVM.Items") { Source = this, }; comboBox.SetBinding(ComboBox.ItemsSourceProperty, binding); binding = new Binding("InstructionOperandVM.OperandListVM.SelectedIndex") { Source = this, ValidatesOnDataErrors = true, ValidatesOnExceptions = true, UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged, }; comboBox.SetBinding(ComboBox.SelectedIndexProperty, binding); binding = new Binding("ComboBoxStyle") { Source = this, }; comboBox.SetBinding(ComboBox.StyleProperty, binding); binding = new Binding("ComboBoxItemTemplate") { Source = this, }; comboBox.SetBinding(ComboBox.ItemTemplateProperty, binding); binding = new Binding("ComboBoxSelectionBoxItemTemplate") { Source = this, }; comboBox.SetBinding(ComboBoxAttachedProps.SelectionBoxItemTemplateProperty, binding); Content = comboBox; } break; default: throw new InvalidOperationException(); } }
void ShowMenu(object parameter, InstructionOperandVM opvm, MenuCommandFlags flags) { var ctxMenu = new ContextMenu(); MenuItem menuItem; if ((flags & (MenuCommandFlags.TypeDef | MenuCommandFlags.TypeRef)) != 0) { ctxMenu.Items.Add(menuItem = new MenuItem() { Header = "_Type...", Command = new RelayCommand(a => AddType(opvm)), }); MainWindow.CreateMenuItemImage(menuItem, typeof(MethodBodyControl).Assembly, "Class", BackgroundType.ContextMenuItem, true); } if ((flags & MenuCommandFlags.TypeSpec) != 0) { ctxMenu.Items.Add(menuItem = new MenuItem() { Header = "Type_Spec...", Command = new RelayCommand(a => AddTypeSpec(opvm)), }); MainWindow.CreateMenuItemImage(menuItem, typeof(MethodBodyControl).Assembly, "Generic", BackgroundType.ContextMenuItem, true); } if ((flags & MenuCommandFlags.MethodDef) != 0) { ctxMenu.Items.Add(menuItem = new MenuItem() { Header = "_Method...", Command = new RelayCommand(a => AddMethodDef(opvm)), }); MainWindow.CreateMenuItemImage(menuItem, typeof(MethodBodyControl).Assembly, "Method", BackgroundType.ContextMenuItem, true); } if ((flags & MenuCommandFlags.MethodMemberRef) != 0) { ctxMenu.Items.Add(new MenuItem() { Header = "M_ethod MemberRef...", Command = new RelayCommand(a => AddMethodMemberRef(opvm)), }); } if ((flags & MenuCommandFlags.MethodSpec) != 0) { ctxMenu.Items.Add(new MenuItem() { Header = "Met_hodSpec...", Command = new RelayCommand(a => AddMethodSpec(opvm)), }); } if ((flags & MenuCommandFlags.FieldDef) != 0) { ctxMenu.Items.Add(menuItem = new MenuItem() { Header = "_Field...", Command = new RelayCommand(a => AddFieldDef(opvm)), }); MainWindow.CreateMenuItemImage(menuItem, typeof(MethodBodyControl).Assembly, "Field", BackgroundType.ContextMenuItem, true); } if ((flags & MenuCommandFlags.FieldMemberRef) != 0) { ctxMenu.Items.Add(new MenuItem() { Header = "F_ield MemberRef...", Command = new RelayCommand(a => AddFieldMemberRef(opvm)), }); } ctxMenu.Placement = PlacementMode.Bottom; ctxMenu.PlacementTarget = parameter as UIElement; ctxMenu.IsOpen = true; }