WPF

<DrawingImage x:Key="FindIcon"/>
<DrawingImage x:Key="SearchIcon"/>

<Image Source="{StaticResource FindIcon}"/>
<Image Source="{StaticResource SearchIcon}"/>

<Image Source="{Binding ChooseIcon}"/>

public DrawingImage ChooseIcon
{
    get
    {
        if (useFindIcon)
        {
            return ???; // how to reference the static resource "FindIcon"
        }
        else if (useSearchIcon)
        {
            return ???;// how to reference the static resource "SearchIcon"
        }
    }
}

Jobs
    Ship To Address

Builders

Foremen
    Foreman Phone

Vendors
Vendor Locations
Vendor Contacts
    Vendor Contact Email
    Vendor Contact Phone

Delivery Method (Will Call or Delivery)
Delivery Date 
For Will Call
    Picked Up By (employee)
    Picked Up By Email
    Picked Up By Email
    Picked Up Location (From Vendor Locations)

Items (The items on the PO)

    <Window.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="pack://application:,,,/MyCompany.Presentation;component/Themes/MyCompany.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Window.Resources>
<!-- ... -->
           <Button Content="Right-Click Me!" Click="ButtonBase_OnClick">
                <Button.ContextMenu>
                <ContextMenu x:Name="MyContextMenu">
                    <MenuItem Header="a" IsCheckable="True" Command="{Binding DoACommand}" IsChecked="{Binding IsAChecked, Mode=OneWay}"/>
                    <MenuItem Header="b" IsCheckable="True" Command="{Binding DoBCommand}" IsChecked="{Binding IsBChecked, Mode=OneWay}"/>
                    </ContextMenu>
                </Button.ContextMenu>
            </Button>

private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
    if (MyContextMenu.ContextMenu != null)
        MyContextMenu.ContextMenu.IsOpen = true;
}

The name 'InitializeComponent' does not exist in the current context

<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}">
        <Border Name="Pulse1" 
                CornerRadius="{Binding Path=ControlCornerRadius1,ElementName=WaitTickerControl,FallbackValue=10}"
                Height="{Binding Path=PulseHeight1,ElementName=WaitTickerControl,FallbackValue=50}"
                Width="{Binding Path=PulseWidth1,ElementName=WaitTickerControl,FallbackValue=10}"
                Margin="10,10,0,0"
                Background="{Binding Path=ControlBackground1,ElementName=WaitTickerControl,FallbackValue=#4287f5}" 
                HorizontalAlignment="Left" VerticalAlignment="Top"/>

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

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

</UserControl>

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

        private Beating? _Timer1 = null;
        private Beating? _Timer2 = null;
        private Beating? _Timer3 = null;

        public int PulseCurrentValue1
        {
            get { return (int)GetValue(PulseCurrentValue1Property); }
            set { SetValue(PulseCurrentValue1Property, value); }
        }
        public static readonly DependencyProperty PulseCurrentValue1Property =
            DependencyProperty.Register("PulseCurrentValue1", typeof(int), typeof(WaitTicker_Control), 
                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_Control), 
                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_Control), 
                new PropertyMetadata(40));
        public int PulseMaxValue
        {
            get { return (int)GetValue(PulseMaxValueProperty); }
            set { SetValue(PulseMaxValueProperty, value); }
        }
        public static readonly DependencyProperty PulseMaxValueProperty =
            DependencyProperty.Register("PulseMaxValue", typeof(int), typeof(WaitTicker_Control), 
                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_Control), 
                new PropertyMetadata(10));
        public int PulseIncrementValue
        {
            get { return (int)GetValue(PulseIncrementValueProperty); }
            set { SetValue(PulseIncrementValueProperty, value); }
        }
        public static readonly DependencyProperty PulseIncrementValueProperty =
            DependencyProperty.Register("PulseIncrementValue", typeof(int), typeof(WaitTicker_Control), 
                new PropertyMetadata(1));

        public double PulseSpeedValue
        {
            get { return (double)GetValue(PulseSpeedValueProperty); }
            set { SetValue(PulseSpeedValueProperty, value); }
        }
        public static readonly DependencyProperty PulseSpeedValueProperty =
            DependencyProperty.Register("PulseSpeedValue", typeof(double), typeof(WaitTicker_Control), 
                new PropertyMetadata(0.01));

        #endregion

        public WaitTicker_Control()
        {
                InitializeComponent();
                _Timer1 = new Beating(Pulse1, this, PulseCurrentValue1, "Pulse1");
                _Timer2 = new Beating(Pulse2, this, PulseCurrentValue2, "Pulse2");
                _Timer3 = new Beating(Pulse3, this, PulseCurrentValue3, "Pulse3");
        }
    }

internal class Beating
{
    private static Timer? _BeatingTimer=null;
    private Dispatcher? _Dispatcher=null;

    private WaitTicker_Control _waitTicker_Control;
    private Border? _pulse { get; set; } = null;
    private bool _Direction = false;

    public string BeatName { get; set; } = string.Empty;
    public int InitialValue { get; set; } = 50;
    public int Increment { get; set; } = 1;
    public int MinValue { get; set; } = 0;
    public int MaxValue { get; set; } = 100;


    public Beating(
        Border pulse,
        WaitTicker_Control waitTicker_Control,
        int initialValue,
        string iBeatName)
    {
        _waitTicker_Control = waitTicker_Control;
        _pulse = pulse;

        MinValue = waitTicker_Control.PulseMinValue;
        MaxValue = waitTicker_Control.PulseMaxValue;
        InitialValue = initialValue;
        Increment = waitTicker_Control.PulseIncrementValue;
        BeatName = iBeatName;

        _Dispatcher = Dispatcher.CurrentDispatcher;

        Beating._BeatingTimer = new Timer();
        Beating._BeatingTimer.Interval = waitTicker_Control.PulseSpeedValue;

        Beating._BeatingTimer.Elapsed += OnTimedEvent;
        Beating._BeatingTimer.AutoReset = true;
        Beating._BeatingTimer.Enabled = true;
    }

    public void StartTimer()
    {
        Beating._BeatingTimer?.Start();
    }

    public void StopTimer()
    {
        Beating._BeatingTimer?.Stop();
    }
    private void OnTimedEvent(Object source, ElapsedEventArgs e)
    {
        try
        {
            if (this._Direction == false)
            {
                this.InitialValue = this.InitialValue - this.Increment;
                if (this.InitialValue < this.MinValue)
                    this._Direction = true;
            }
            else
            {
                this.InitialValue = this.InitialValue + this.Increment;
                if (this.InitialValue > this.MaxValue)
                    this._Direction = false;
            }
            if (this._pulse != null)
            {
                this._Dispatcher?.Invoke(new Action(() => { this._pulse.Height = this.InitialValue; }));
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}