Question

I am developing a WPF application. I am basically a C++ developer and have recently shifted to C#. In my application I have dynamically generated set of buttons which perform a specific operation.

Each button has a frequency to it which is captured and is used to perform some operation. In my C++ Application, I had created as follows:

static const char *freqs[MAX_CLOCK_RANGE] = 
{
"12.0.",12.288","15.36","19.2","23.0","24.0","26.0" //MAX_CLOCK_RANGE is 7
};

for(int i = 0; i < MAX_CLOCK_RANGE; i++)
{
    buttonText = String(T("Set ")) + String(freqs[i])+ String(T(" MHz"));
    m_buttonSetFreq[i] = new TextButton(buttonText, String::empty);
    m_buttonSetFreq[i]->addButtonListener(this);
    addAndMakeVisible(m_buttonSetFreq[i]);      
}

int cnt = 0;
while(cnt < MAX_CLOCK_RANGE)
{
   if(button == m_buttonSetFreq[cnt])
   break;
   cnt++;       
}
if(cnt < MAX_CLOCK_RANGE)
{
   unsigned int val = String(freqs[cnt]).getDoubleValue() * 1000.0;
}
sendBuf[numBytes++] = 0x00; //SendBuf is unsigned char
sendBuf[numBytes++] = 0x00;
sendBuf[numBytes++] = (val >> 8) & 0xFF;
sendBuf[numBytes++] = val & 0xFF;

Thus it takes the value of freq from the char array and performs operation on it as given above. Cnt has the value of which particular button is clicked and takes the frequency of button clicked. I did it in my WPF app as follows:

XAML:

<ListBox x:Name="SetButtonList" ItemsSource="{Binding}" >
                    <ListBox.ItemTemplate>
                        <DataTemplate >
                            <Grid>
                                <Button Name="FreqButton" Content="{Binding Path=SetButtonFreq}" Command="{Binding ElementName=SetButtonList, Path=DataContext.SetFreqCommand}" />                                    
                            </Grid>
                        </DataTemplate>
                    </ListBox.ItemTemplate>
</ListBox>

Xaml.cs:

ClockViewModel mClock = new ClockViewModel();

mClock.Add(new ClockModel("Set 12.0 MHz"));
mClock.Add(new ClockModel("Set 12.288 MHz"));
mClock.Add(new ClockModel("Set 15.36 MHz"));
mClock.Add(new ClockModel("Set 19.2 MHz"));
mClock.Add(new ClockModel("Set 23.0 MHz"));
mClock.Add(new ClockModel("Set 24.0 MHz"));
mClock.Add(new ClockModel("Set 26.0 MHz"));
SetButtonList.DataContext = mClock;

ViewModel:

ClockModel mCModel = new ClockModel();

private ICommand mSetFreqCommand;
    public ICommand SetFreqCommand
    {
        get
        {
            if (mSetFreqCommand == null)
                mSetFreqCommand = new DelegateCommand(new Action(SetFreqCommandExecuted), new Func<bool>(SetFreqCommandCanExecute));

            return mSetFreqCommand;
        }
        set
        {
            mSetFreqCommand = value;
        }
    }

    public bool SetFreqCommandCanExecute()
    {
        return true;
    }

    public void SetFreqCommandExecuted()
    {
        //How can I retrieve the Frequency of button clicked and perform same operation as done in C++
    }

Model:

public String SetButtonFreq {get; set;}

Is it possible to get the freq of each button clicked and perform the same steps as done in C++ code??? Please help 🙂

Answer 1

Two possible solutions.

1st: Bind to command in ViewModel instance of each button:

<Window x:Class="WpfTest.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <ListBox ItemsSource="{Binding Clocks}">
            <ListBox.ItemTemplate>
                <DataTemplate>
                <Button Content="{Binding Frequency}" 
                        Command="{Binding SetFrequency}"/>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
</Window>

With following View Models and code behind:

class ClockViewModel  // DataContext of ListBoxItem
{
    public double Frequency { get; set; }
    public ICommand SetFrequency
    {
        get
        {
            return new DelegateCommand((obj) => { 
              double freq = this.Frequency; 
              // ...
            });
        }
    }
}

class WindowViewModel 
{
    ObservableCollection<ClockViewModel> clocks_ = 
        new ObservableCollection<ClockViewModel>();
    public ObservableCollection<ClockViewModel> Clocks {get {return clocks_;}}
}

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        var viewModel = new WindowViewModel();
        viewModel.Clocks.Add(new ClockViewModel() { Frequency = 10.123 });
        viewModel.Clocks.Add(new ClockViewModel() { Frequency = 42.0 });
        viewModel.Clocks.Add(new ClockViewModel() { Frequency = 3.14 });

        DataContext = viewModel;
    }
}

2nd): If the Command should be part of the windows view model you could use CommandParameter (Updated to show the in “Set 3.13 Mhz” format):

<Window x:Class="WpfTest.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            Title="MainWindow" Height="350" Width="525">
  <Grid>
    <ListBox Name="list" ItemsSource="{Binding Clocks}">
      <ListBox.ItemTemplate>
        <DataTemplate>
          <Button Command="{Binding Path=DataContext.SetFrequency, 
                          ElementName=list}"
                  CommandParameter="{Binding}">
            <Button.Content>
              <TextBlock>
                <Run>Set </Run>
                <Run Text="{Binding Frequency}"/>
                <Run> Mhz</Run>
              </TextBlock>
            </Button.Content>
          </Button>
        </DataTemplate>
      </ListBox.ItemTemplate>
    </ListBox>
  </Grid>
</Window>

This passes the buttons data context to the command:

class ClockViewModel
{
    public double Frequency { get; set; }
}

class WindowViewModel
{
    ObservableCollection<ClockViewModel> clocks_ = new ObservableCollection<ClockViewModel>();
    public ObservableCollection<ClockViewModel> Clocks
    {
        get { return clocks_; }
    }

    public ICommand SetFrequency
    {
        get{
            return new DelegateCommand((obj) => 
            { 
                var clock = obj as ClockViewModel;
                DoSendBufStuffWithFrequency(clock.Frequency);
            });}
    }

    private void DoSendBufStuffWithFrequency(double frequency)
    {
    }
}