Existe algum evento que se pode ouvir que verifica o estado atual da edição? Como se pode ouvir quando o combobox não está no modo de edição.
ComboBox (ou TextBox) está em modo de edição
ComboBox não está no modo de edição
Ignore as cores, o ponto é que o ComboBox está em um modo onde o usuário pode editar/escrever texto ou não. O foco não funciona, pois ele ainda pode estar neste modo quando o combobox não está em foco.
Tenho um objeto DataSet que tem uma propriedade name e uma propriedade ID. Tenho uma lista de datasets no meu viewmodel, que deve ser o itemsource de uma coluna DataGrid Combobox. Defini a vinculação da seguinte forma:
dataGridControl:DataGridComboBoxColumn
Binding="{Binding DataSetIndex}"
Header="DataSet"
ItemsSource="{x:Bind Model.DataSets}"
DisplayMemberPath="Name"
Tag="DataSet" />
Agora, isso funciona, exceto pelo fato de que, de alguma forma, preciso informar à vinculação que ela deve usar a propriedade DataSet.ID. Então, quando um usuário seleciona um valor na combobox, o DataSetIndex de vinculação deve ser definido como um int, que é a propriedade DataSet.ID. Como posso fazer isso na vinculação? Agora, é claro, recebo um erro dizendo que o itemsource não tem uma propriedade int, porque ele tenta usar o objeto DataSet como um todo. Agora, não há SelectedValuePath no kit de ferramentas da comunidade? Tenho que usar um templatecolumn?
Aqui está minha pergunta atualizada com base na sua solução. Ela também tem a vinculação codebehind.
<dataGridControl:DataGridTemplateColumn Header="DataSet">
<dataGridControl:DataGridTemplateColumn.CellEditingTemplate>
<DataTemplate x:DataType="local:DataExtractionSetupViewModel">
<ComboBox x:Name="dataSetsComboBox" Loaded="ComboBox_Loaded"
DisplayMemberPath="Name"
SelectedValue="{Binding DataSetIndex, Mode=TwoWay}" SelectedValuePath="ID" IsDropDownOpen="True"/>
</DataTemplate>
</dataGridControl:DataGridTemplateColumn.CellEditingTemplate>
<dataGridControl:DataGridTemplateColumn.CellTemplate>
<DataTemplate>
<TextBlock Text="{Binding DatasetIndex}"/>
</DataTemplate>
</dataGridControl:DataGridTemplateColumn.CellTemplate>
</dataGridControl:DataGridTemplateColumn>
Agora, minha única pergunta é: como podemos fazer com que essa coluna de modelo personalizado pareça exatamente como uma coluna de combobox de grade de dados normal e também mostrar o nome do conjunto de dados na caixa de texto em vez do índice?
Como você programaticamente usa um conversor no caminho do membro de exibição ou usa um itemtemplate com o conversor no código por trás?
var listView = new ListView
{
ItemsSource = SomeObject,
HorizontalAlignment = HorizontalAlignment.Right,
SelectionMode=ListViewSelectionMode.Single,
DisplayMemberPath=<---use converter here
};
var stackPanel = new StackPanel();
stackPanel.Children.Add(listView);
Exemplo xaml equivalente para referência:
<ListView ItemsSource="{x:Bind Object, Mode=OneWay}">
<ListView.ItemTemplate>
<DataTemplate>
<TextBlock Text="{Binding Converter={StaticResource Converter}}"/>
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
Em um contexto de grade de dados onde há uma vinculação bidirecional no item selecionado, como você evita que o código g.cs atualize a vinculação se várias linhas forem selecionadas?
<dataGridControl:DataGrid
SelectedItem="{x:Bind Model.SelectedItem, Mode=TwoWay}"
Em um cenário em que o usuário seleciona várias linhas, ele usa a última linha selecionada quando você seleciona várias e, claro, considerando que é uma ligação bidirecional, você não pode limpar a propriedade do item selecionado no modelo de exibição sem limpar toda a seleção do DataGrid. O item selecionado no modelo de exibição é enganoso, considerando que várias linhas são selecionadas, e não a última.
Quero ter uma visibilidade baseada na contagem de selecteditems de um datagrid. No entanto, isso não parece funcionar no winui, mas funcionou bem no WPF?
Conversor:
public object Convert(object value, Type targetType, object parameter, string language)
{
if ((int)value == 1)
return Visibility.Visible;
else
return Visibility.Collapsed;
}
Vinculativo:
Visibility="{Binding ElementName=DataGrid,Path=SelectedItems.Count,
Converter={StaticResource Converter}}"
Também tentei com x:Bind:
Visibility="{x:Bind DataGrid.SelectedItems.Count,
Converter={StaticResource CountToVisibilityConverter}}"
Parece-me que a propriedade não é atualizada. Se eu coloco um breakpoint no conversor, ele só é chamado no estágio inicial.
Usando o DataGrid no Community ToolKit. Como alguém pode vincular um eventhandler para escutar uma alteração no DataGridComboBoxColumn?
A maneira correta de criar uma propriedade observável no mvvm é
[ObservableProperty]
private string _name;
No entanto, em certos cenários você precisa alterar o conjunto. Como fazer isso corretamente sem declarar o Public?
private double _currentProgressPct;
public double CurrentProgressPct
{
get => _currentProgressPct;
set
{
_dispatcherQueue.TryEnqueue(DispatcherQueuePriority.High, () =>
{
SetProperty(ref _currentProgressPct, value);
});
}
}
Pelo que entendi, a primeira abordagem é a correta de acordo com o mvvm, mas a última não?
Além disso, de acordo com este artigo, você precisa implementar a interface INotifyPropertyChanged. No entanto, isso é necessário ao usar [ObservableProperty]? Pelo que entendi, o kit de ferramentas da comunidade precisa que a classe seja um observableobject?
O motivo pelo qual estou fazendo as últimas perguntas é porque não parece que as ligações são liberadas ao inspecionar com o profiler de desempenho com foco na memória. De acordo com outro tópico que encontrei, isso pode ser porque INotifyProperyChanged não está implementado?
Estou tentando deixar o usuário escolher em um combobox no datagrid, mas não consigo encontrar a abordagem correta. Eu tentei usar vinculação e x:bind. Qual seria a melhor abordagem? Eu imagino que o código a seguir esteja correto, mas estou faltando alguma coisa.
Modelo de visualização
public partial class CustomerModel : ObservableObject
{
private ObservableCollection<DataType> _objects;
public ObservableCollection<DataType> Objects
{
get => _objects;
set => SetProperty(ref _objects, value);
}
private ObservableCollection<string> _field;
public ObservableCollection<string> Field
{
get => _field;
set => SetProperty(ref _field, value);
}
public CustomerModel()
{
Objects = new();
Field = new ObservableCollection<string> { "Test", "Test" };
}
public class DataType : ObservableObject
{
public int ID { get; set; }
public string Name { get; set; }
public string Caption { get; set; }
public bool Numeric { get; set; }
public DataType()
{
}
}
}
.xaml
<controls:DataGrid
x:Name="dataGrid1" KeyDown="dataGrid1_KeyDown"
ItemsSource="{x:Bind Model.Objects}" AutoGenerateColumns="False" >
<controls:DataGrid.Columns>
<controls:DataGridComboBoxColumn Header="Field" ItemsSource="{x:Bind Model.Field}" Tag="Field"/>
</controls:DataGrid.Columns>
</controls:DataGrid>
Código atualizado que agora está funcionando. Isso parece bom?
public partial class CustomerModel : ObservableObject
{
public enum Choices { A, B, C }
[ObservableProperty]
private ObservableCollection<DataType> _objects;
public CustomerModel()
{
Objects = new();
var data = new DataType();
Objects.Add(data);
}
public static Choices[] ChoicesOptions { get; } = Enum.GetValues<Choices>();
public partial class DataType : ObservableObject
{
public int ID { get; set; }
public string Name { get; set; }
public string Caption { get; set; }
public bool Numeric { get; set; }
[ObservableProperty]
private Choices _choice;
}
}
.xaml
<controls:DataGridComboBoxColumn Header="Field" Binding="{Binding Choice}" ItemsSource="{x:Bind local:CustomerModel.ChoicesOptions, Mode=OneTime}" Tag="Field"
Além disso, notei que você instancia o viewmodel no arquivo codebehind, isso é necessário? Eu não:
public sealed partial class DataGridPage : Page
{
public DataGridPage()
{
this.InitializeComponent();
}
}