WPF vb.net KeyBinding Delete
Well, your question is really not related to AutoCAD .NET API programming at all, and I bet many, if not most, AutoCAD .NET programming still use Win Forms more than WPF in AutoCAD add-in as UI, thus you have much less chance of getting good replies for this kind of question in this forum than in more generic, WPF discussion forums, such as in Stackoverflow.com.
Having said that, let me give it a try: you may want to apply KeyBinding in the root UIElement, instead of ListView. If your UI is a dialog window, the root UIElement is <Window />, if it is a Palette in a custom PalatteSet, it is <UserControl />, so it would be something like:
<Window[UserControl] .....>
<Window[UserControl].InputBindings>
<KeyBinding Key="Delete" Command="{Binding DeleteCommand}" />
</Window[UserControl].InputBindings>
</Window[UserControl]>
Of course, the DeleteCommand would have its "CanExecute" function properly coded so that if no item in the ListView is selected, the function returns False, so that the command is disabled, and pressing "Delete" button would not run the command's code.
OK, I assume that the KeyBinding now does work, right?
ICommand, which is bound to the "Delete" key, must have an implemented CanExecute function that returns a boolean value. So, it is up to you to place code logic in it to decide what to do so that the Command either can be executed, or disabled. In your case, the logic in CanExecute() would be something like: check if the target listview has one or more items selected or not; if no, returns False, so the command is disabled (thus, pressing "Delete" would do nothing to the ListView); if yes, as optional, you may want to pop up a message box with "yes/No" button for user confirmation, then return True or False accordingly.
If you do use MVVM pattern, your ViewModel would have an ObservableCollection<Something> bound to the ListView and a SelectedSomething property that is bound to the ListView's SelectedItem. Then you only need one line of code as CanExecute function: (o)=>{ return SelectionSomething != null;}
Obviously, if you do not use MVVM pattern, you can still write code behind the view, as you do with Win Form (but a lot more code and messier). I'd not use WPF UI if MVVM pattern is not used.
The items that are bound to the listview should be ObservableCollection<Something>.
The ViewModel (MyDataContext class, according to your next post) should look like:
Public Class MyDataContext
Inherit ViewModelBase '' You probably have a viewmodelbase class that implementing INotifyPropertyChanged
Private _selected As Something=Nothing
Private _somthings As New ObservableCollection(of Something)()
Private _deleteCommand As ICommand
.....
Public Sub New()
'' Create commands,
'' Initialize _somethings collection
End Sub
Public Property Somethings() As ObserverbaleCollection(of Something)
Get
Return _somethings
End Get
End Property
Public Property SelectedSomething() As Something
Get
Return _selected
End Get
Set (ByVal value As Something)
_something = value
OnPropertyChange("SelectedSomething") '' This method should be defined in ViewModelBase clase
End Set
'' Other properties exposed for binding, such as commands
... ...
End Class
With this ViewModel (DataContext) to be bound to the UI, you can set the ListView's ItemsSource to be bound to "Somethings", and the ListView's SelectedItem to be bound to "SelectedSomething". And then finally, in the deleting command's CanExecute() method, you simply test if property SelectedSomething is null or not.
Well, it is quite some learning to get started with WPF and MVVM pattern. Hopefully you can master the basics fast enough to use WPF UI in AutoCAD.
I am not sure why does your DataContext (MyDataContext class) implement ICommand. It should be a kind of ViewModel, which expose ICommand as part of its public properties, which can be bound to UI's controls, such as Buttons.
IMO, using WPF UI in AutoCAD add-ins only make sense when MVVM pattern is used, unless the add-in UI is extremely simple and only very small amount of code behind is enough to handle user interaction. In your case, you can only use code-behind without binding, if you choose so. Again, I'd not use WPF UI without implementing MVVM patter to take advantage of rich binding functionality.
Anyway, it may be too complicated and to off-topic to further the discussion in this forum. Here I attach an simple EXE WPF sample project to show how to use MVVM pattern to bind keys ("Insert" and "Delete" keys) to add/delete items from a WPF ListView. From the sample project you can see I only have one line of code that set the UI's DataContext, which can only be done in the XAML file, so that the entire functioning ListView adding/deleting process is done without UI code-behind at all. All logic is in ViewModel.
Hope this helps.
Yeah, VB.NET does not have Envent "add"/"remove" accessor as in C#, even most online VB.NET<=>C# converters cannot convert that C# code to VB.NET correctly. You need to write more lines of code to do the same thing, which I had to search the Internet to find suitable code from others (another reason to choose C# instead of VB.NET).
Anyway, here is the VB.NET equivalent code to the class file "WpfBaseLib.cs" in WpfBaseLib project:
Imports System
Imports System.ComponentModel
Imports System.Windows.Input
Imports System.Runtime.CompilerServices
Public Class RelayCommand
Implements ICommand
Public Property ExecuteDelegate() As Action(Of Object)
Public Property CanExecuteDelegate() As Func(Of Object, Boolean)
Public Sub New()
End Sub
Public Sub New(execute As Action(Of Object))
Me.New(execute, Nothing)
End Sub
Public Sub New(execute As Action(Of Object), Optional canExecute As Func(Of Object, Boolean) = Nothing)
If execute Is Nothing Then
Throw New ArgumentNullException("execute")
Else
ExecuteDelegate = execute
End If
CanExecuteDelegate = canExecute
End Sub
Public Function CanExecute(parameter As Object) As Boolean Implements ICommand.CanExecute
Return If(CanExecuteDelegate Is Nothing, True, CanExecuteDelegate(parameter))
End Function
Public Custom Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged
AddHandler(ByVal value As EventHandler)
If CanExecuteDelegate IsNot Nothing Then
AddHandler CommandManager.RequerySuggested, value
End If
End AddHandler
RemoveHandler(ByVal value As EventHandler)
If CanExecuteDelegate IsNot Nothing Then
RemoveHandler CommandManager.RequerySuggested, value
End If
End RemoveHandler
RaiseEvent(ByVal sender As Object, ByVal e As System.EventArgs)
CommandManager.InvalidateRequerySuggested()
End RaiseEvent
End Event
Public Sub Execute(parameter As Object) Implements ICommand.Execute
If ExecuteDelegate IsNot Nothing Then ExecuteDelegate.Invoke(parameter)
End Sub
Public Sub RaiseCanExecuteChanged()
CommandManager.InvalidateRequerySuggested()
End Sub
End Class
Public MustInherit Class ViewModelBase
Implements INotifyPropertyChanged
Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged
Protected Overridable Sub OnPropertyChanged(<CallerMemberName> ByVal Optional propertyName As String = Nothing)
RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
End Sub
End Class
So, you create a VB.NET class library, add references to PressentationCore.dll and PresentationFramework.dll. Then add new class file, and copy the above code into it. Hope this helps.
As for binding mouse click/double-click to command, if you search this online, you would find out that it is a bit more complicated. Maybe some code-behind would be simpler. But I would not let user to simply do "double-click" on a list view item to delete. I'd rather place a "remove" button beside each item, so user would know what to do, if he/she wants to delete item.
