Can Not Bin to Dependency Property in Custom Control - WPF Discussion Boards

Re: Using Dependency Property's to Affect Non WPF Property's

Richard MacCutchan3-Sep-22 21:01

Richard MacCutchan

3-Sep-22 21:01

It would appear that you have two accounts. Please close the one you do not need.

Re: Using Dependency Property's to Affect Non WPF Property's

mjeeves3-Sep-22 8:58

mjeeves

3-Sep-22 8:58

So I have three last issues, thanks for all the help

1) if I use the usercontrol name "Name="WaitTickerCustomControl" then the Custom Control disappears in the Main Window odd.

2) The directly Bound dependency property are bound but nothing updates

3) The Indirectly Bound property's only affect the third ticker odd...

Thanks for the help im learning alot.

Madaxe

XAML Custom Control

<pre><UserControl x:Class="Testing.CustomControls.WaitTicker_CustomControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:Testing.CustomControls"
             mc:Ignorable="d" 
             d:DesignHeight="70" d:DesignWidth="60"
             Name="WaitTickerCustomControl">
    <Grid Name="WaitTickerMainGrid" Visibility="{Binding Path=ControlHideShow,ElementName=WaitTickerCustomControl, FallbackValue=Visible}">
        <Border Name="Pulse1" 
                CornerRadius="{Binding Path=ControlCornerRadius1,ElementName=WaitTickerCustomControl,FallbackValue=10}"
                Height="{Binding Path=PulseHeight1,ElementName=WaitTickerCustomControl,FallbackValue=50}"
                Width="{Binding Path=PulseWidth1,ElementName=WaitTickerCustomControl,FallbackValue=10}"
                Margin="10,10,0,0"
                Background="{Binding Path=ControlBackground1,ElementName=WaitTickerCustomControl,FallbackValue=#4287f5}" 
                HorizontalAlignment="Left" VerticalAlignment="Top"/>

        <Border Name="Pulse2"
                CornerRadius="{Binding Path=ControlCornerRadius2,ElementName=WaitTickerCustomControl,FallbackValue=10}"
                Height="{Binding Path=PulseHeight2,ElementName=WaitTickerCustomControl,FallbackValue=50}"
                Width="{Binding Path=PulseWidth2,ElementName=WaitTickerCustomControl,FallbackValue=10}"
                Margin="25,10,0,0"
                Background="{Binding Path=ControlBackground2,ElementName=WaitTickerCustomControl,FallbackValue=#4287f5}" 
                HorizontalAlignment="Left" VerticalAlignment="Top"/>

        <Border Name="Pulse3"
                CornerRadius="{Binding Path=ControlCornerRadius3,ElementName=WaitTickerCustomControl,FallbackValue=10}"
                Height="{Binding Path=PulseHeight3,ElementName=WaitTickerCustomControl,FallbackValue=50}"
                Width="{Binding Path=PulseWidth3,ElementName=WaitTickerCustomControl,FallbackValue=10}"
                Margin="40,10,0,0"
                Background="{Binding Path=ControlBackground3,ElementName=WaitTickerCustomControl,FallbackValue=#4287f5}" 
                HorizontalAlignment="Left" VerticalAlignment="Top"/>
    </Grid>
</UserControl>

XAML Code Behind

public partial class WaitTicker_CustomControl : UserControl, INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler? PropertyChanged;
        protected void OnPropertyChanged([CallerMemberName] string? propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        //Directly Bound to XAML
        public Visibility ControlHideShow
        {
            get { return (Visibility)GetValue(ControlHideShowProperty); }
            set { SetValue(ControlHideShowProperty, value); }
        }
        public static readonly DependencyProperty ControlHideShowProperty =
            DependencyProperty.Register("ControlHideShow", typeof(Visibility), 
                typeof(WaitTicker_CustomControl),
               new PropertyMetadata(Visibility.Hidden));
        public int ControlCornerRadius1
        {
            get { return (int)GetValue(ControlCornerRadius1Property); }
            set { SetValue(ControlCornerRadius1Property, value); }
        }
        public static readonly DependencyProperty ControlCornerRadius1Property =
            DependencyProperty.Register("ControlCornerRadius1", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(10));
        public int ControlCornerRadius2
        {
            get { return (int)GetValue(ControlCornerRadius2Property); }
            set { SetValue(ControlCornerRadius2Property, value); }
        }
        public static readonly DependencyProperty ControlCornerRadius2Property =
            DependencyProperty.Register("ControlCornerRadius2", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(10));
        public int ControlCornerRadius3
        {
            get { return (int)GetValue(ControlCornerRadius3Property); }
            set { SetValue(ControlCornerRadius3Property, value); }
        }
        public static readonly DependencyProperty ControlCornerRadius3Property =
            DependencyProperty.Register("ControlCornerRadius3", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(10));
        public int PulseHeight1
        {
            get { return (int)GetValue(PulseHeight1Property); }
            set { SetValue(PulseHeight1Property, value); }
        }
        public static readonly DependencyProperty PulseHeight1Property =
            DependencyProperty.Register("PulseHeight1", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(1));
        public int PulseHeight2
        {
            get { return (int)GetValue(PulseHeight2Property); }
            set { SetValue(PulseHeight2Property, value); }
        }
        public static readonly DependencyProperty PulseHeight2Property =
            DependencyProperty.Register("PulseHeight2", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(25));
        public int PulseHeight3
        {
            get { return (int)GetValue(PulseHeight3Property); }
            set { SetValue(PulseHeight3Property, value); }
        }
        public static readonly DependencyProperty PulseHeight3Property =
            DependencyProperty.Register("PulseHeight3", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(50));
        public int PulseWidth1
        {
            get { return (int)GetValue(PulseWidth1Property); }
            set { SetValue(PulseWidth1Property, value); }
        }
        public static readonly DependencyProperty PulseWidth1Property =
            DependencyProperty.Register("PulseWidth1", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(20));
        public int PulseWidth2
        {
            get { return (int)GetValue(PulseWidth2Property); }
            set { SetValue(PulseWidth2Property, value); }
        }
        public static readonly DependencyProperty PulseWidth2Property =
            DependencyProperty.Register("PulseWidth2", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(20));
        public int PulseWidth3
        {
            get { return (int)GetValue(PulseWidth3Property); }
            set { SetValue(PulseWidth3Property, value); }
        }
        public static readonly DependencyProperty PulseWidth3Property =
            DependencyProperty.Register("PulseWidth3", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(0));

        public Brush ControlBackground1
        {
            get { return (Brush)GetValue(ControlBackground1Property); }
            set { SetValue(ControlBackground1Property, value); }
        }
        public static readonly DependencyProperty ControlBackground1Property =
            DependencyProperty.Register("ControlBackground1", typeof(Brush),
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(Brushes.Blue));
        public Brush ControlBackground2
        {
            get { return (Brush)GetValue(ControlBackground2Property); }
            set { SetValue(ControlBackground2Property, value); }
        }
        public static readonly DependencyProperty ControlBackground2Property =
            DependencyProperty.Register("ControlBackground2", typeof(Brush),
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(Brushes.Blue));
        public Brush ControlBackground3
        {
            get { return (Brush)GetValue(ControlBackground3Property); }
            set { SetValue(ControlBackground3Property, value); }
        }
        public static readonly DependencyProperty ControlBackground3Property =
            DependencyProperty.Register("ControlBackground3", typeof(Brush),
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(Brushes.Blue));


        private Beating _timer1;
        private Beating _timer2;
        private Beating _timer3;

        // Indirectly Bound to XAML
        public int PulseIncrementValue
        {
            get { return (int)GetValue(PulseIncrementValueProperty); }
            set { SetValue(PulseIncrementValueProperty, value); }
        }
        public static readonly DependencyProperty PulseIncrementValueProperty =
            DependencyProperty.Register("PulseIncrementValue", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(1));
        public int PulseMaxValue
        {
            get { return (int)GetValue(PulseMaxValueProperty); }
            set { SetValue(PulseMaxValueProperty, value); }
        }
        public static readonly DependencyProperty PulseMaxValueProperty =
            DependencyProperty.Register("PulseMaxValue", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(50));
        public int PulseMinValue
        {
            get { return (int)GetValue(PulseMinValueProperty); }
            set { SetValue(PulseMinValueProperty, value); }
        }
        public static readonly DependencyProperty PulseMinValueProperty =
            DependencyProperty.Register("PulseMinValue", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(10));
        public double PulseSpeedValue
        {
            get { return (double)GetValue(PulseSpeedValueProperty); }
            set { SetValue(PulseSpeedValueProperty, value); }
        }
        public static readonly DependencyProperty PulseSpeedValueProperty =
            DependencyProperty.Register("PulseSpeedValue", typeof(double), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(0.01));
        public int PulseCurrentValue1
        {
            get { return (int)GetValue(PulseCurrentValue1Property); }
            set { SetValue(PulseCurrentValue1Property, value); }
        }
        public static readonly DependencyProperty PulseCurrentValue1Property =
            DependencyProperty.Register("PulseCurrentValue1", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(5));
        public int PulseCurrentValue2
        {
            get { return (int)GetValue(PulseCurrentValue2Property); }
            set { SetValue(PulseCurrentValue2Property, value); }
        }
        public static readonly DependencyProperty PulseCurrentValue2Property =
            DependencyProperty.Register("PulseCurrentValue2", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(20));
        public int PulseCurrentValue3
        {
            get { return (int)GetValue(PulseCurrentValue3Property); }
            set { SetValue(PulseCurrentValue3Property, value); }
        }
        public static readonly DependencyProperty PulseCurrentValue3Property =
            DependencyProperty.Register("PulseCurrentValue3", typeof(int), 
                typeof(WaitTicker_CustomControl),
                new PropertyMetadata(40));

        private Beating CreateBeating(string beatName, DependencyProperty valueProperty, Border pulse)
        {
            Beating result = new Beating((int)GetValue(valueProperty), PulseIncrementValue, PulseMinValue, PulseMaxValue, beatName, PulseSpeedValue);

            // Push changes to the control's properties down to the Beating instance:
            SetBinding(PulseIncrementValueProperty, new Binding(nameof(Beating.Increment)) { Source = result, Mode = BindingMode.OneWayToSource });
            SetBinding(PulseMinValueProperty, new Binding(nameof(Beating.MinValue)) { Source = result, Mode = BindingMode.OneWayToSource });
            SetBinding(PulseMaxValueProperty, new Binding(nameof(Beating.MaxValue)) { Source = result, Mode = BindingMode.OneWayToSource });
            SetBinding(PulseSpeedValueProperty, new Binding(nameof(Beating.Speed)) { Source = result, Mode = BindingMode.OneWayToSource });

            // Bind the border's height to the Beating's value:
            pulse.SetBinding(FrameworkElement.HeightProperty, new Binding(nameof(Beating.Value)) { Source = result, Mode = BindingMode.OneWay });

            return result;
        }
        public WaitTicker_CustomControl()
        {
            InitializeComponent();
            _timer1 = CreateBeating("Pulse1", PulseCurrentValue1Property, Pulse1);
            _timer2 = CreateBeating("Pulse2", PulseCurrentValue2Property, Pulse2);
            _timer3 = CreateBeating("Pulse3", PulseCurrentValue3Property, Pulse3);
        }
    }
    internal sealed class Beating : INotifyPropertyChanged
    {
        private readonly Timer? _timer;
        private int _value;
        private bool _direction;

        public int Value
        {
            get { return _value; }
            set
            {
                if (value != _value)
                {
                    _value = value;
                    OnPropertyChanged();
                }
            }
        }
        public int Increment { get; set; }
        public int MinValue { get; set; }
        public int MaxValue { get; set; }
        public string BeatName { get; }

        public double Speed
        {
            get { return _timer.Interval; }
            set { _timer.Interval = value; }
        }

        public event PropertyChangedEventHandler? PropertyChanged;
        private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        public Beating(int initialValue, int increment, int minValue, int maxValue, string beatName, double speed)
        {
            _value = initialValue;
            Increment = increment;
            MinValue = minValue;
            MaxValue = maxValue;
            BeatName = beatName;

            _timer = new Timer
            {
                Interval = speed,
                AutoReset = true,
                Enabled = true,
            };

            _timer.Elapsed += OnTimedEvent;
        }
        public void StartTimer()
        {
            _timer.Start();
        }
        public void StopTimer()
        {
            _timer.Stop();
        }
        private void OnTimedEvent(Object source, ElapsedEventArgs e)
        {
            if (!_direction)
            {
                Value -= Increment;
                if (Value < MinValue)
                    _direction = true;
            }
            else
            {
                Value += Increment;
                if (Value > MaxValue)
                    _direction = false;
            }
        }
    }

Custom Control Implementation

<Window x:Class="Testing.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Testing" xmlns:customcontrols="clr-namespace:Testing.CustomControls"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <customcontrols:WaitTicker_CustomControl
            Height="100" Width="100"
            VerticalAlignment="Top" HorizontalAlignment="Left"
            Margin="10 10 0 0"
            PulseMaxValue="100"
            PulseMinValue="5"
            PulseHeight1="100"
            PulseHeight2="100"
            PulseHeight3="100"
            PulseSpeedValue="50"
            ControlCornerRadius1="5"
            ControlCornerRadius2="5"
            ControlCornerRadius3="5"
            ControlBackground1="Aquamarine"
            ControlBackground2="Yellow"
            ControlBackground3="Orange"/>
    </Grid>
</Window>

modified 3-Sep-22 18:15pm.

Re: Using Dependency Property's to Affect Non WPF Property's

Gerry Schmitz4-Sep-22 8:57

Gerry Schmitz

4-Sep-22 8:57

ElementName=WaitTickerCustomControl

A pointless assignment. Which is addressed by a simple

this.DataContext = this;

in the constructor. (Which may be required in any case).

All your "dependency properties", on first glance, look like a reach that could have been defaulted in code behind; complimented with an "options" flyout / popup.

"Before entering on an understanding, I have meditated for a long time, and have foreseen what might happen. It is not genius which reveals to me suddenly, secretly, what I have to say or to do in a circumstance unexpected by other people; it is reflection, it is meditation." - Napoleon I

Re: Using Dependency Property's to Affect Non WPF Property's

Richard Deeming5-Sep-22 21:11

Richard Deeming

5-Sep-22 21:11

Gerry Schmitz wrote:
this.DataContext = this;

Which will almost certainly bring you back to the original problem[^].

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Re: Using Dependency Property's to Affect Non WPF Property's

Gerry Schmitz6-Sep-22 5:34

Gerry Schmitz

6-Sep-22 5:34

Each control has a DataContext. You can let them default to a "higher up", or set them each explicitly. Setting a DataContext is rarely an issue; omitting them is. The excess of pointless XAML and dependency properties is obfuscating the problem. That was my (indirect) point.

Re: Using Dependency Property's to Affect Non WPF Property's

Marc Jeeves6-Sep-22 10:05

Marc Jeeves

6-Sep-22 10:05

So how would you guys build this custom control?

Re: Using Dependency Property's to Affect Non WPF Property's

Gerry Schmitz6-Sep-22 13:19

Gerry Schmitz

6-Sep-22 13:19

You're actually creating a user control; and not a "custom control".

The "simplest" way to create a user control is to add properties {get;set;} to the UC in the .cs; bind the controls in the .xaml to the properties in the .cs; and implement INotifyPropertyChanged (which for a "few" controls, can be issued with "no contol name" without any hit on performance). The DataContext of the UC is the UC; i.e. "this".

Any time there is new data, you load the properties and call "property changed" which updates the UI. If it's a two-way UI, data moves to the properties and events on the controls get invoked (e.g. text changed).

That's the pattern, and most everything else has a "smell". Dead | X|

$Shucks | :-\$

Anything else that happens is a function of what events the user control wants to "surface" (e.g. a request queued to an observable collection or file watcher).

Can Not Bin to Dependency Property in Custom Control

Marc Jeeves1-Sep-22 6:26

Marc Jeeves

1-Sep-22 6:26

Within my View Model i have a property and backer to bind to the ControlHideShow, I don't get a bind error but if I change the default value in the View Model nothing happens. If I don't bind in the Implementation XAML and set Visible or Hidden it works so why can I not bind to the ViewModel

thanks

Madaxe

Public interface ViewModel
{
        Visibility ControlHideShow { get; set; }
}
    
public class MainPageViewModel : ViewModelBase, IMainPageViewModel
{
    
        private Visibility _controlHideShow = Visibility.Visible;
        public Visibility ControlHideShow
        {
            get => _controlHideShow;
            set{ _controlHideShow = value;  OnPropertyChanged(nameof(ControlHideShow)); }
        }
}

Implementation XML

<controls:WaitTicker_Control
                        x:Name="WaitCursor"
                        Width="60" Height="30"
                        Grid.Row="4" Grid.Column="1" 
                        HorizontalAlignment="Center" 
                        VerticalAlignment="Center"
                        Margin="100 0 0 0"
                
                        ControlBackground1="#FFA5CD3C"
                        ControlBackground2="#FF208D2F" 
                        ControlBackground3="#FF206A8D" 
                
                        ControlCornerRadius1="2" 
                        ControlCornerRadius2="2"
                        ControlCornerRadius3="2"           
                
                        PulseHeight1="25" PulseHeight2="25" PulseHeight3="25"
                        PulseWidth1="5" PulseWidth2="5" PulseWidth3="5"
                        PulseMaxValue="50" PulseMinValue="5"
                        PulseSpeedValue="0.0001"
                        PulseIncrementValue="1" 
                        PulseCurrentValue1="1" PulseCurrentValue2="25" PulseCurrentValue3="50"
                        ControlHideShow="{Binding ControlHideShow}"/>

Custom Control XAML

<UserControl x:Class="DES.CATIAV6.ClearanceContactAndClashManager.UI.Controls.WaitTicker_Control"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
                 xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
                 xmlns:local="clr-namespace:DES.CATIAV6.ClearanceContactAndClashManager.UI.Controls"
                 mc:Ignorable="d" 
                 DataContext="{Binding RelativeSource={RelativeSource Self}}" 
                 Background="Transparent" 
                 Height="70" Width="60"
                 Name="WaitTickerControl">
        <Grid Name="WaitTickerMainGrid" Visibility="{Binding Path=ControlHideShow,ElementName=WaitTickerControl, FallbackValue=Hidden}">

        </Grid>
    
    </UserControl>

Custom Control Code Behind

    public partial class WaitTicker_Control : UserControl, INotifyPropertyChanged
        {
            public event PropertyChangedEventHandler? PropertyChanged;
    
            protected void OnPropertyChanged([CallerMemberName] string? propertyName = null)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }

    
            public Visibility ControlHideShow
            {
                get { return (Visibility)GetValue(ControlHideShowProperty); }
                set { SetValue(ControlHideShowProperty, value); }
            }
            public static readonly DependencyProperty ControlHideShowProperty =
                DependencyProperty.Register("ControlHideShow", typeof(Visibility), typeof(WaitTicker_Control),
                   new PropertyMetadata(Visibility.Hidden));

Re: Can Not Bin to Dependency Property in Custom Control

Richard Deeming1-Sep-22 6:35

Richard Deeming

1-Sep-22 6:35

I suspect it's because you've set the DataContext on the <UserControl> element. That means the <controls:WaitTickerControl ... ControlHideShow="{Binding ControlHideShow}" /> is binding the user control's property to itself, rather than the property from the inherited viewmodel.

Try removing the DataContext assignment - you've specified the ElementName in your binding, so you shouldn't need it.

XAML

<UserControl 
    x:Class="DES.CATIAV6.ClearanceContactAndClashManager.UI.Controls.WaitTicker_Control"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
    xmlns:local="clr-namespace:DES.CATIAV6.ClearanceContactAndClashManager.UI.Controls"
    mc:Ignorable="d" 
    Background="Transparent" 
    Height="70" Width="60"
    Name="WaitTickerControl"
>
    <Grid Name="WaitTickerMainGrid" Visibility="{Binding Path=ControlHideShow, ElementName=WaitTickerControl, FallbackValue=Hidden}">
        ...
    </Grid>
</UserControl>

If that doesn't work, try setting the DataContext on the Grid instead of the UserControl.

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Re: Can Not Bin to Dependency Property in Custom Control

Marc Jeeves1-Sep-22 6:47

Marc Jeeves

1-Sep-22 6:47

Spot on, sometimes its the wood for the trees.

thanks a bunch

Madaxe

What is the most common MVVM framework used today?

Code4Ever21-Jul-22 7:26

Code4Ever

21-Jul-22 7:26

I searched the Internet and realized that there are different frameworks for the MVVM pattern used in WPF applications. One of them which is mostly used is MVVM Light but unfortunately, its development has ceased. I want to know what MVVM framework is mostly used and if there are adequate tutorials on the Internet for it.

Re: What is the most common MVVM framework used today?

Pete O'Hanlon21-Jul-22 21:21

Pete O'Hanlon

21-Jul-22 21:21

It's hard to say which framework is the most common because stats like this aren't readily available. If you are just looking for a supported framework then Microsoft has a framework available as part of the community toolkit; it's well documented[^].

Advanced TypeScript Programming Projects

Re: What is the most common MVVM framework used today?

Richard Deeming21-Jul-22 21:22

Richard Deeming

21-Jul-22 21:22

There are several options listed here:
GitHub - Carlos487/awesome-wpf: A collection of awesome WPF resources, libraries and UI controls.[^]

Or you could always roll your own.

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

Re: What is the most common MVVM framework used today?

Gerry Schmitz22-Jul-22 5:10

Gerry Schmitz

22-Jul-22 5:10

When doing Windows, I'll take MS first over the alternatives.

Quote:
Prism 8 is a fully open source version of the Prism guidance originally produced by Microsoft patterns & practices.

Introduction to Prism | Prism

Re: What is the most common MVVM framework used today?

Pete O'Hanlon24-Jul-22 11:32

Pete O'Hanlon

24-Jul-22 11:32

Prism isn't Microsoft offering. It's maintained by Brian Lagunas and Dan Siegel. Both are MVPs, but work for other companies.

Advanced TypeScript Programming Projects

Re: What is the most common MVVM framework used today?

Gerry Schmitz25-Jul-22 20:43

Gerry Schmitz

25-Jul-22 20:43

So, the fact that someone else now maintains it negates my opinion even though Microsoft originated it? Run with that.

Re: What is the most common MVVM framework used today?

Pete O'Hanlon25-Jul-22 21:30

Pete O'Hanlon

25-Jul-22 21:30

It has been so long away from the P&P camp that Microsoft's influence on it has long been expunged. The simple fact is, Microsoft has their own MVVM offering which has nothing to do with Prism. Your statement implied that Prism was a Microsoft offering and it hasn't been for a long time so if you are pushing someone to Microsoft's offering, at least make sure it is Microsoft that is offering it.

Advanced TypeScript Programming Projects

Is it possible to do event handling in the ViewModel?

Code4Ever16-Jul-22 6:39

Code4Ever

16-Jul-22 6:39

I have the following code in Code-Behind section of my WPF MVVM:

public EquipmentIdentity()
        {
            InitializeComponent();
            EquipmentIdentityViewModel eivm = new EquipmentIdentityViewModel();
            DataContext = eivm;
            dataPager.OnDemandLoading += dataPager_OnDemandLoading;
        }

private void dataPager_OnDemandLoading(object sender, Syncfusion.UI.Xaml.Controls.DataPager.OnDemandLoadingEventArgs args)
        {
            //some codes here
        }

How can I remove this event handling from Code-Behind and take it to the ViewModel?

When I use dataPager.OnDemandLoading += dataPager_OnDemandLoading; in ViewModel it shows this error:

Quote:
System.NullReferenceException: 'Object reference not set to an instance of an object.'

Re: Is it possible to do event handling in the ViewModel?

Gerry Schmitz17-Jul-22 6:06

Gerry Schmitz

17-Jul-22 6:06

View models are about "data"; not "behavior".

mvc - Should MVVM models have behaviour? - Software Engineering Stack Exchange

modified 17-Jul-22 12:22pm.

DICOM TAGS

harol espinosa26-Jun-22 5:20

harol espinosa

26-Jun-22 5:20

Hello everyone , I need your help , how to get dicom tags with wpf and openFileDialog Confused | :confused:

Re: DICOM TAGS

Dave Kreskowiak26-Jun-22 6:13

Dave Kreskowiak

26-Jun-22 6:13

Reading DICOM file tags has nothing to do with WPF or the OpenFile dialog. WPF is a presentation (UI) framework, and an OpenFile dialog just gets a filepath from the user.

Reading the tag data is just straight up reading a file. There's plenty of info on the web on it. You just have to search for "C# read DICOM tags[^]" and start reading.

Asking questions is a skill
CodeProject Forum Guidelines
Google: C# How to debug code
Seriously, go read these articles.

Dave Kreskowiak

Development

User 156237373-Jun-22 10:46

User 15623737

3-Jun-22 10:46

Just starting out in learning VS, C# and Xaml.
I am much older than most on here...I am betting anyway.

EE-PE that has folded a 20+ year Consulting Engineering business and trying to see if somehow I can do something in programming. I have struggled through and have a desktop app completed but have NO idea what is next.

Do a need to get a business certificate of some type so the app can load on others computers ?
Do I search out companies that market third party development ?
Do I partner with another developer to handle the marketing aspect ?

First choice of mine would be to find a Cleveland Ohio developer I could actually talk with, but have had zero success in this path.

modified 7-Jul-22 21:01pm.

Re: Development

Gerry Schmitz4-Jun-22 10:35

Gerry Schmitz

4-Jun-22 10:35

Or you can put it in the Microsoft store.

Publish traditional desktop apps through Microsoft Store | Microsoft Developer

Re: Development

User 156237376-Jun-22 4:22

User 15623737

6-Jun-22 4:22

Thank you for taking the time to respond.

Quickly looking over the link brings up even more questions.
Appears my weak general knowledge will keep this just a hobby.

modified 7-Jul-22 21:01pm.

TreeView in ControlTemplate - Handling Item Expanded

Kevin Marois27-Apr-22 9:46

Kevin Marois

27-Apr-22 9:46

I am creating a Custom Control and in the control template I have a TreeView class in it.

<Style TargetType="{x:Type local:MyControl}">

    <Setter Property="Template">

        <Setter.Value>

            <ControlTemplate TargetType="{x:Type local:MyControl}">

                <Border Background="{TemplateBinding Background}"
                    BorderBrush="{TemplateBinding BorderBrush}"
                    BorderThickness="{TemplateBinding BorderThickness}">

                    <TreeView ItemsSource="{Binding TreeDataItems, RelativeSource={RelativeSource TemplatedParent}}">

                        <TreeView.Resources>
                            <HierarchicalDataTemplate DataType="{x:Type local:TreeItem}" ItemsSource="{Binding Children}">
                                <TextBlock Text="{Binding Path=Caption}" />
                            </HierarchicalDataTemplate>
                        </TreeView.Resources>

                        <i:Interaction.Triggers>
                            <i:EventTrigger EventName="TreeViewItem.Expanded">
                                <i:InvokeCommandAction Command="{Binding TreeItemExpandedCommand, RelativeSource={RelativeSource TemplatedParent}}"
                                                    CommandParameter="{Binding}">

                                </i:InvokeCommandAction>
                            </i:EventTrigger>
                        </i:Interaction.Triggers>

                    </TreeView>
                </Border>

            </ControlTemplate>

        </Setter.Value>

    </Setter>

</Style>

In the code behind I have

private ICommand _TreeItemExpandedCommand;
public ICommand TreeItemExpandedCommand
{
    get
    {
        if (_TreeItemExpandedCommand == null)
            _TreeItemExpandedCommand = new RelayCommand<object>(p => TreeItemExpandedExecuted(p));
        return _TreeItemExpandedCommand;
    }
}

private void TreeItemExpandedExecuted(object args)
{
}

When I expand a node nothing happens. There are no binding errors, and the Command's getter fires when it starts, but the TreeItemExpandedExecuted never fires.

I tried using the event itself:

<TreeView TreeViewItem.Expanded="TreeViewItem_Expanded">
    ...
</TreeView/>

and

 private void TreeViewItem_Expanded(object sender, RoutedEventArgs e)
    {
        TreeViewItem tvi = e.OriginalSource as TreeViewItem;
        if (tvi != null)
        {
          // Do something
        }
    }

But still nothing.

I'm guessing this has something to do with this all being in a ControlTemplate. Anyone see what's wrong here?

If it's not broken, fix it until it is.
Everything makes sense in someone's mind.
Ya can't fix stupid.

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.