path: root/Software/Visual_Studio/Tango.BL/Entities/HardwareDancerBase.cs

//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Tango Observables Generator
// 
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated. Do not modify!
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Xml.Serialization;
using Newtonsoft.Json;
using System.Linq;
using Tango.DAL.Remote.DB;
using Tango.Core;
using System.ComponentModel;
using Tango.Core.CustomAttributes;

namespace Tango.BL.Entities
{
    [Table("HARDWARE_DANCERS")]
    public abstract class HardwareDancerBase : ObservableEntity<HardwareDancer>
    {

        public event EventHandler<Boolean> GradualChanged;

        public event EventHandler<Double> KChanged;

        public event EventHandler<Double> XChanged;

        public event EventHandler<Int32> PulsePerMmSpringChanged;

        public event EventHandler<Int32> MaximalMovementMmChanged;

        public event EventHandler<Int32> ZeroPointChanged;

        public event EventHandler<Int32> ResolutionBitsChanged;

        public event EventHandler<Int32> ArmLengthChanged;

        public event EventHandler<Boolean> AssemblyDirectionRightChanged;

        public event EventHandler<Boolean> AccelerateOnTensionRaiseChanged;

        public event EventHandler<Boolean> ActiveChanged;

        public event EventHandler<HardwareDancerType> HardwareDancerTypeChanged;

        public event EventHandler<HardwareVersion> HardwareVersionChanged;

        protected String _hardwaredancertypeguid;

        /// <summary>
        /// Gets or sets the hardwaredancerbase hardware dancer type guid.
        /// </summary>

        [Column("HARDWARE_DANCER_TYPE_GUID")]
        [ForeignKey("HardwareDancerType")]

        public  String HardwareDancerTypeGuid
        {
            get 
            {
                return _hardwaredancertypeguid; 
            }

            set 
            {
                if (_hardwaredancertypeguid != value)
                {
                    _hardwaredancertypeguid = value;

                }
            }
        }

        protected String _hardwareversionguid;

        /// <summary>
        /// Gets or sets the hardwaredancerbase hardware version guid.
        /// </summary>

        [Column("HARDWARE_VERSION_GUID")]
        [ForeignKey("HardwareVersion")]

        public  String HardwareVersionGuid
        {
            get 
            {
                return _hardwareversionguid; 
            }

            set 
            {
                if (_hardwareversionguid != value)
                {
                    _hardwareversionguid = value;

                }
            }
        }

        protected Boolean _gradual;

        /// <summary>
        /// Gets or sets the hardwaredancerbase gradual.
        /// </summary>

        [Column("GRADUAL")]

        public  Boolean Gradual
        {
            get 
            {
                return _gradual; 
            }

            set 
            {
                if (_gradual != value)
                {
                    _gradual = value;

                    OnGradualChanged(value);

                }
            }
        }

        protected Double _k;

        /// <summary>
        /// Gets or sets the hardwaredancerbase k.
        /// </summary>

        [Column("K")]

        public  Double K
        {
            get 
            {
                return _k; 
            }

            set 
            {
                if (_k != value)
                {
                    _k = value;

                    OnKChanged(value);

                }
            }
        }

        protected Double _x;

        /// <summary>
        /// Gets or sets the hardwaredancerbase x.
        /// </summary>

        [Column("X")]

        public  Double X
        {
            get 
            {
                return _x; 
            }

            set 
            {
                if (_x != value)
                {
                    _x = value;

                    OnXChanged(value);

                }
            }
        }

        protected Int32 _pulsepermmspring;

        /// <summary>
        /// Gets or sets the hardwaredancerbase pulse per mm spring.
        /// </summary>

        [Column("PULSE_PER_MM_SPRING")]

        public  Int32 PulsePerMmSpring
        {
            get 
            {
                return _pulsepermmspring; 
            }

            set 
            {
                if (_pulsepermmspring != value)
                {
                    _pulsepermmspring = value;

                    OnPulsePerMmSpringChanged(value);

                }
            }
        }

        protected Int32 _maximalmovementmm;

        /// <summary>
        /// Gets or sets the hardwaredancerbase maximal movement mm.
        /// </summary>

        [Column("MAXIMAL_MOVEMENT_MM")]

        public  Int32 MaximalMovementMm
        {
            get 
            {
                return _maximalmovementmm; 
            }

            set 
            {
                if (_maximalmovementmm != value)
                {
                    _maximalmovementmm = value;

                    OnMaximalMovementMmChanged(value);

                }
            }
        }

        protected Int32 _zeropoint;

        /// <summary>
        /// Gets or sets the hardwaredancerbase zero point.
        /// </summary>

        [Column("ZERO_POINT")]

        public  Int32 ZeroPoint
        {
            get 
            {
                return _zeropoint; 
            }

            set 
            {
                if (_zeropoint != value)
                {
                    _zeropoint = value;

                    OnZeroPointChanged(value);

                }
            }
        }

        protected Int32 _resolutionbits;

        /// <summary>
        /// Gets or sets the hardwaredancerbase resolution bits.
        /// </summary>

        [Column("RESOLUTION_BITS")]

        public  Int32 ResolutionBits
        {
            get 
            {
                return _resolutionbits; 
            }

            set 
            {
                if (_resolutionbits != value)
                {
                    _resolutionbits = value;

                    OnResolutionBitsChanged(value);

                }
            }
        }

        protected Int32 _armlength;

        /// <summary>
        /// Gets or sets the hardwaredancerbase arm length.
        /// </summary>

        [Column("ARM_LENGTH")]

        public  Int32 ArmLength
        {
            get 
            {
                return _armlength; 
            }

            set 
            {
                if (_armlength != value)
                {
                    _armlength = value;

                    OnArmLengthChanged(value);

                }
            }
        }

        protected Boolean _assemblydirectionright;

        /// <summary>
        /// Gets or sets the hardwaredancerbase assembly direction right.
        /// </summary>

        [Column("ASSEMBLY_DIRECTION_RIGHT")]

        public  Boolean AssemblyDirectionRight
        {
            get 
            {
                return _assemblydirectionright; 
            }

            set 
            {
                if (_assemblydirectionright != value)
                {
                    _assemblydirectionright = value;

                    OnAssemblyDirectionRightChanged(value);

                }
            }
        }

        protected Boolean _accelerateontensionraise;

        /// <summary>
        /// Gets or sets the hardwaredancerbase accelerate on tension raise.
        /// </summary>

        [Column("ACCELERATE_ON_TENSION_RAISE")]

        public  Boolean AccelerateOnTensionRaise
        {
            get 
            {
                return _accelerateontensionraise; 
            }

            set 
            {
                if (_accelerateontensionraise != value)
                {
                    _accelerateontensionraise = value;

                    OnAccelerateOnTensionRaiseChanged(value);

                }
            }
        }

        protected Boolean _active;

        /// <summary>
        /// Gets or sets the hardwaredancerbase active.
        /// </summary>

        [Column("ACTIVE")]

        public  Boolean Active
        {
            get 
            {
                return _active; 
            }

            set 
            {
                if (_active != value)
                {
                    _active = value;

                    OnActiveChanged(value);

                }
            }
        }

        protected HardwareDancerType _hardwaredancertype;

        /// <summary>
        /// Gets or sets the hardwaredancerbase hardware dancer types.
        /// </summary>

        [XmlIgnore]
        [JsonIgnore]
        public virtual HardwareDancerType HardwareDancerType
        {
            get 
            {
                return _hardwaredancertype; 
            }

            set 
            {
                if (_hardwaredancertype != value)
                {
                    _hardwaredancertype = value;

                    if (HardwareDancerType != null)
                    {
                        HardwareDancerTypeGuid = HardwareDancerType.Guid;
                    }

                    OnHardwareDancerTypeChanged(value);

                }
            }
        }

        protected HardwareVersion _hardwareversion;

        /// <summary>
        /// Gets or sets the hardwaredancerbase hardware versions.
        /// </summary>

        [XmlIgnore]
        [JsonIgnore]
        public virtual HardwareVersion HardwareVersion
        {
            get 
            {
                return _hardwareversion; 
            }

            set 
            {
                if (_hardwareversion != value)
                {
                    _hardwareversion = value;

                    if (HardwareVersion != null)
                    {
                        HardwareVersionGuid = HardwareVersion.Guid;
                    }

                    OnHardwareVersionChanged(value);

                }
            }
        }

        /// <summary>
        /// Called when the Gradual has changed.
        /// </summary>
        protected virtual void OnGradualChanged(Boolean gradual)
        {
            GradualChanged?.Invoke(this, gradual);
            RaisePropertyChanged(nameof(Gradual));
        }

        /// <summary>
        /// Called when the K has changed.
        /// </summary>
        protected virtual void OnKChanged(Double k)
        {
            KChanged?.Invoke(this, k);
            RaisePropertyChanged(nameof(K));
        }

        /// <summary>
        /// Called when the X has changed.
        /// </summary>
        protected virtual void OnXChanged(Double x)
        {
            XChanged?.Invoke(this, x);
            RaisePropertyChanged(nameof(X));
        }

        /// <summary>
        /// Called when the PulsePerMmSpring has changed.
        /// </summary>
        protected virtual void OnPulsePerMmSpringChanged(Int32 pulsepermmspring)
        {
            PulsePerMmSpringChanged?.Invoke(this, pulsepermmspring);
            RaisePropertyChanged(nameof(PulsePerMmSpring));
        }

        /// <summary>
        /// Called when the MaximalMovementMm has changed.
        /// </summary>
        protected virtual void OnMaximalMovementMmChanged(Int32 maximalmovementmm)
        {
            MaximalMovementMmChanged?.Invoke(this, maximalmovementmm);
            RaisePropertyChanged(nameof(MaximalMovementMm));
        }

        /// <summary>
        /// Called when the ZeroPoint has changed.
        /// </summary>
        protected virtual void OnZeroPointChanged(Int32 zeropoint)
        {
            ZeroPointChanged?.Invoke(this, zeropoint);
            RaisePropertyChanged(nameof(ZeroPoint));
        }

        /// <summary>
        /// Called when the ResolutionBits has changed.
        /// </summary>
        protected virtual void OnResolutionBitsChanged(Int32 resolutionbits)
        {
            ResolutionBitsChanged?.Invoke(this, resolutionbits);
            RaisePropertyChanged(nameof(ResolutionBits));
        }

        /// <summary>
        /// Called when the ArmLength has changed.
        /// </summary>
        protected virtual void OnArmLengthChanged(Int32 armlength)
        {
            ArmLengthChanged?.Invoke(this, armlength);
            RaisePropertyChanged(nameof(ArmLength));
        }

        /// <summary>
        /// Called when the AssemblyDirectionRight has changed.
        /// </summary>
        protected virtual void OnAssemblyDirectionRightChanged(Boolean assemblydirectionright)
        {
            AssemblyDirectionRightChanged?.Invoke(this, assemblydirectionright);
            RaisePropertyChanged(nameof(AssemblyDirectionRight));
        }

        /// <summary>
        /// Called when the AccelerateOnTensionRaise has changed.
        /// </summary>
        protected virtual void OnAccelerateOnTensionRaiseChanged(Boolean accelerateontensionraise)
        {
            AccelerateOnTensionRaiseChanged?.Invoke(this, accelerateontensionraise);
            RaisePropertyChanged(nameof(AccelerateOnTensionRaise));
        }

        /// <summary>
        /// Called when the Active has changed.
        /// </summary>
        protected virtual void OnActiveChanged(Boolean active)
        {
            ActiveChanged?.Invoke(this, active);
            RaisePropertyChanged(nameof(Active));
        }

        /// <summary>
        /// Called when the HardwareDancerType has changed.
        /// </summary>
        protected virtual void OnHardwareDancerTypeChanged(HardwareDancerType hardwaredancertype)
        {
            HardwareDancerTypeChanged?.Invoke(this, hardwaredancertype);
            RaisePropertyChanged(nameof(HardwareDancerType));
        }

        /// <summary>
        /// Called when the HardwareVersion has changed.
        /// </summary>
        protected virtual void OnHardwareVersionChanged(HardwareVersion hardwareversion)
        {
            HardwareVersionChanged?.Invoke(this, hardwareversion);
            RaisePropertyChanged(nameof(HardwareVersion));
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HardwareDancerBase" /> class.
        /// </summary>
        public HardwareDancerBase() : base()
        {
        }
    }
}