Question

Lets say I have 3 or more Slider and each slider can have a value from 0 to 100.
However I want that the sum of all slider values is <= 100. In case I have 4 slider everyones max value would be 25.

Every slider has a binding to a double variable and every time the user uses a slider (tick frequency 0.1) I calculate the sum and set other slider back or if necessary set the same slider back, so that the sum is <= 100.

The problem is, that the calculation needs a decent amount of time and in the meantime the user can set illegal values. I would like to solve this by blocking the UI until the calculation is over. Basically the opposite of the desired responsiveness.

Other ideas and suggestions to solve the slider thing are welcome.

slider binding

public BindingList<WLCToolParameter> WLCParameter
   {
       get { return _toolParameter; }
       set { _toolParameter = value; }
   }

should be instant – not really 🙁

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MCDA.Entity;
using MCDA.Extensions;

namespace MCDA.Model
{
    class ProportionalDistributionStrategy : IWeightDistributionStrategy
    {
        public void Distribute<T>(IList<T> listOfToolParameter) where T : class, IToolParameter
        {

            if (listOfToolParameter.Count == 0)
                return;

            IToolParameter lastWeightChangedToolParameter =  lastWeightChangedToolParameter = listOfToolParameter[0].LastWeightChangedToolParameter;

            double sumOfAllWeights = listOfToolParameter.Sum(t =>t.Weight);

            //we have to rescale
            if (sumOfAllWeights > 100)
            {
                double overrun = sumOfAllWeights - 100;

                //how much do we have without the locked and the last changed?
                double availableSpace = listOfToolParameter.Where(t => t.IsLocked == false && t != lastWeightChangedToolParameter).Sum(t => t.Weight);

                //we have enough by taking from the non locked
                if (availableSpace > overrun)
                {
                    //lets remove proportional
                    double sumOfChangeableWeights = listOfToolParameter.Where(t => t.IsLocked == false && t != lastWeightChangedToolParameter).Sum(t => t.Weight);

                    //in case we have only one element that is suitable we can directly remove all from this one
                    if (listOfToolParameter.Where(t => t.IsLocked == false && t.Weight > 0 && t != lastWeightChangedToolParameter).Count() == 1)
                    {
                        listOfToolParameter.Where(t => t.IsLocked == false && t.Weight > 0 && t != lastWeightChangedToolParameter).ForEach(t => t.Weight = t.Weight - overrun);
                        return;
                    }
                    listOfToolParameter.Where(t => t.IsLocked == false && t.Weight > 0 && t != lastWeightChangedToolParameter).ForEach(t => t.Weight = t.Weight - (sumOfChangeableWeights / (sumOfChangeableWeights - t.Weight)) * overrun);
                }

                //we have to resize also the latest change, but we try to keep as much as possible of the latest change
                else
                {
                    //lets set them to zero
                    listOfToolParameter.Where(t => t.IsLocked == false && t != lastWeightChangedToolParameter).ForEach(t => t.Weight = 0);

                    //how much are we still over?
                    double stillOver = listOfToolParameter.Sum(t => t.Weight) - 100;

                    //and cut from the last changed
                    listOfToolParameter.Where(t => t == lastWeightChangedToolParameter).ForEach(t => t.Weight -= stillOver);
                }
            }
        }
    }
}

Answer 1

It looks like you are not making use of data binding. Here is a simple example – just add your calculation logic to the calculating method. The UI will update itself. Note this is a crude example. I am not sure I would implement it this way. Also be careful of using decimals in your numbers. If you use this with foreign languages / regional settings with a comma as the decimal separator – it will error out.

<Window x:Class="WpfApplication3.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>
        <StackPanel>
            <Slider Margin="10" Value="{Binding Path=Value1}" />
            <TextBlock Text="{Binding Path=Value1}" />
            <Slider Margin="10" Value="{Binding Path=Value2}" />
            <TextBlock Text="{Binding Path=Value2}" />
            <Slider Margin="10" Value="{Binding Path=Value3}" />
            <TextBlock Text="{Binding Path=Value3}" />
        </StackPanel>

    </Grid>
</Window>

Code Behind (MVVM approach this would be in your View Model)

namespace WpfApplication3
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window, INotifyPropertyChanged
    {
        public MainWindow()
        {
            InitializeComponent();
            DataContext = this;
        }

        private double _value1;
        public double Value1
        {
            get { return _value1; }
            set
            {
                if(value != _value1)
                {
                    _value1 = value;
                    DoMyCalculations(_value1, _value2, _value3);
                    NotifyPropertChanged("Value1");
                }
            }
        }
        private double _value2;
        public double Value2
        {
            get { return _value2; }
            set
            {
                if (value != _value2)
                {
                    _value2 = value;
                    DoMyCalculations(_value1, _value2, _value3);
                    NotifyPropertChanged("Value2");
                }
            }
        }
        private double _value3;
        public double Value3
        {
            get { return _value3; }
            set
            {
                if (value != _value3)
                {
                    _value3 = value;
                    DoMyCalculations(_value1, _value2, _value3);
                    NotifyPropertChanged("Value3");
                }
            }
        }
        private bool isCalculating = false;
        private void DoMyCalculations(double value1, double value2, double value3)
        {
            if (isCalculating)
                return;
            isCalculating = true;

            // Perform logic to reset here


            isCalculating = false;
        }

        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Notify of Property Changed event
        /// </summary>
        /// <param name="propertyName"></param>
        public void NotifyPropertChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}