New Extra Inks DB, PMR, BL.

3 files changed, 1482 insertions, 0 deletions

diff --git a/Software/Visual_Studio/Tango.BL/Entities/JobRunBase.cs b/Software/Visual_Studio/Tango.BL/Entities/JobRunBase.cs
index 54685f7ee..327d8ac85 100644
--- a/Software/Visual_Studio/Tango.BL/Entities/JobRunBase.cs
+++ b/Software/Visual_Studio/Tango.BL/Entities/JobRunBase.cs
@@ -117,6 +117,80 @@ namespace Tango.BL.Entities
 
         public event EventHandler<Int64> VioletQuantityChanged;
 
+        public event EventHandler<Int64> TwTransparentInkQuantityChanged;
+
+        public event EventHandler<Int64> C1TiQuantityChanged;
+
+        public event EventHandler<Int64> TwCyanQuantityChanged;
+
+        public event EventHandler<Int64> TwLightCyanQuantityChanged;
+
+        public event EventHandler<Int64> TwMagentaQuantityChanged;
+
+        public event EventHandler<Int64> TwLightMagentaQuantityChanged;
+
+        public event EventHandler<Int64> TwYellowQuantityChanged;
+
+        public event EventHandler<Int64> TwLightYellowQuantityChanged;
+
+        public event EventHandler<Int64> C1YellowQuantityChanged;
+
+        public event EventHandler<Int64> C1LightYellowQuantityChanged;
+
+        public event EventHandler<Int64> TwBlackQuantityChanged;
+
+        public event EventHandler<Int64> TwVioletQuantityChanged;
+
+        public event EventHandler<Int64> TwLightVioletQuantityChanged;
+
+        public event EventHandler<Int64> CtBlueQuantityChanged;
+
+        public event EventHandler<Int64> CtLightBlueQuantityChanged;
+
+        public event EventHandler<Int64> CtRubineQuantityChanged;
+
+        public event EventHandler<Int64> CtLightRubineQuantityChanged;
+
+        public event EventHandler<Int64> CtOrangeQuantityChanged;
+
+        public event EventHandler<Int64> CtLightOrangeQuantityChanged;
+
+        public event EventHandler<Int64> CtNavyQuantityChanged;
+
+        public event EventHandler<Int64> HdBlueQuantityChanged;
+
+        public event EventHandler<Int64> HdLightBlueQuantityChanged;
+
+        public event EventHandler<Int64> HdRubineQuantityChanged;
+
+        public event EventHandler<Int64> HdLightRubineQuantityChanged;
+
+        public event EventHandler<Int64> HdOrangeQuantityChanged;
+
+        public event EventHandler<Int64> HdLightOrangeQuantityChanged;
+
+        public event EventHandler<Int64> HdNavyQuantityChanged;
+
+        public event EventHandler<Int64> HdLightNavyQuantityChanged;
+
+        public event EventHandler<Int64> AmBlueQuantityChanged;
+
+        public event EventHandler<Int64> AmLightBlueQuantityChanged;
+
+        public event EventHandler<Int64> AmRedQuantityChanged;
+
+        public event EventHandler<Int64> AmLightRedQuantityChanged;
+
+        public event EventHandler<Int64> AmOrangeQuantityChanged;
+
+        public event EventHandler<Int64> AmLightOrangeQuantityChanged;
+
+        public event EventHandler<Int64> AmYellowQuantityChanged;
+
+        public event EventHandler<Int64> AmLightYellowQuantityChanged;
+
+        public event EventHandler<Int64> AmBlackQuantityChanged;
+
         protected String _machineguid;
 
         /// <summary>
@@ -1459,6 +1533,1005 @@ namespace Tango.BL.Entities
             }
         }
 
+        protected Int64 _twtransparentinkquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw transparent ink quantity.
+        /// </summary>
+
+        [Column("TW_TRANSPARENT_INK_QUANTITY")]
+
+        public  Int64 TwTransparentInkQuantity
+        {
+            get 
+            {
+                return _twtransparentinkquantity; 
+            }
+
+            set 
+            {
+                if (_twtransparentinkquantity != value)
+                {
+                    _twtransparentinkquantity = value;
+
+                    OnTwTransparentInkQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _c1tiquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase c1 ti quantity.
+        /// </summary>
+
+        [Column("C1_TI_QUANTITY")]
+
+        public  Int64 C1TiQuantity
+        {
+            get 
+            {
+                return _c1tiquantity; 
+            }
+
+            set 
+            {
+                if (_c1tiquantity != value)
+                {
+                    _c1tiquantity = value;
+
+                    OnC1TiQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _twcyanquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw cyan quantity.
+        /// </summary>
+
+        [Column("TW_CYAN_QUANTITY")]
+
+        public  Int64 TwCyanQuantity
+        {
+            get 
+            {
+                return _twcyanquantity; 
+            }
+
+            set 
+            {
+                if (_twcyanquantity != value)
+                {
+                    _twcyanquantity = value;
+
+                    OnTwCyanQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _twlightcyanquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw light cyan quantity.
+        /// </summary>
+
+        [Column("TW_LIGHT_CYAN_QUANTITY")]
+
+        public  Int64 TwLightCyanQuantity
+        {
+            get 
+            {
+                return _twlightcyanquantity; 
+            }
+
+            set 
+            {
+                if (_twlightcyanquantity != value)
+                {
+                    _twlightcyanquantity = value;
+
+                    OnTwLightCyanQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _twmagentaquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw magenta quantity.
+        /// </summary>
+
+        [Column("TW_MAGENTA_QUANTITY")]
+
+        public  Int64 TwMagentaQuantity
+        {
+            get 
+            {
+                return _twmagentaquantity; 
+            }
+
+            set 
+            {
+                if (_twmagentaquantity != value)
+                {
+                    _twmagentaquantity = value;
+
+                    OnTwMagentaQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _twlightmagentaquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw light magenta quantity.
+        /// </summary>
+
+        [Column("TW_LIGHT_MAGENTA_QUANTITY")]
+
+        public  Int64 TwLightMagentaQuantity
+        {
+            get 
+            {
+                return _twlightmagentaquantity; 
+            }
+
+            set 
+            {
+                if (_twlightmagentaquantity != value)
+                {
+                    _twlightmagentaquantity = value;
+
+                    OnTwLightMagentaQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _twyellowquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw yellow quantity.
+        /// </summary>
+
+        [Column("TW_YELLOW_QUANTITY")]
+
+        public  Int64 TwYellowQuantity
+        {
+            get 
+            {
+                return _twyellowquantity; 
+            }
+
+            set 
+            {
+                if (_twyellowquantity != value)
+                {
+                    _twyellowquantity = value;
+
+                    OnTwYellowQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _twlightyellowquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw light yellow quantity.
+        /// </summary>
+
+        [Column("TW_LIGHT_YELLOW_QUANTITY")]
+
+        public  Int64 TwLightYellowQuantity
+        {
+            get 
+            {
+                return _twlightyellowquantity; 
+            }
+
+            set 
+            {
+                if (_twlightyellowquantity != value)
+                {
+                    _twlightyellowquantity = value;
+
+                    OnTwLightYellowQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _c1yellowquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase c1 yellow quantity.
+        /// </summary>
+
+        [Column("C1_YELLOW_QUANTITY")]
+
+        public  Int64 C1YellowQuantity
+        {
+            get 
+            {
+                return _c1yellowquantity; 
+            }
+
+            set 
+            {
+                if (_c1yellowquantity != value)
+                {
+                    _c1yellowquantity = value;
+
+                    OnC1YellowQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _c1lightyellowquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase c1 light yellow quantity.
+        /// </summary>
+
+        [Column("C1_LIGHT_YELLOW_QUANTITY")]
+
+        public  Int64 C1LightYellowQuantity
+        {
+            get 
+            {
+                return _c1lightyellowquantity; 
+            }
+
+            set 
+            {
+                if (_c1lightyellowquantity != value)
+                {
+                    _c1lightyellowquantity = value;
+
+                    OnC1LightYellowQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _twblackquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw black quantity.
+        /// </summary>
+
+        [Column("TW_BLACK_QUANTITY")]
+
+        public  Int64 TwBlackQuantity
+        {
+            get 
+            {
+                return _twblackquantity; 
+            }
+
+            set 
+            {
+                if (_twblackquantity != value)
+                {
+                    _twblackquantity = value;
+
+                    OnTwBlackQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _twvioletquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw violet quantity.
+        /// </summary>
+
+        [Column("TW_VIOLET_QUANTITY")]
+
+        public  Int64 TwVioletQuantity
+        {
+            get 
+            {
+                return _twvioletquantity; 
+            }
+
+            set 
+            {
+                if (_twvioletquantity != value)
+                {
+                    _twvioletquantity = value;
+
+                    OnTwVioletQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _twlightvioletquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase tw light violet quantity.
+        /// </summary>
+
+        [Column("TW_LIGHT_VIOLET_QUANTITY")]
+
+        public  Int64 TwLightVioletQuantity
+        {
+            get 
+            {
+                return _twlightvioletquantity; 
+            }
+
+            set 
+            {
+                if (_twlightvioletquantity != value)
+                {
+                    _twlightvioletquantity = value;
+
+                    OnTwLightVioletQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _ctbluequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase ct blue quantity.
+        /// </summary>
+
+        [Column("CT_BLUE_QUANTITY")]
+
+        public  Int64 CtBlueQuantity
+        {
+            get 
+            {
+                return _ctbluequantity; 
+            }
+
+            set 
+            {
+                if (_ctbluequantity != value)
+                {
+                    _ctbluequantity = value;
+
+                    OnCtBlueQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _ctlightbluequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase ct light blue quantity.
+        /// </summary>
+
+        [Column("CT_LIGHT_BLUE_QUANTITY")]
+
+        public  Int64 CtLightBlueQuantity
+        {
+            get 
+            {
+                return _ctlightbluequantity; 
+            }
+
+            set 
+            {
+                if (_ctlightbluequantity != value)
+                {
+                    _ctlightbluequantity = value;
+
+                    OnCtLightBlueQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _ctrubinequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase ct rubine quantity.
+        /// </summary>
+
+        [Column("CT_RUBINE_QUANTITY")]
+
+        public  Int64 CtRubineQuantity
+        {
+            get 
+            {
+                return _ctrubinequantity; 
+            }
+
+            set 
+            {
+                if (_ctrubinequantity != value)
+                {
+                    _ctrubinequantity = value;
+
+                    OnCtRubineQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _ctlightrubinequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase ct light rubine quantity.
+        /// </summary>
+
+        [Column("CT_LIGHT_RUBINE_QUANTITY")]
+
+        public  Int64 CtLightRubineQuantity
+        {
+            get 
+            {
+                return _ctlightrubinequantity; 
+            }
+
+            set 
+            {
+                if (_ctlightrubinequantity != value)
+                {
+                    _ctlightrubinequantity = value;
+
+                    OnCtLightRubineQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _ctorangequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase ct orange quantity.
+        /// </summary>
+
+        [Column("CT_ORANGE_QUANTITY")]
+
+        public  Int64 CtOrangeQuantity
+        {
+            get 
+            {
+                return _ctorangequantity; 
+            }
+
+            set 
+            {
+                if (_ctorangequantity != value)
+                {
+                    _ctorangequantity = value;
+
+                    OnCtOrangeQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _ctlightorangequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase ct light orange quantity.
+        /// </summary>
+
+        [Column("CT_LIGHT_ORANGE_QUANTITY")]
+
+        public  Int64 CtLightOrangeQuantity
+        {
+            get 
+            {
+                return _ctlightorangequantity; 
+            }
+
+            set 
+            {
+                if (_ctlightorangequantity != value)
+                {
+                    _ctlightorangequantity = value;
+
+                    OnCtLightOrangeQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _ctnavyquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase ct navy quantity.
+        /// </summary>
+
+        [Column("CT_NAVY_QUANTITY")]
+
+        public  Int64 CtNavyQuantity
+        {
+            get 
+            {
+                return _ctnavyquantity; 
+            }
+
+            set 
+            {
+                if (_ctnavyquantity != value)
+                {
+                    _ctnavyquantity = value;
+
+                    OnCtNavyQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _hdbluequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase hd blue quantity.
+        /// </summary>
+
+        [Column("HD_BLUE_QUANTITY")]
+
+        public  Int64 HdBlueQuantity
+        {
+            get 
+            {
+                return _hdbluequantity; 
+            }
+
+            set 
+            {
+                if (_hdbluequantity != value)
+                {
+                    _hdbluequantity = value;
+
+                    OnHdBlueQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _hdlightbluequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase hd light blue quantity.
+        /// </summary>
+
+        [Column("HD_LIGHT_BLUE_QUANTITY")]
+
+        public  Int64 HdLightBlueQuantity
+        {
+            get 
+            {
+                return _hdlightbluequantity; 
+            }
+
+            set 
+            {
+                if (_hdlightbluequantity != value)
+                {
+                    _hdlightbluequantity = value;
+
+                    OnHdLightBlueQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _hdrubinequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase hd rubine quantity.
+        /// </summary>
+
+        [Column("HD_RUBINE_QUANTITY")]
+
+        public  Int64 HdRubineQuantity
+        {
+            get 
+            {
+                return _hdrubinequantity; 
+            }
+
+            set 
+            {
+                if (_hdrubinequantity != value)
+                {
+                    _hdrubinequantity = value;
+
+                    OnHdRubineQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _hdlightrubinequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase hd light rubine quantity.
+        /// </summary>
+
+        [Column("HD_LIGHT_RUBINE_QUANTITY")]
+
+        public  Int64 HdLightRubineQuantity
+        {
+            get 
+            {
+                return _hdlightrubinequantity; 
+            }
+
+            set 
+            {
+                if (_hdlightrubinequantity != value)
+                {
+                    _hdlightrubinequantity = value;
+
+                    OnHdLightRubineQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _hdorangequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase hd orange quantity.
+        /// </summary>
+
+        [Column("HD_ORANGE_QUANTITY")]
+
+        public  Int64 HdOrangeQuantity
+        {
+            get 
+            {
+                return _hdorangequantity; 
+            }
+
+            set 
+            {
+                if (_hdorangequantity != value)
+                {
+                    _hdorangequantity = value;
+
+                    OnHdOrangeQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _hdlightorangequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase hd light orange quantity.
+        /// </summary>
+
+        [Column("HD_LIGHT_ORANGE_QUANTITY")]
+
+        public  Int64 HdLightOrangeQuantity
+        {
+            get 
+            {
+                return _hdlightorangequantity; 
+            }
+
+            set 
+            {
+                if (_hdlightorangequantity != value)
+                {
+                    _hdlightorangequantity = value;
+
+                    OnHdLightOrangeQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _hdnavyquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase hd navy quantity.
+        /// </summary>
+
+        [Column("HD_NAVY_QUANTITY")]
+
+        public  Int64 HdNavyQuantity
+        {
+            get 
+            {
+                return _hdnavyquantity; 
+            }
+
+            set 
+            {
+                if (_hdnavyquantity != value)
+                {
+                    _hdnavyquantity = value;
+
+                    OnHdNavyQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _hdlightnavyquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase hd light navy quantity.
+        /// </summary>
+
+        [Column("HD_LIGHT_NAVY_QUANTITY")]
+
+        public  Int64 HdLightNavyQuantity
+        {
+            get 
+            {
+                return _hdlightnavyquantity; 
+            }
+
+            set 
+            {
+                if (_hdlightnavyquantity != value)
+                {
+                    _hdlightnavyquantity = value;
+
+                    OnHdLightNavyQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _ambluequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase am blue quantity.
+        /// </summary>
+
+        [Column("AM_BLUE_QUANTITY")]
+
+        public  Int64 AmBlueQuantity
+        {
+            get 
+            {
+                return _ambluequantity; 
+            }
+
+            set 
+            {
+                if (_ambluequantity != value)
+                {
+                    _ambluequantity = value;
+
+                    OnAmBlueQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _amlightbluequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase am light blue quantity.
+        /// </summary>
+
+        [Column("AM_LIGHT_BLUE_QUANTITY")]
+
+        public  Int64 AmLightBlueQuantity
+        {
+            get 
+            {
+                return _amlightbluequantity; 
+            }
+
+            set 
+            {
+                if (_amlightbluequantity != value)
+                {
+                    _amlightbluequantity = value;
+
+                    OnAmLightBlueQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _amredquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase am red quantity.
+        /// </summary>
+
+        [Column("AM_RED_QUANTITY")]
+
+        public  Int64 AmRedQuantity
+        {
+            get 
+            {
+                return _amredquantity; 
+            }
+
+            set 
+            {
+                if (_amredquantity != value)
+                {
+                    _amredquantity = value;
+
+                    OnAmRedQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _amlightredquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase am light red quantity.
+        /// </summary>
+
+        [Column("AM_LIGHT_RED_QUANTITY")]
+
+        public  Int64 AmLightRedQuantity
+        {
+            get 
+            {
+                return _amlightredquantity; 
+            }
+
+            set 
+            {
+                if (_amlightredquantity != value)
+                {
+                    _amlightredquantity = value;
+
+                    OnAmLightRedQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _amorangequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase am orange quantity.
+        /// </summary>
+
+        [Column("AM_ORANGE_QUANTITY")]
+
+        public  Int64 AmOrangeQuantity
+        {
+            get 
+            {
+                return _amorangequantity; 
+            }
+
+            set 
+            {
+                if (_amorangequantity != value)
+                {
+                    _amorangequantity = value;
+
+                    OnAmOrangeQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _amlightorangequantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase am light orange quantity.
+        /// </summary>
+
+        [Column("AM_LIGHT_ORANGE_QUANTITY")]
+
+        public  Int64 AmLightOrangeQuantity
+        {
+            get 
+            {
+                return _amlightorangequantity; 
+            }
+
+            set 
+            {
+                if (_amlightorangequantity != value)
+                {
+                    _amlightorangequantity = value;
+
+                    OnAmLightOrangeQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _amyellowquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase am yellow quantity.
+        /// </summary>
+
+        [Column("AM_YELLOW_QUANTITY")]
+
+        public  Int64 AmYellowQuantity
+        {
+            get 
+            {
+                return _amyellowquantity; 
+            }
+
+            set 
+            {
+                if (_amyellowquantity != value)
+                {
+                    _amyellowquantity = value;
+
+                    OnAmYellowQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _amlightyellowquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase am light yellow quantity.
+        /// </summary>
+
+        [Column("AM_LIGHT_YELLOW_QUANTITY")]
+
+        public  Int64 AmLightYellowQuantity
+        {
+            get 
+            {
+                return _amlightyellowquantity; 
+            }
+
+            set 
+            {
+                if (_amlightyellowquantity != value)
+                {
+                    _amlightyellowquantity = value;
+
+                    OnAmLightYellowQuantityChanged(value);
+
+                }
+            }
+        }
+
+        protected Int64 _amblackquantity;
+
+        /// <summary>
+        /// Gets or sets the jobrunbase am black quantity.
+        /// </summary>
+
+        [Column("AM_BLACK_QUANTITY")]
+
+        public  Int64 AmBlackQuantity
+        {
+            get 
+            {
+                return _amblackquantity; 
+            }
+
+            set 
+            {
+                if (_amblackquantity != value)
+                {
+                    _amblackquantity = value;
+
+                    OnAmBlackQuantityChanged(value);
+
+                }
+            }
+        }
+
         /// <summary>
         /// Called when the JobName has changed.
         /// </summary>
@@ -1865,6 +2938,339 @@ namespace Tango.BL.Entities
         }
 
         /// <summary>
+        /// Called when the TwTransparentInkQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwTransparentInkQuantityChanged(Int64 twtransparentinkquantity)
+        {
+            TwTransparentInkQuantityChanged?.Invoke(this, twtransparentinkquantity);
+            RaisePropertyChanged(nameof(TwTransparentInkQuantity));
+        }
+
+        /// <summary>
+        /// Called when the C1TiQuantity has changed.
+        /// </summary>
+        protected virtual void OnC1TiQuantityChanged(Int64 c1tiquantity)
+        {
+            C1TiQuantityChanged?.Invoke(this, c1tiquantity);
+            RaisePropertyChanged(nameof(C1TiQuantity));
+        }
+
+        /// <summary>
+        /// Called when the TwCyanQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwCyanQuantityChanged(Int64 twcyanquantity)
+        {
+            TwCyanQuantityChanged?.Invoke(this, twcyanquantity);
+            RaisePropertyChanged(nameof(TwCyanQuantity));
+        }
+
+        /// <summary>
+        /// Called when the TwLightCyanQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwLightCyanQuantityChanged(Int64 twlightcyanquantity)
+        {
+            TwLightCyanQuantityChanged?.Invoke(this, twlightcyanquantity);
+            RaisePropertyChanged(nameof(TwLightCyanQuantity));
+        }
+
+        /// <summary>
+        /// Called when the TwMagentaQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwMagentaQuantityChanged(Int64 twmagentaquantity)
+        {
+            TwMagentaQuantityChanged?.Invoke(this, twmagentaquantity);
+            RaisePropertyChanged(nameof(TwMagentaQuantity));
+        }
+
+        /// <summary>
+        /// Called when the TwLightMagentaQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwLightMagentaQuantityChanged(Int64 twlightmagentaquantity)
+        {
+            TwLightMagentaQuantityChanged?.Invoke(this, twlightmagentaquantity);
+            RaisePropertyChanged(nameof(TwLightMagentaQuantity));
+        }
+
+        /// <summary>
+        /// Called when the TwYellowQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwYellowQuantityChanged(Int64 twyellowquantity)
+        {
+            TwYellowQuantityChanged?.Invoke(this, twyellowquantity);
+            RaisePropertyChanged(nameof(TwYellowQuantity));
+        }
+
+        /// <summary>
+        /// Called when the TwLightYellowQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwLightYellowQuantityChanged(Int64 twlightyellowquantity)
+        {
+            TwLightYellowQuantityChanged?.Invoke(this, twlightyellowquantity);
+            RaisePropertyChanged(nameof(TwLightYellowQuantity));
+        }
+
+        /// <summary>
+        /// Called when the C1YellowQuantity has changed.
+        /// </summary>
+        protected virtual void OnC1YellowQuantityChanged(Int64 c1yellowquantity)
+        {
+            C1YellowQuantityChanged?.Invoke(this, c1yellowquantity);
+            RaisePropertyChanged(nameof(C1YellowQuantity));
+        }
+
+        /// <summary>
+        /// Called when the C1LightYellowQuantity has changed.
+        /// </summary>
+        protected virtual void OnC1LightYellowQuantityChanged(Int64 c1lightyellowquantity)
+        {
+            C1LightYellowQuantityChanged?.Invoke(this, c1lightyellowquantity);
+            RaisePropertyChanged(nameof(C1LightYellowQuantity));
+        }
+
+        /// <summary>
+        /// Called when the TwBlackQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwBlackQuantityChanged(Int64 twblackquantity)
+        {
+            TwBlackQuantityChanged?.Invoke(this, twblackquantity);
+            RaisePropertyChanged(nameof(TwBlackQuantity));
+        }
+
+        /// <summary>
+        /// Called when the TwVioletQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwVioletQuantityChanged(Int64 twvioletquantity)
+        {
+            TwVioletQuantityChanged?.Invoke(this, twvioletquantity);
+            RaisePropertyChanged(nameof(TwVioletQuantity));
+        }
+
+        /// <summary>
+        /// Called when the TwLightVioletQuantity has changed.
+        /// </summary>
+        protected virtual void OnTwLightVioletQuantityChanged(Int64 twlightvioletquantity)
+        {
+            TwLightVioletQuantityChanged?.Invoke(this, twlightvioletquantity);
+            RaisePropertyChanged(nameof(TwLightVioletQuantity));
+        }
+
+        /// <summary>
+        /// Called when the CtBlueQuantity has changed.
+        /// </summary>
+        protected virtual void OnCtBlueQuantityChanged(Int64 ctbluequantity)
+        {
+            CtBlueQuantityChanged?.Invoke(this, ctbluequantity);
+            RaisePropertyChanged(nameof(CtBlueQuantity));
+        }
+
+        /// <summary>
+        /// Called when the CtLightBlueQuantity has changed.
+        /// </summary>
+        protected virtual void OnCtLightBlueQuantityChanged(Int64 ctlightbluequantity)
+        {
+            CtLightBlueQuantityChanged?.Invoke(this, ctlightbluequantity);
+            RaisePropertyChanged(nameof(CtLightBlueQuantity));
+        }
+
+        /// <summary>
+        /// Called when the CtRubineQuantity has changed.
+        /// </summary>
+        protected virtual void OnCtRubineQuantityChanged(Int64 ctrubinequantity)
+        {
+            CtRubineQuantityChanged?.Invoke(this, ctrubinequantity);
+            RaisePropertyChanged(nameof(CtRubineQuantity));
+        }
+
+        /// <summary>
+        /// Called when the CtLightRubineQuantity has changed.
+        /// </summary>
+        protected virtual void OnCtLightRubineQuantityChanged(Int64 ctlightrubinequantity)
+        {
+            CtLightRubineQuantityChanged?.Invoke(this, ctlightrubinequantity);
+            RaisePropertyChanged(nameof(CtLightRubineQuantity));
+        }
+
+        /// <summary>
+        /// Called when the CtOrangeQuantity has changed.
+        /// </summary>
+        protected virtual void OnCtOrangeQuantityChanged(Int64 ctorangequantity)
+        {
+            CtOrangeQuantityChanged?.Invoke(this, ctorangequantity);
+            RaisePropertyChanged(nameof(CtOrangeQuantity));
+        }
+
+        /// <summary>
+        /// Called when the CtLightOrangeQuantity has changed.
+        /// </summary>
+        protected virtual void OnCtLightOrangeQuantityChanged(Int64 ctlightorangequantity)
+        {
+            CtLightOrangeQuantityChanged?.Invoke(this, ctlightorangequantity);
+            RaisePropertyChanged(nameof(CtLightOrangeQuantity));
+        }
+
+        /// <summary>
+        /// Called when the CtNavyQuantity has changed.
+        /// </summary>
+        protected virtual void OnCtNavyQuantityChanged(Int64 ctnavyquantity)
+        {
+            CtNavyQuantityChanged?.Invoke(this, ctnavyquantity);
+            RaisePropertyChanged(nameof(CtNavyQuantity));
+        }
+
+        /// <summary>
+        /// Called when the HdBlueQuantity has changed.
+        /// </summary>
+        protected virtual void OnHdBlueQuantityChanged(Int64 hdbluequantity)
+        {
+            HdBlueQuantityChanged?.Invoke(this, hdbluequantity);
+            RaisePropertyChanged(nameof(HdBlueQuantity));
+        }
+
+        /// <summary>
+        /// Called when the HdLightBlueQuantity has changed.
+        /// </summary>
+        protected virtual void OnHdLightBlueQuantityChanged(Int64 hdlightbluequantity)
+        {
+            HdLightBlueQuantityChanged?.Invoke(this, hdlightbluequantity);
+            RaisePropertyChanged(nameof(HdLightBlueQuantity));
+        }
+
+        /// <summary>
+        /// Called when the HdRubineQuantity has changed.
+        /// </summary>
+        protected virtual void OnHdRubineQuantityChanged(Int64 hdrubinequantity)
+        {
+            HdRubineQuantityChanged?.Invoke(this, hdrubinequantity);
+            RaisePropertyChanged(nameof(HdRubineQuantity));
+        }
+
+        /// <summary>
+        /// Called when the HdLightRubineQuantity has changed.
+        /// </summary>
+        protected virtual void OnHdLightRubineQuantityChanged(Int64 hdlightrubinequantity)
+        {
+            HdLightRubineQuantityChanged?.Invoke(this, hdlightrubinequantity);
+            RaisePropertyChanged(nameof(HdLightRubineQuantity));
+        }
+
+        /// <summary>
+        /// Called when the HdOrangeQuantity has changed.
+        /// </summary>
+        protected virtual void OnHdOrangeQuantityChanged(Int64 hdorangequantity)
+        {
+            HdOrangeQuantityChanged?.Invoke(this, hdorangequantity);
+            RaisePropertyChanged(nameof(HdOrangeQuantity));
+        }
+
+        /// <summary>
+        /// Called when the HdLightOrangeQuantity has changed.
+        /// </summary>
+        protected virtual void OnHdLightOrangeQuantityChanged(Int64 hdlightorangequantity)
+        {
+            HdLightOrangeQuantityChanged?.Invoke(this, hdlightorangequantity);
+            RaisePropertyChanged(nameof(HdLightOrangeQuantity));
+        }
+
+        /// <summary>
+        /// Called when the HdNavyQuantity has changed.
+        /// </summary>
+        protected virtual void OnHdNavyQuantityChanged(Int64 hdnavyquantity)
+        {
+            HdNavyQuantityChanged?.Invoke(this, hdnavyquantity);
+            RaisePropertyChanged(nameof(HdNavyQuantity));
+        }
+
+        /// <summary>
+        /// Called when the HdLightNavyQuantity has changed.
+        /// </summary>
+        protected virtual void OnHdLightNavyQuantityChanged(Int64 hdlightnavyquantity)
+        {
+            HdLightNavyQuantityChanged?.Invoke(this, hdlightnavyquantity);
+            RaisePropertyChanged(nameof(HdLightNavyQuantity));
+        }
+
+        /// <summary>
+        /// Called when the AmBlueQuantity has changed.
+        /// </summary>
+        protected virtual void OnAmBlueQuantityChanged(Int64 ambluequantity)
+        {
+            AmBlueQuantityChanged?.Invoke(this, ambluequantity);
+            RaisePropertyChanged(nameof(AmBlueQuantity));
+        }
+
+        /// <summary>
+        /// Called when the AmLightBlueQuantity has changed.
+        /// </summary>
+        protected virtual void OnAmLightBlueQuantityChanged(Int64 amlightbluequantity)
+        {
+            AmLightBlueQuantityChanged?.Invoke(this, amlightbluequantity);
+            RaisePropertyChanged(nameof(AmLightBlueQuantity));
+        }
+
+        /// <summary>
+        /// Called when the AmRedQuantity has changed.
+        /// </summary>
+        protected virtual void OnAmRedQuantityChanged(Int64 amredquantity)
+        {
+            AmRedQuantityChanged?.Invoke(this, amredquantity);
+            RaisePropertyChanged(nameof(AmRedQuantity));
+        }
+
+        /// <summary>
+        /// Called when the AmLightRedQuantity has changed.
+        /// </summary>
+        protected virtual void OnAmLightRedQuantityChanged(Int64 amlightredquantity)
+        {
+            AmLightRedQuantityChanged?.Invoke(this, amlightredquantity);
+            RaisePropertyChanged(nameof(AmLightRedQuantity));
+        }
+
+        /// <summary>
+        /// Called when the AmOrangeQuantity has changed.
+        /// </summary>
+        protected virtual void OnAmOrangeQuantityChanged(Int64 amorangequantity)
+        {
+            AmOrangeQuantityChanged?.Invoke(this, amorangequantity);
+            RaisePropertyChanged(nameof(AmOrangeQuantity));
+        }
+
+        /// <summary>
+        /// Called when the AmLightOrangeQuantity has changed.
+        /// </summary>
+        protected virtual void OnAmLightOrangeQuantityChanged(Int64 amlightorangequantity)
+        {
+            AmLightOrangeQuantityChanged?.Invoke(this, amlightorangequantity);
+            RaisePropertyChanged(nameof(AmLightOrangeQuantity));
+        }
+
+        /// <summary>
+        /// Called when the AmYellowQuantity has changed.
+        /// </summary>
+        protected virtual void OnAmYellowQuantityChanged(Int64 amyellowquantity)
+        {
+            AmYellowQuantityChanged?.Invoke(this, amyellowquantity);
+            RaisePropertyChanged(nameof(AmYellowQuantity));
+        }
+
+        /// <summary>
+        /// Called when the AmLightYellowQuantity has changed.
+        /// </summary>
+        protected virtual void OnAmLightYellowQuantityChanged(Int64 amlightyellowquantity)
+        {
+            AmLightYellowQuantityChanged?.Invoke(this, amlightyellowquantity);
+            RaisePropertyChanged(nameof(AmLightYellowQuantity));
+        }
+
+        /// <summary>
+        /// Called when the AmBlackQuantity has changed.
+        /// </summary>
+        protected virtual void OnAmBlackQuantityChanged(Int64 amblackquantity)
+        {
+            AmBlackQuantityChanged?.Invoke(this, amblackquantity);
+            RaisePropertyChanged(nameof(AmBlackQuantity));
+        }
+
+        /// <summary>
         /// Initializes a new instance of the <see cref="JobRunBase" /> class.
         /// </summary>
         public JobRunBase() : base()
diff --git a/Software/Visual_Studio/Tango.BL/Entities/LiquidTypeBase.cs b/Software/Visual_Studio/Tango.BL/Entities/LiquidTypeBase.cs
index 82403a11b..fbd32967f 100644
--- a/Software/Visual_Studio/Tango.BL/Entities/LiquidTypeBase.cs
+++ b/Software/Visual_Studio/Tango.BL/Entities/LiquidTypeBase.cs
@@ -49,6 +49,8 @@ namespace Tango.BL.Entities
 
         public event EventHandler<Int32> DarkInkCodeChanged;
 
+        public event EventHandler<String> DisplayNameChanged;
+
         public event EventHandler<SynchronizedObservableCollection<Cat>> CatsChanged;
 
         public event EventHandler<SynchronizedObservableCollection<IdsPack>> IdsPacksChanged;
@@ -354,6 +356,33 @@ namespace Tango.BL.Entities
             }
         }
 
+        protected String _displayname;
+
+        /// <summary>
+        /// Gets or sets the liquidtypebase display name.
+        /// </summary>
+
+        [Column("DISPLAY_NAME")]
+
+        public  String DisplayName
+        {
+            get 
+            {
+                return _displayname; 
+            }
+
+            set 
+            {
+                if (_displayname != value)
+                {
+                    _displayname = value;
+
+                    OnDisplayNameChanged(value);
+
+                }
+            }
+        }
+
         protected SynchronizedObservableCollection<Cat> _cats;
 
         /// <summary>
@@ -554,6 +583,15 @@ namespace Tango.BL.Entities
         }
 
         /// <summary>
+        /// Called when the DisplayName has changed.
+        /// </summary>
+        protected virtual void OnDisplayNameChanged(String displayname)
+        {
+            DisplayNameChanged?.Invoke(this, displayname);
+            RaisePropertyChanged(nameof(DisplayName));
+        }
+
+        /// <summary>
         /// Called when the Cats has changed.
         /// </summary>
         protected virtual void OnCatsChanged(SynchronizedObservableCollection<Cat> cats)
diff --git a/Software/Visual_Studio/Tango.BL/Entities/RmlBase.cs b/Software/Visual_Studio/Tango.BL/Entities/RmlBase.cs
index 17b29d691..357be1666 100644
--- a/Software/Visual_Studio/Tango.BL/Entities/RmlBase.cs
+++ b/Software/Visual_Studio/Tango.BL/Entities/RmlBase.cs
@@ -109,6 +109,8 @@ namespace Tango.BL.Entities
 
         public event EventHandler<Double> BtsrTensionErrorChanged;
 
+        public event EventHandler<Double> DefaultLiquidFactorChanged;
+
         public event EventHandler<BtsrApplicationType> BtsrApplicationTypeChanged;
 
         public event EventHandler<BtsrYarnType> BtsrYarnTypeChanged;
@@ -1540,6 +1542,33 @@ namespace Tango.BL.Entities
             }
         }
 
+        protected Double _defaultliquidfactor;
+
+        /// <summary>
+        /// Gets or sets the rmlbase default liquid factor.
+        /// </summary>
+
+        [Column("DEFAULT_LIQUID_FACTOR")]
+
+        public  Double DefaultLiquidFactor
+        {
+            get 
+            {
+                return _defaultliquidfactor; 
+            }
+
+            set 
+            {
+                if (_defaultliquidfactor != value)
+                {
+                    _defaultliquidfactor = value;
+
+                    OnDefaultLiquidFactorChanged(value);
+
+                }
+            }
+        }
+
         protected BtsrApplicationType _btsrapplicationtype;
 
         /// <summary>
@@ -2462,6 +2491,15 @@ namespace Tango.BL.Entities
         }
 
         /// <summary>
+        /// Called when the DefaultLiquidFactor has changed.
+        /// </summary>
+        protected virtual void OnDefaultLiquidFactorChanged(Double defaultliquidfactor)
+        {
+            DefaultLiquidFactorChanged?.Invoke(this, defaultliquidfactor);
+            RaisePropertyChanged(nameof(DefaultLiquidFactor));
+        }
+
+        /// <summary>
         /// Called when the BtsrApplicationType has changed.
         /// </summary>
         protected virtual void OnBtsrApplicationTypeChanged(BtsrApplicationType btsrapplicationtype)