From f272d741e2c3ec820b1a39e7797ac46986ab62c9 Mon Sep 17 00:00:00 2001 From: Roy Ben Shabat Date: Mon, 8 Sep 2025 17:08:54 +0300 Subject: New Extra Inks DB, PMR, BL. --- .../Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs | 296 ++++ .../Tango.BL/DTO/LiquidTypeDTOBase.cs | 8 + Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs | 8 + .../Visual_Studio/Tango.BL/Entities/JobRunBase.cs | 1506 +++++++++++++++++++- .../Tango.BL/Entities/LiquidTypeBase.cs | 38 + .../Visual_Studio/Tango.BL/Entities/RmlBase.cs | 38 + .../Tango.BL/Enumerations/LiquidTypes.cs | 222 +++ 7 files changed, 2066 insertions(+), 50 deletions(-) (limited to 'Software/Visual_Studio/Tango.BL') diff --git a/Software/Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs b/Software/Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs index 08e8d7337..6543ce97b 100644 --- a/Software/Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs +++ b/Software/Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs @@ -421,5 +421,301 @@ namespace Tango.BL.DTO get; set; } + /// + /// tw transparent ink quantity + /// + public Int64 TwTransparentInkQuantity + { + get; set; + } + + /// + /// c1 ti quantity + /// + public Int64 C1TiQuantity + { + get; set; + } + + /// + /// tw cyan quantity + /// + public Int64 TwCyanQuantity + { + get; set; + } + + /// + /// tw light cyan quantity + /// + public Int64 TwLightCyanQuantity + { + get; set; + } + + /// + /// tw magenta quantity + /// + public Int64 TwMagentaQuantity + { + get; set; + } + + /// + /// tw light magenta quantity + /// + public Int64 TwLightMagentaQuantity + { + get; set; + } + + /// + /// tw yellow quantity + /// + public Int64 TwYellowQuantity + { + get; set; + } + + /// + /// tw light yellow quantity + /// + public Int64 TwLightYellowQuantity + { + get; set; + } + + /// + /// c1 yellow quantity + /// + public Int64 C1YellowQuantity + { + get; set; + } + + /// + /// c1 light yellow quantity + /// + public Int64 C1LightYellowQuantity + { + get; set; + } + + /// + /// tw black quantity + /// + public Int64 TwBlackQuantity + { + get; set; + } + + /// + /// tw violet quantity + /// + public Int64 TwVioletQuantity + { + get; set; + } + + /// + /// tw light violet quantity + /// + public Int64 TwLightVioletQuantity + { + get; set; + } + + /// + /// ct blue quantity + /// + public Int64 CtBlueQuantity + { + get; set; + } + + /// + /// ct light blue quantity + /// + public Int64 CtLightBlueQuantity + { + get; set; + } + + /// + /// ct rubine quantity + /// + public Int64 CtRubineQuantity + { + get; set; + } + + /// + /// ct light rubine quantity + /// + public Int64 CtLightRubineQuantity + { + get; set; + } + + /// + /// ct orange quantity + /// + public Int64 CtOrangeQuantity + { + get; set; + } + + /// + /// ct light orange quantity + /// + public Int64 CtLightOrangeQuantity + { + get; set; + } + + /// + /// ct navy quantity + /// + public Int64 CtNavyQuantity + { + get; set; + } + + /// + /// hd blue quantity + /// + public Int64 HdBlueQuantity + { + get; set; + } + + /// + /// hd light blue quantity + /// + public Int64 HdLightBlueQuantity + { + get; set; + } + + /// + /// hd rubine quantity + /// + public Int64 HdRubineQuantity + { + get; set; + } + + /// + /// hd light rubine quantity + /// + public Int64 HdLightRubineQuantity + { + get; set; + } + + /// + /// hd orange quantity + /// + public Int64 HdOrangeQuantity + { + get; set; + } + + /// + /// hd light orange quantity + /// + public Int64 HdLightOrangeQuantity + { + get; set; + } + + /// + /// hd navy quantity + /// + public Int64 HdNavyQuantity + { + get; set; + } + + /// + /// hd light navy quantity + /// + public Int64 HdLightNavyQuantity + { + get; set; + } + + /// + /// am blue quantity + /// + public Int64 AmBlueQuantity + { + get; set; + } + + /// + /// am light blue quantity + /// + public Int64 AmLightBlueQuantity + { + get; set; + } + + /// + /// am red quantity + /// + public Int64 AmRedQuantity + { + get; set; + } + + /// + /// am light red quantity + /// + public Int64 AmLightRedQuantity + { + get; set; + } + + /// + /// am orange quantity + /// + public Int64 AmOrangeQuantity + { + get; set; + } + + /// + /// am light orange quantity + /// + public Int64 AmLightOrangeQuantity + { + get; set; + } + + /// + /// am yellow quantity + /// + public Int64 AmYellowQuantity + { + get; set; + } + + /// + /// am light yellow quantity + /// + public Int64 AmLightYellowQuantity + { + get; set; + } + + /// + /// am black quantity + /// + public Int64 AmBlackQuantity + { + get; set; + } + } } diff --git a/Software/Visual_Studio/Tango.BL/DTO/LiquidTypeDTOBase.cs b/Software/Visual_Studio/Tango.BL/DTO/LiquidTypeDTOBase.cs index eba35dbd6..5d860f0ae 100644 --- a/Software/Visual_Studio/Tango.BL/DTO/LiquidTypeDTOBase.cs +++ b/Software/Visual_Studio/Tango.BL/DTO/LiquidTypeDTOBase.cs @@ -109,5 +109,13 @@ namespace Tango.BL.DTO get; set; } + /// + /// display name + /// + public String DisplayName + { + get; set; + } + } } diff --git a/Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs b/Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs index e3b9f676c..460d1f193 100644 --- a/Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs +++ b/Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs @@ -437,5 +437,13 @@ namespace Tango.BL.DTO get; set; } + /// + /// default liquid factor + /// + public Double DefaultLiquidFactor + { + get; set; + } + } } 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 VioletQuantityChanged; + public event EventHandler TwTransparentInkQuantityChanged; + + public event EventHandler C1TiQuantityChanged; + + public event EventHandler TwCyanQuantityChanged; + + public event EventHandler TwLightCyanQuantityChanged; + + public event EventHandler TwMagentaQuantityChanged; + + public event EventHandler TwLightMagentaQuantityChanged; + + public event EventHandler TwYellowQuantityChanged; + + public event EventHandler TwLightYellowQuantityChanged; + + public event EventHandler C1YellowQuantityChanged; + + public event EventHandler C1LightYellowQuantityChanged; + + public event EventHandler TwBlackQuantityChanged; + + public event EventHandler TwVioletQuantityChanged; + + public event EventHandler TwLightVioletQuantityChanged; + + public event EventHandler CtBlueQuantityChanged; + + public event EventHandler CtLightBlueQuantityChanged; + + public event EventHandler CtRubineQuantityChanged; + + public event EventHandler CtLightRubineQuantityChanged; + + public event EventHandler CtOrangeQuantityChanged; + + public event EventHandler CtLightOrangeQuantityChanged; + + public event EventHandler CtNavyQuantityChanged; + + public event EventHandler HdBlueQuantityChanged; + + public event EventHandler HdLightBlueQuantityChanged; + + public event EventHandler HdRubineQuantityChanged; + + public event EventHandler HdLightRubineQuantityChanged; + + public event EventHandler HdOrangeQuantityChanged; + + public event EventHandler HdLightOrangeQuantityChanged; + + public event EventHandler HdNavyQuantityChanged; + + public event EventHandler HdLightNavyQuantityChanged; + + public event EventHandler AmBlueQuantityChanged; + + public event EventHandler AmLightBlueQuantityChanged; + + public event EventHandler AmRedQuantityChanged; + + public event EventHandler AmLightRedQuantityChanged; + + public event EventHandler AmOrangeQuantityChanged; + + public event EventHandler AmLightOrangeQuantityChanged; + + public event EventHandler AmYellowQuantityChanged; + + public event EventHandler AmLightYellowQuantityChanged; + + public event EventHandler AmBlackQuantityChanged; + protected String _machineguid; /// @@ -1459,118 +1533,1117 @@ namespace Tango.BL.Entities } } + protected Int64 _twtransparentinkquantity; + /// - /// Called when the JobName has changed. + /// Gets or sets the jobrunbase tw transparent ink quantity. /// - protected virtual void OnJobNameChanged(String jobname) + + [Column("TW_TRANSPARENT_INK_QUANTITY")] + + public Int64 TwTransparentInkQuantity { - JobNameChanged?.Invoke(this, jobname); - RaisePropertyChanged(nameof(JobName)); + get + { + return _twtransparentinkquantity; + } + + set + { + if (_twtransparentinkquantity != value) + { + _twtransparentinkquantity = value; + + OnTwTransparentInkQuantityChanged(value); + + } + } } + protected Int64 _c1tiquantity; + /// - /// Called when the JobDesignation has changed. + /// Gets or sets the jobrunbase c1 ti quantity. /// - protected virtual void OnJobDesignationChanged(Int32 jobdesignation) + + [Column("C1_TI_QUANTITY")] + + public Int64 C1TiQuantity { - JobDesignationChanged?.Invoke(this, jobdesignation); - RaisePropertyChanged(nameof(JobDesignation)); + get + { + return _c1tiquantity; + } + + set + { + if (_c1tiquantity != value) + { + _c1tiquantity = value; + + OnC1TiQuantityChanged(value); + + } + } } + protected Int64 _twcyanquantity; + /// - /// Called when the JobSource has changed. + /// Gets or sets the jobrunbase tw cyan quantity. /// - protected virtual void OnJobSourceChanged(Int32 jobsource) + + [Column("TW_CYAN_QUANTITY")] + + public Int64 TwCyanQuantity { - JobSourceChanged?.Invoke(this, jobsource); - RaisePropertyChanged(nameof(JobSource)); + get + { + return _twcyanquantity; + } + + set + { + if (_twcyanquantity != value) + { + _twcyanquantity = value; + + OnTwCyanQuantityChanged(value); + + } + } } + protected Int64 _twlightcyanquantity; + /// - /// Called when the JobString has changed. + /// Gets or sets the jobrunbase tw light cyan quantity. /// - protected virtual void OnJobStringChanged(String jobstring) + + [Column("TW_LIGHT_CYAN_QUANTITY")] + + public Int64 TwLightCyanQuantity { - JobStringChanged?.Invoke(this, jobstring); - RaisePropertyChanged(nameof(JobString)); + get + { + return _twlightcyanquantity; + } + + set + { + if (_twlightcyanquantity != value) + { + _twlightcyanquantity = value; + + OnTwLightCyanQuantityChanged(value); + + } + } } + protected Int64 _twmagentaquantity; + /// - /// Called when the StartDate has changed. + /// Gets or sets the jobrunbase tw magenta quantity. /// - protected virtual void OnStartDateChanged(DateTime startdate) + + [Column("TW_MAGENTA_QUANTITY")] + + public Int64 TwMagentaQuantity { - StartDateChanged?.Invoke(this, startdate); - RaisePropertyChanged(nameof(StartDate)); + get + { + return _twmagentaquantity; + } + + set + { + if (_twmagentaquantity != value) + { + _twmagentaquantity = value; + + OnTwMagentaQuantityChanged(value); + + } + } } + protected Int64 _twlightmagentaquantity; + /// - /// Called when the UploadingStartDate has changed. + /// Gets or sets the jobrunbase tw light magenta quantity. /// - protected virtual void OnUploadingStartDateChanged(Nullable uploadingstartdate) + + [Column("TW_LIGHT_MAGENTA_QUANTITY")] + + public Int64 TwLightMagentaQuantity { - UploadingStartDateChanged?.Invoke(this, uploadingstartdate); - RaisePropertyChanged(nameof(UploadingStartDate)); + get + { + return _twlightmagentaquantity; + } + + set + { + if (_twlightmagentaquantity != value) + { + _twlightmagentaquantity = value; + + OnTwLightMagentaQuantityChanged(value); + + } + } } + protected Int64 _twyellowquantity; + /// - /// Called when the HeatingStartDate has changed. + /// Gets or sets the jobrunbase tw yellow quantity. /// - protected virtual void OnHeatingStartDateChanged(Nullable heatingstartdate) + + [Column("TW_YELLOW_QUANTITY")] + + public Int64 TwYellowQuantity { - HeatingStartDateChanged?.Invoke(this, heatingstartdate); - RaisePropertyChanged(nameof(HeatingStartDate)); + get + { + return _twyellowquantity; + } + + set + { + if (_twyellowquantity != value) + { + _twyellowquantity = value; + + OnTwYellowQuantityChanged(value); + + } + } } + protected Int64 _twlightyellowquantity; + /// - /// Called when the ActualStartDate has changed. + /// Gets or sets the jobrunbase tw light yellow quantity. /// - protected virtual void OnActualStartDateChanged(Nullable actualstartdate) + + [Column("TW_LIGHT_YELLOW_QUANTITY")] + + public Int64 TwLightYellowQuantity { - ActualStartDateChanged?.Invoke(this, actualstartdate); - RaisePropertyChanged(nameof(ActualStartDate)); + get + { + return _twlightyellowquantity; + } + + set + { + if (_twlightyellowquantity != value) + { + _twlightyellowquantity = value; + + OnTwLightYellowQuantityChanged(value); + + } + } } + protected Int64 _c1yellowquantity; + /// - /// Called when the EndDate has changed. + /// Gets or sets the jobrunbase c1 yellow quantity. /// - protected virtual void OnEndDateChanged(DateTime enddate) + + [Column("C1_YELLOW_QUANTITY")] + + public Int64 C1YellowQuantity { - EndDateChanged?.Invoke(this, enddate); - RaisePropertyChanged(nameof(EndDate)); + get + { + return _c1yellowquantity; + } + + set + { + if (_c1yellowquantity != value) + { + _c1yellowquantity = value; + + OnC1YellowQuantityChanged(value); + + } + } } + protected Int64 _c1lightyellowquantity; + /// - /// Called when the Status has changed. + /// Gets or sets the jobrunbase c1 light yellow quantity. /// - protected virtual void OnStatusChanged(Int32 status) + + [Column("C1_LIGHT_YELLOW_QUANTITY")] + + public Int64 C1LightYellowQuantity { - StatusChanged?.Invoke(this, status); - RaisePropertyChanged(nameof(Status)); + get + { + return _c1lightyellowquantity; + } + + set + { + if (_c1lightyellowquantity != value) + { + _c1lightyellowquantity = value; + + OnC1LightYellowQuantityChanged(value); + + } + } } + protected Int64 _twblackquantity; + /// - /// Called when the JobLength has changed. + /// Gets or sets the jobrunbase tw black quantity. /// - protected virtual void OnJobLengthChanged(Double joblength) + + [Column("TW_BLACK_QUANTITY")] + + public Int64 TwBlackQuantity { - JobLengthChanged?.Invoke(this, joblength); - RaisePropertyChanged(nameof(JobLength)); + get + { + return _twblackquantity; + } + + set + { + if (_twblackquantity != value) + { + _twblackquantity = value; + + OnTwBlackQuantityChanged(value); + + } + } } + protected Int64 _twvioletquantity; + /// - /// Called when the IsGradient has changed. + /// Gets or sets the jobrunbase tw violet quantity. /// - protected virtual void OnIsGradientChanged(Boolean isgradient) + + [Column("TW_VIOLET_QUANTITY")] + + public Int64 TwVioletQuantity { - IsGradientChanged?.Invoke(this, isgradient); - RaisePropertyChanged(nameof(IsGradient)); + get + { + return _twvioletquantity; + } + + set + { + if (_twvioletquantity != value) + { + _twvioletquantity = value; + + OnTwVioletQuantityChanged(value); + + } + } } + protected Int64 _twlightvioletquantity; + /// - /// Called when the GradientResolutionCm has changed. + /// Gets or sets the jobrunbase tw light violet quantity. /// - protected virtual void OnGradientResolutionCmChanged(Int32 gradientresolutioncm) + + [Column("TW_LIGHT_VIOLET_QUANTITY")] + + public Int64 TwLightVioletQuantity + { + get + { + return _twlightvioletquantity; + } + + set + { + if (_twlightvioletquantity != value) + { + _twlightvioletquantity = value; + + OnTwLightVioletQuantityChanged(value); + + } + } + } + + protected Int64 _ctbluequantity; + + /// + /// Gets or sets the jobrunbase ct blue quantity. + /// + + [Column("CT_BLUE_QUANTITY")] + + public Int64 CtBlueQuantity + { + get + { + return _ctbluequantity; + } + + set + { + if (_ctbluequantity != value) + { + _ctbluequantity = value; + + OnCtBlueQuantityChanged(value); + + } + } + } + + protected Int64 _ctlightbluequantity; + + /// + /// Gets or sets the jobrunbase ct light blue quantity. + /// + + [Column("CT_LIGHT_BLUE_QUANTITY")] + + public Int64 CtLightBlueQuantity + { + get + { + return _ctlightbluequantity; + } + + set + { + if (_ctlightbluequantity != value) + { + _ctlightbluequantity = value; + + OnCtLightBlueQuantityChanged(value); + + } + } + } + + protected Int64 _ctrubinequantity; + + /// + /// Gets or sets the jobrunbase ct rubine quantity. + /// + + [Column("CT_RUBINE_QUANTITY")] + + public Int64 CtRubineQuantity + { + get + { + return _ctrubinequantity; + } + + set + { + if (_ctrubinequantity != value) + { + _ctrubinequantity = value; + + OnCtRubineQuantityChanged(value); + + } + } + } + + protected Int64 _ctlightrubinequantity; + + /// + /// Gets or sets the jobrunbase ct light rubine quantity. + /// + + [Column("CT_LIGHT_RUBINE_QUANTITY")] + + public Int64 CtLightRubineQuantity + { + get + { + return _ctlightrubinequantity; + } + + set + { + if (_ctlightrubinequantity != value) + { + _ctlightrubinequantity = value; + + OnCtLightRubineQuantityChanged(value); + + } + } + } + + protected Int64 _ctorangequantity; + + /// + /// Gets or sets the jobrunbase ct orange quantity. + /// + + [Column("CT_ORANGE_QUANTITY")] + + public Int64 CtOrangeQuantity + { + get + { + return _ctorangequantity; + } + + set + { + if (_ctorangequantity != value) + { + _ctorangequantity = value; + + OnCtOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _ctlightorangequantity; + + /// + /// Gets or sets the jobrunbase ct light orange quantity. + /// + + [Column("CT_LIGHT_ORANGE_QUANTITY")] + + public Int64 CtLightOrangeQuantity + { + get + { + return _ctlightorangequantity; + } + + set + { + if (_ctlightorangequantity != value) + { + _ctlightorangequantity = value; + + OnCtLightOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _ctnavyquantity; + + /// + /// Gets or sets the jobrunbase ct navy quantity. + /// + + [Column("CT_NAVY_QUANTITY")] + + public Int64 CtNavyQuantity + { + get + { + return _ctnavyquantity; + } + + set + { + if (_ctnavyquantity != value) + { + _ctnavyquantity = value; + + OnCtNavyQuantityChanged(value); + + } + } + } + + protected Int64 _hdbluequantity; + + /// + /// Gets or sets the jobrunbase hd blue quantity. + /// + + [Column("HD_BLUE_QUANTITY")] + + public Int64 HdBlueQuantity + { + get + { + return _hdbluequantity; + } + + set + { + if (_hdbluequantity != value) + { + _hdbluequantity = value; + + OnHdBlueQuantityChanged(value); + + } + } + } + + protected Int64 _hdlightbluequantity; + + /// + /// Gets or sets the jobrunbase hd light blue quantity. + /// + + [Column("HD_LIGHT_BLUE_QUANTITY")] + + public Int64 HdLightBlueQuantity + { + get + { + return _hdlightbluequantity; + } + + set + { + if (_hdlightbluequantity != value) + { + _hdlightbluequantity = value; + + OnHdLightBlueQuantityChanged(value); + + } + } + } + + protected Int64 _hdrubinequantity; + + /// + /// Gets or sets the jobrunbase hd rubine quantity. + /// + + [Column("HD_RUBINE_QUANTITY")] + + public Int64 HdRubineQuantity + { + get + { + return _hdrubinequantity; + } + + set + { + if (_hdrubinequantity != value) + { + _hdrubinequantity = value; + + OnHdRubineQuantityChanged(value); + + } + } + } + + protected Int64 _hdlightrubinequantity; + + /// + /// Gets or sets the jobrunbase hd light rubine quantity. + /// + + [Column("HD_LIGHT_RUBINE_QUANTITY")] + + public Int64 HdLightRubineQuantity + { + get + { + return _hdlightrubinequantity; + } + + set + { + if (_hdlightrubinequantity != value) + { + _hdlightrubinequantity = value; + + OnHdLightRubineQuantityChanged(value); + + } + } + } + + protected Int64 _hdorangequantity; + + /// + /// Gets or sets the jobrunbase hd orange quantity. + /// + + [Column("HD_ORANGE_QUANTITY")] + + public Int64 HdOrangeQuantity + { + get + { + return _hdorangequantity; + } + + set + { + if (_hdorangequantity != value) + { + _hdorangequantity = value; + + OnHdOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _hdlightorangequantity; + + /// + /// Gets or sets the jobrunbase hd light orange quantity. + /// + + [Column("HD_LIGHT_ORANGE_QUANTITY")] + + public Int64 HdLightOrangeQuantity + { + get + { + return _hdlightorangequantity; + } + + set + { + if (_hdlightorangequantity != value) + { + _hdlightorangequantity = value; + + OnHdLightOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _hdnavyquantity; + + /// + /// Gets or sets the jobrunbase hd navy quantity. + /// + + [Column("HD_NAVY_QUANTITY")] + + public Int64 HdNavyQuantity + { + get + { + return _hdnavyquantity; + } + + set + { + if (_hdnavyquantity != value) + { + _hdnavyquantity = value; + + OnHdNavyQuantityChanged(value); + + } + } + } + + protected Int64 _hdlightnavyquantity; + + /// + /// Gets or sets the jobrunbase hd light navy quantity. + /// + + [Column("HD_LIGHT_NAVY_QUANTITY")] + + public Int64 HdLightNavyQuantity + { + get + { + return _hdlightnavyquantity; + } + + set + { + if (_hdlightnavyquantity != value) + { + _hdlightnavyquantity = value; + + OnHdLightNavyQuantityChanged(value); + + } + } + } + + protected Int64 _ambluequantity; + + /// + /// Gets or sets the jobrunbase am blue quantity. + /// + + [Column("AM_BLUE_QUANTITY")] + + public Int64 AmBlueQuantity + { + get + { + return _ambluequantity; + } + + set + { + if (_ambluequantity != value) + { + _ambluequantity = value; + + OnAmBlueQuantityChanged(value); + + } + } + } + + protected Int64 _amlightbluequantity; + + /// + /// Gets or sets the jobrunbase am light blue quantity. + /// + + [Column("AM_LIGHT_BLUE_QUANTITY")] + + public Int64 AmLightBlueQuantity + { + get + { + return _amlightbluequantity; + } + + set + { + if (_amlightbluequantity != value) + { + _amlightbluequantity = value; + + OnAmLightBlueQuantityChanged(value); + + } + } + } + + protected Int64 _amredquantity; + + /// + /// Gets or sets the jobrunbase am red quantity. + /// + + [Column("AM_RED_QUANTITY")] + + public Int64 AmRedQuantity + { + get + { + return _amredquantity; + } + + set + { + if (_amredquantity != value) + { + _amredquantity = value; + + OnAmRedQuantityChanged(value); + + } + } + } + + protected Int64 _amlightredquantity; + + /// + /// Gets or sets the jobrunbase am light red quantity. + /// + + [Column("AM_LIGHT_RED_QUANTITY")] + + public Int64 AmLightRedQuantity + { + get + { + return _amlightredquantity; + } + + set + { + if (_amlightredquantity != value) + { + _amlightredquantity = value; + + OnAmLightRedQuantityChanged(value); + + } + } + } + + protected Int64 _amorangequantity; + + /// + /// Gets or sets the jobrunbase am orange quantity. + /// + + [Column("AM_ORANGE_QUANTITY")] + + public Int64 AmOrangeQuantity + { + get + { + return _amorangequantity; + } + + set + { + if (_amorangequantity != value) + { + _amorangequantity = value; + + OnAmOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _amlightorangequantity; + + /// + /// Gets or sets the jobrunbase am light orange quantity. + /// + + [Column("AM_LIGHT_ORANGE_QUANTITY")] + + public Int64 AmLightOrangeQuantity + { + get + { + return _amlightorangequantity; + } + + set + { + if (_amlightorangequantity != value) + { + _amlightorangequantity = value; + + OnAmLightOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _amyellowquantity; + + /// + /// Gets or sets the jobrunbase am yellow quantity. + /// + + [Column("AM_YELLOW_QUANTITY")] + + public Int64 AmYellowQuantity + { + get + { + return _amyellowquantity; + } + + set + { + if (_amyellowquantity != value) + { + _amyellowquantity = value; + + OnAmYellowQuantityChanged(value); + + } + } + } + + protected Int64 _amlightyellowquantity; + + /// + /// Gets or sets the jobrunbase am light yellow quantity. + /// + + [Column("AM_LIGHT_YELLOW_QUANTITY")] + + public Int64 AmLightYellowQuantity + { + get + { + return _amlightyellowquantity; + } + + set + { + if (_amlightyellowquantity != value) + { + _amlightyellowquantity = value; + + OnAmLightYellowQuantityChanged(value); + + } + } + } + + protected Int64 _amblackquantity; + + /// + /// Gets or sets the jobrunbase am black quantity. + /// + + [Column("AM_BLACK_QUANTITY")] + + public Int64 AmBlackQuantity + { + get + { + return _amblackquantity; + } + + set + { + if (_amblackquantity != value) + { + _amblackquantity = value; + + OnAmBlackQuantityChanged(value); + + } + } + } + + /// + /// Called when the JobName has changed. + /// + protected virtual void OnJobNameChanged(String jobname) + { + JobNameChanged?.Invoke(this, jobname); + RaisePropertyChanged(nameof(JobName)); + } + + /// + /// Called when the JobDesignation has changed. + /// + protected virtual void OnJobDesignationChanged(Int32 jobdesignation) + { + JobDesignationChanged?.Invoke(this, jobdesignation); + RaisePropertyChanged(nameof(JobDesignation)); + } + + /// + /// Called when the JobSource has changed. + /// + protected virtual void OnJobSourceChanged(Int32 jobsource) + { + JobSourceChanged?.Invoke(this, jobsource); + RaisePropertyChanged(nameof(JobSource)); + } + + /// + /// Called when the JobString has changed. + /// + protected virtual void OnJobStringChanged(String jobstring) + { + JobStringChanged?.Invoke(this, jobstring); + RaisePropertyChanged(nameof(JobString)); + } + + /// + /// Called when the StartDate has changed. + /// + protected virtual void OnStartDateChanged(DateTime startdate) + { + StartDateChanged?.Invoke(this, startdate); + RaisePropertyChanged(nameof(StartDate)); + } + + /// + /// Called when the UploadingStartDate has changed. + /// + protected virtual void OnUploadingStartDateChanged(Nullable uploadingstartdate) + { + UploadingStartDateChanged?.Invoke(this, uploadingstartdate); + RaisePropertyChanged(nameof(UploadingStartDate)); + } + + /// + /// Called when the HeatingStartDate has changed. + /// + protected virtual void OnHeatingStartDateChanged(Nullable heatingstartdate) + { + HeatingStartDateChanged?.Invoke(this, heatingstartdate); + RaisePropertyChanged(nameof(HeatingStartDate)); + } + + /// + /// Called when the ActualStartDate has changed. + /// + protected virtual void OnActualStartDateChanged(Nullable actualstartdate) + { + ActualStartDateChanged?.Invoke(this, actualstartdate); + RaisePropertyChanged(nameof(ActualStartDate)); + } + + /// + /// Called when the EndDate has changed. + /// + protected virtual void OnEndDateChanged(DateTime enddate) + { + EndDateChanged?.Invoke(this, enddate); + RaisePropertyChanged(nameof(EndDate)); + } + + /// + /// Called when the Status has changed. + /// + protected virtual void OnStatusChanged(Int32 status) + { + StatusChanged?.Invoke(this, status); + RaisePropertyChanged(nameof(Status)); + } + + /// + /// Called when the JobLength has changed. + /// + protected virtual void OnJobLengthChanged(Double joblength) + { + JobLengthChanged?.Invoke(this, joblength); + RaisePropertyChanged(nameof(JobLength)); + } + + /// + /// Called when the IsGradient has changed. + /// + protected virtual void OnIsGradientChanged(Boolean isgradient) + { + IsGradientChanged?.Invoke(this, isgradient); + RaisePropertyChanged(nameof(IsGradient)); + } + + /// + /// Called when the GradientResolutionCm has changed. + /// + protected virtual void OnGradientResolutionCmChanged(Int32 gradientresolutioncm) { GradientResolutionCmChanged?.Invoke(this, gradientresolutioncm); RaisePropertyChanged(nameof(GradientResolutionCm)); @@ -1864,6 +2937,339 @@ namespace Tango.BL.Entities RaisePropertyChanged(nameof(VioletQuantity)); } + /// + /// Called when the TwTransparentInkQuantity has changed. + /// + protected virtual void OnTwTransparentInkQuantityChanged(Int64 twtransparentinkquantity) + { + TwTransparentInkQuantityChanged?.Invoke(this, twtransparentinkquantity); + RaisePropertyChanged(nameof(TwTransparentInkQuantity)); + } + + /// + /// Called when the C1TiQuantity has changed. + /// + protected virtual void OnC1TiQuantityChanged(Int64 c1tiquantity) + { + C1TiQuantityChanged?.Invoke(this, c1tiquantity); + RaisePropertyChanged(nameof(C1TiQuantity)); + } + + /// + /// Called when the TwCyanQuantity has changed. + /// + protected virtual void OnTwCyanQuantityChanged(Int64 twcyanquantity) + { + TwCyanQuantityChanged?.Invoke(this, twcyanquantity); + RaisePropertyChanged(nameof(TwCyanQuantity)); + } + + /// + /// Called when the TwLightCyanQuantity has changed. + /// + protected virtual void OnTwLightCyanQuantityChanged(Int64 twlightcyanquantity) + { + TwLightCyanQuantityChanged?.Invoke(this, twlightcyanquantity); + RaisePropertyChanged(nameof(TwLightCyanQuantity)); + } + + /// + /// Called when the TwMagentaQuantity has changed. + /// + protected virtual void OnTwMagentaQuantityChanged(Int64 twmagentaquantity) + { + TwMagentaQuantityChanged?.Invoke(this, twmagentaquantity); + RaisePropertyChanged(nameof(TwMagentaQuantity)); + } + + /// + /// Called when the TwLightMagentaQuantity has changed. + /// + protected virtual void OnTwLightMagentaQuantityChanged(Int64 twlightmagentaquantity) + { + TwLightMagentaQuantityChanged?.Invoke(this, twlightmagentaquantity); + RaisePropertyChanged(nameof(TwLightMagentaQuantity)); + } + + /// + /// Called when the TwYellowQuantity has changed. + /// + protected virtual void OnTwYellowQuantityChanged(Int64 twyellowquantity) + { + TwYellowQuantityChanged?.Invoke(this, twyellowquantity); + RaisePropertyChanged(nameof(TwYellowQuantity)); + } + + /// + /// Called when the TwLightYellowQuantity has changed. + /// + protected virtual void OnTwLightYellowQuantityChanged(Int64 twlightyellowquantity) + { + TwLightYellowQuantityChanged?.Invoke(this, twlightyellowquantity); + RaisePropertyChanged(nameof(TwLightYellowQuantity)); + } + + /// + /// Called when the C1YellowQuantity has changed. + /// + protected virtual void OnC1YellowQuantityChanged(Int64 c1yellowquantity) + { + C1YellowQuantityChanged?.Invoke(this, c1yellowquantity); + RaisePropertyChanged(nameof(C1YellowQuantity)); + } + + /// + /// Called when the C1LightYellowQuantity has changed. + /// + protected virtual void OnC1LightYellowQuantityChanged(Int64 c1lightyellowquantity) + { + C1LightYellowQuantityChanged?.Invoke(this, c1lightyellowquantity); + RaisePropertyChanged(nameof(C1LightYellowQuantity)); + } + + /// + /// Called when the TwBlackQuantity has changed. + /// + protected virtual void OnTwBlackQuantityChanged(Int64 twblackquantity) + { + TwBlackQuantityChanged?.Invoke(this, twblackquantity); + RaisePropertyChanged(nameof(TwBlackQuantity)); + } + + /// + /// Called when the TwVioletQuantity has changed. + /// + protected virtual void OnTwVioletQuantityChanged(Int64 twvioletquantity) + { + TwVioletQuantityChanged?.Invoke(this, twvioletquantity); + RaisePropertyChanged(nameof(TwVioletQuantity)); + } + + /// + /// Called when the TwLightVioletQuantity has changed. + /// + protected virtual void OnTwLightVioletQuantityChanged(Int64 twlightvioletquantity) + { + TwLightVioletQuantityChanged?.Invoke(this, twlightvioletquantity); + RaisePropertyChanged(nameof(TwLightVioletQuantity)); + } + + /// + /// Called when the CtBlueQuantity has changed. + /// + protected virtual void OnCtBlueQuantityChanged(Int64 ctbluequantity) + { + CtBlueQuantityChanged?.Invoke(this, ctbluequantity); + RaisePropertyChanged(nameof(CtBlueQuantity)); + } + + /// + /// Called when the CtLightBlueQuantity has changed. + /// + protected virtual void OnCtLightBlueQuantityChanged(Int64 ctlightbluequantity) + { + CtLightBlueQuantityChanged?.Invoke(this, ctlightbluequantity); + RaisePropertyChanged(nameof(CtLightBlueQuantity)); + } + + /// + /// Called when the CtRubineQuantity has changed. + /// + protected virtual void OnCtRubineQuantityChanged(Int64 ctrubinequantity) + { + CtRubineQuantityChanged?.Invoke(this, ctrubinequantity); + RaisePropertyChanged(nameof(CtRubineQuantity)); + } + + /// + /// Called when the CtLightRubineQuantity has changed. + /// + protected virtual void OnCtLightRubineQuantityChanged(Int64 ctlightrubinequantity) + { + CtLightRubineQuantityChanged?.Invoke(this, ctlightrubinequantity); + RaisePropertyChanged(nameof(CtLightRubineQuantity)); + } + + /// + /// Called when the CtOrangeQuantity has changed. + /// + protected virtual void OnCtOrangeQuantityChanged(Int64 ctorangequantity) + { + CtOrangeQuantityChanged?.Invoke(this, ctorangequantity); + RaisePropertyChanged(nameof(CtOrangeQuantity)); + } + + /// + /// Called when the CtLightOrangeQuantity has changed. + /// + protected virtual void OnCtLightOrangeQuantityChanged(Int64 ctlightorangequantity) + { + CtLightOrangeQuantityChanged?.Invoke(this, ctlightorangequantity); + RaisePropertyChanged(nameof(CtLightOrangeQuantity)); + } + + /// + /// Called when the CtNavyQuantity has changed. + /// + protected virtual void OnCtNavyQuantityChanged(Int64 ctnavyquantity) + { + CtNavyQuantityChanged?.Invoke(this, ctnavyquantity); + RaisePropertyChanged(nameof(CtNavyQuantity)); + } + + /// + /// Called when the HdBlueQuantity has changed. + /// + protected virtual void OnHdBlueQuantityChanged(Int64 hdbluequantity) + { + HdBlueQuantityChanged?.Invoke(this, hdbluequantity); + RaisePropertyChanged(nameof(HdBlueQuantity)); + } + + /// + /// Called when the HdLightBlueQuantity has changed. + /// + protected virtual void OnHdLightBlueQuantityChanged(Int64 hdlightbluequantity) + { + HdLightBlueQuantityChanged?.Invoke(this, hdlightbluequantity); + RaisePropertyChanged(nameof(HdLightBlueQuantity)); + } + + /// + /// Called when the HdRubineQuantity has changed. + /// + protected virtual void OnHdRubineQuantityChanged(Int64 hdrubinequantity) + { + HdRubineQuantityChanged?.Invoke(this, hdrubinequantity); + RaisePropertyChanged(nameof(HdRubineQuantity)); + } + + /// + /// Called when the HdLightRubineQuantity has changed. + /// + protected virtual void OnHdLightRubineQuantityChanged(Int64 hdlightrubinequantity) + { + HdLightRubineQuantityChanged?.Invoke(this, hdlightrubinequantity); + RaisePropertyChanged(nameof(HdLightRubineQuantity)); + } + + /// + /// Called when the HdOrangeQuantity has changed. + /// + protected virtual void OnHdOrangeQuantityChanged(Int64 hdorangequantity) + { + HdOrangeQuantityChanged?.Invoke(this, hdorangequantity); + RaisePropertyChanged(nameof(HdOrangeQuantity)); + } + + /// + /// Called when the HdLightOrangeQuantity has changed. + /// + protected virtual void OnHdLightOrangeQuantityChanged(Int64 hdlightorangequantity) + { + HdLightOrangeQuantityChanged?.Invoke(this, hdlightorangequantity); + RaisePropertyChanged(nameof(HdLightOrangeQuantity)); + } + + /// + /// Called when the HdNavyQuantity has changed. + /// + protected virtual void OnHdNavyQuantityChanged(Int64 hdnavyquantity) + { + HdNavyQuantityChanged?.Invoke(this, hdnavyquantity); + RaisePropertyChanged(nameof(HdNavyQuantity)); + } + + /// + /// Called when the HdLightNavyQuantity has changed. + /// + protected virtual void OnHdLightNavyQuantityChanged(Int64 hdlightnavyquantity) + { + HdLightNavyQuantityChanged?.Invoke(this, hdlightnavyquantity); + RaisePropertyChanged(nameof(HdLightNavyQuantity)); + } + + /// + /// Called when the AmBlueQuantity has changed. + /// + protected virtual void OnAmBlueQuantityChanged(Int64 ambluequantity) + { + AmBlueQuantityChanged?.Invoke(this, ambluequantity); + RaisePropertyChanged(nameof(AmBlueQuantity)); + } + + /// + /// Called when the AmLightBlueQuantity has changed. + /// + protected virtual void OnAmLightBlueQuantityChanged(Int64 amlightbluequantity) + { + AmLightBlueQuantityChanged?.Invoke(this, amlightbluequantity); + RaisePropertyChanged(nameof(AmLightBlueQuantity)); + } + + /// + /// Called when the AmRedQuantity has changed. + /// + protected virtual void OnAmRedQuantityChanged(Int64 amredquantity) + { + AmRedQuantityChanged?.Invoke(this, amredquantity); + RaisePropertyChanged(nameof(AmRedQuantity)); + } + + /// + /// Called when the AmLightRedQuantity has changed. + /// + protected virtual void OnAmLightRedQuantityChanged(Int64 amlightredquantity) + { + AmLightRedQuantityChanged?.Invoke(this, amlightredquantity); + RaisePropertyChanged(nameof(AmLightRedQuantity)); + } + + /// + /// Called when the AmOrangeQuantity has changed. + /// + protected virtual void OnAmOrangeQuantityChanged(Int64 amorangequantity) + { + AmOrangeQuantityChanged?.Invoke(this, amorangequantity); + RaisePropertyChanged(nameof(AmOrangeQuantity)); + } + + /// + /// Called when the AmLightOrangeQuantity has changed. + /// + protected virtual void OnAmLightOrangeQuantityChanged(Int64 amlightorangequantity) + { + AmLightOrangeQuantityChanged?.Invoke(this, amlightorangequantity); + RaisePropertyChanged(nameof(AmLightOrangeQuantity)); + } + + /// + /// Called when the AmYellowQuantity has changed. + /// + protected virtual void OnAmYellowQuantityChanged(Int64 amyellowquantity) + { + AmYellowQuantityChanged?.Invoke(this, amyellowquantity); + RaisePropertyChanged(nameof(AmYellowQuantity)); + } + + /// + /// Called when the AmLightYellowQuantity has changed. + /// + protected virtual void OnAmLightYellowQuantityChanged(Int64 amlightyellowquantity) + { + AmLightYellowQuantityChanged?.Invoke(this, amlightyellowquantity); + RaisePropertyChanged(nameof(AmLightYellowQuantity)); + } + + /// + /// Called when the AmBlackQuantity has changed. + /// + protected virtual void OnAmBlackQuantityChanged(Int64 amblackquantity) + { + AmBlackQuantityChanged?.Invoke(this, amblackquantity); + RaisePropertyChanged(nameof(AmBlackQuantity)); + } + /// /// Initializes a new instance of the class. /// 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 DarkInkCodeChanged; + public event EventHandler DisplayNameChanged; + public event EventHandler> CatsChanged; public event EventHandler> IdsPacksChanged; @@ -354,6 +356,33 @@ namespace Tango.BL.Entities } } + protected String _displayname; + + /// + /// Gets or sets the liquidtypebase display name. + /// + + [Column("DISPLAY_NAME")] + + public String DisplayName + { + get + { + return _displayname; + } + + set + { + if (_displayname != value) + { + _displayname = value; + + OnDisplayNameChanged(value); + + } + } + } + protected SynchronizedObservableCollection _cats; /// @@ -553,6 +582,15 @@ namespace Tango.BL.Entities RaisePropertyChanged(nameof(DarkInkCode)); } + /// + /// Called when the DisplayName has changed. + /// + protected virtual void OnDisplayNameChanged(String displayname) + { + DisplayNameChanged?.Invoke(this, displayname); + RaisePropertyChanged(nameof(DisplayName)); + } + /// /// Called when the Cats has changed. /// 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 BtsrTensionErrorChanged; + public event EventHandler DefaultLiquidFactorChanged; + public event EventHandler BtsrApplicationTypeChanged; public event EventHandler BtsrYarnTypeChanged; @@ -1540,6 +1542,33 @@ namespace Tango.BL.Entities } } + protected Double _defaultliquidfactor; + + /// + /// Gets or sets the rmlbase default liquid factor. + /// + + [Column("DEFAULT_LIQUID_FACTOR")] + + public Double DefaultLiquidFactor + { + get + { + return _defaultliquidfactor; + } + + set + { + if (_defaultliquidfactor != value) + { + _defaultliquidfactor = value; + + OnDefaultLiquidFactorChanged(value); + + } + } + } + protected BtsrApplicationType _btsrapplicationtype; /// @@ -2461,6 +2490,15 @@ namespace Tango.BL.Entities RaisePropertyChanged(nameof(BtsrTensionError)); } + /// + /// Called when the DefaultLiquidFactor has changed. + /// + protected virtual void OnDefaultLiquidFactorChanged(Double defaultliquidfactor) + { + DefaultLiquidFactorChanged?.Invoke(this, defaultliquidfactor); + RaisePropertyChanged(nameof(DefaultLiquidFactor)); + } + /// /// Called when the BtsrApplicationType has changed. /// diff --git a/Software/Visual_Studio/Tango.BL/Enumerations/LiquidTypes.cs b/Software/Visual_Studio/Tango.BL/Enumerations/LiquidTypes.cs index 07b46869e..d44726994 100644 --- a/Software/Visual_Studio/Tango.BL/Enumerations/LiquidTypes.cs +++ b/Software/Visual_Studio/Tango.BL/Enumerations/LiquidTypes.cs @@ -19,6 +19,12 @@ namespace Tango.BL.Enumerations public enum LiquidTypes { + /// + /// (CT Orange) + /// + [Description("CT Orange")] + CTOrange = 230, + /// /// (Light Cyan) /// @@ -31,30 +37,144 @@ namespace Tango.BL.Enumerations [Description("Cyan")] Cyan = 0, + /// + /// (AM Black) + /// + [Description("AM Black")] + AMBlack = 450, + + /// + /// (HD Navy) + /// + [Description("HD Navy")] + HDNavy = 340, + + /// + /// (HD Orange) + /// + [Description("HD Orange")] + HDOrange = 330, + /// /// (Transparent Ink) /// [Description("Transparent Ink")] TransparentInk = 4, + /// + /// (TW Transparent Ink) + /// + [Description("TW Transparent Ink")] + TWTransparentInk = 100, + + /// + /// (AM Light Yellow) + /// + [Description("AM Light Yellow")] + AMLightYellow = 441, + + /// + /// (TW Cyan) + /// + [Description("TW Cyan")] + TWCyan = 110, + /// /// (Magenta) /// [Description("Magenta")] Magenta = 1, + /// + /// (HD Light Orange) + /// + [Description("HD Light Orange")] + HDLightOrange = 331, + + /// + /// (TW Light Violet) + /// + [Description("TW Light Violet")] + TWLightViolet = 151, + + /// + /// (C1 Yellow) + /// + [Description("C1 Yellow")] + C1Yellow = 135, + + /// + /// (CT Rubine) + /// + [Description("CT Rubine")] + CTRubine = 220, + + /// + /// (TW Light Yellow) + /// + [Description("TW Light Yellow")] + TWLightYellow = 131, + /// /// (Lubricant) /// [Description("Lubricant")] Lubricant = 5, + /// + /// (CT Navy) + /// + [Description("CT Navy")] + CTNavy = 240, + + /// + /// (TW Black) + /// + [Description("TW Black")] + TWBlack = 140, + + /// + /// (HD Light Rubine) + /// + [Description("HD Light Rubine")] + HDLightRubine = 321, + + /// + /// (HD Rubine) + /// + [Description("HD Rubine")] + HDRubine = 320, + + /// + /// (TW Yellow) + /// + [Description("TW Yellow")] + TWYellow = 130, + + /// + /// (AM Light Red) + /// + [Description("AM Light Red")] + AMLightRed = 421, + + /// + /// (TW Violet) + /// + [Description("TW Violet")] + TWViolet = 150, + /// /// (Light Magenta) /// [Description("Light Magenta")] LightMagenta = 8, + /// + /// (AM Blue) + /// + [Description("AM Blue")] + AMBlue = 410, + /// /// (Blue) /// @@ -109,23 +229,125 @@ namespace Tango.BL.Enumerations [Description("Violet")] Violet = 10, + /// + /// (AM Red) + /// + [Description("AM Red")] + AMRed = 420, + + /// + /// (CT Light Rubine) + /// + [Description("CT Light Rubine")] + CTLightRubine = 221, + + /// + /// (TW Light Cyan) + /// + [Description("TW Light Cyan")] + TWLightCyan = 111, + /// /// (Yellow) /// [Description("Yellow")] Yellow = 2, + /// + /// (HD Blue) + /// + [Description("HD Blue")] + HDBlue = 310, + + /// + /// (CT Light Blue) + /// + [Description("CT Light Blue")] + CTLightBlue = 211, + + /// + /// (C1 TI) + /// + [Description("C1 TI")] + C1TI = 105, + + /// + /// (TW Magenta) + /// + [Description("TW Magenta")] + TWMagenta = 120, + /// /// (Black) /// [Description("Black")] Black = 3, + /// + /// (AM Yellow) + /// + [Description("AM Yellow")] + AMYellow = 440, + + /// + /// (AM Light Orange) + /// + [Description("AM Light Orange")] + AMLightOrange = 431, + + /// + /// (AM Orange) + /// + [Description("AM Orange")] + AMOrange = 430, + + /// + /// (C1 Light Yellow) + /// + [Description("C1 Light Yellow")] + C1LightYellow = 136, + /// /// (Cleaner) /// [Description("Cleaner")] Cleaner = 6, + /// + /// (CT Light Orange) + /// + [Description("CT Light Orange")] + CTLightOrange = 231, + + /// + /// (TW Light Magenta) + /// + [Description("TW Light Magenta")] + TWLightMagenta = 121, + + /// + /// (AM Light Blue) + /// + [Description("AM Light Blue")] + AMLightBlue = 411, + + /// + /// (CT Blue) + /// + [Description("CT Blue")] + CTBlue = 210, + + /// + /// (HD Light Navy) + /// + [Description("HD Light Navy")] + HDLightNavy = 341, + + /// + /// (HD Light Blue) + /// + [Description("HD Light Blue")] + HDLightBlue = 311, + } } -- cgit v1.3.1