using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;

namespace Cosmos.KPS
{
    [Serializable]
    public class PrinterCommand
    {
        #region 위치
        public enum Position
        {
            Top,
            Buttom,
            TopAndButtom,
            None
        }
        public enum Alignment
        {
            Center,
            Left,
            Right
        }
        #endregion

        #region Character size/Filter
        /// <summary>
        /// Character size horizontal [넓이 배율 1~8]
        /// </summary>
        public enum CharactersizeH
        {
            H_1,
            H_2,
            H_3,
            H_4,
            H_5,
            H_6,
            H_7,
            H_8
        }
        /// <summary>
        /// Character size vertical [높이 배율 1~8]
        /// </summary>
        public enum CharactersizeV
        {
            V_1,
            V_2,
            V_3,
            V_4,
            V_5,
            V_6,
            V_7,
            V_8
        }

        /// <summary>
        /// Bold 체 여부
        /// </summary>
        public enum TextBold
        {
            Nomal,
            Bold
        }

        /// <summary>
        /// 밑줄(UnderLine)
        /// </summary>
        public enum TextUnderLine
        {
            Nomal,
            UnderLine
        }

        /// <summary>
        /// 반전 Text 효과
        /// </summary>
        public enum TextReverseMode
        {
            Nomal,
            ReverseMode
        }

        #endregion

        #region Barcode Type
        /// <summary>
        /// Print Barcode
        /// 1Dh, 6BH, m, d1, ...dk, 00H [0 ≤ m ≤ 6, 32 ≤ k ≤ 126, 1 ≤ k ≤ 255]
        /// 1Dh, 6BH, m, n, d1, ...dn [65 ≤ m ≤ 73, 1 ≤ n ≤ 255, 0 ≤ d ≤ 127]
        /// </summary>
        public enum BarcodeType : int
        {
            UPC_A = 0,          //m = 0, 65,  
            UPC_E = 1,          //m = 1, 66
            EAN13_KAN13 = 2,    //m = 2, 67
            EAN8_KAN8 = 3,      //m = 3, 68
            COE39 = 4,          //m = 4, 69
            ITF = 5,            //m = 5, 70
            CODEBAR = 6,        //m = 6, 71
            CODE93 = 72,        //m = 72
            CODE128 = 73        //m = 73
        }
        #endregion

        #region Error Code
        public const int PRT_SUCCESS = 0;
        #endregion

        #region "StatusUpdateEvent" Event: "Data" Parameter Constants
        public const int PTR_SUE_COVER_OPEN = 11;
        public const int PTR_SUE_COVER_OK = 12;
        public const int PTR_SUE_JRN_EMPTY = 21;
        public const int PTR_SUE_JRN_NEAREMPTY = 22;
        public const int PTR_SUE_JRN_PAPEROK = 23;
        public const int PTR_SUE_REC_EMPTY = 24;
        public const int PTR_SUE_REC_NEAREMPTY = 25;
        public const int PTR_SUE_REC_PAPEROK = 26;
        public const int PTR_SUE_SLP_EMPTY = 27;
        public const int PTR_SUE_SLP_NEAREMPTY = 28;
        public const int PTR_SUE_SLP_PAPEROK = 29;
        public const int PTR_SUE_JRN_CARTRIDGE_EMPTY = 41;
        public const int PTR_SUE_JRN_CARTRIDGE_NEAREMPTY = 42;
        public const int PTR_SUE_JRN_HEAD_CLEANING = 43;
        public const int PTR_SUE_JRN_CARTRIDGE_OK = 44;
        public const int PTR_SUE_REC_CARTRIDGE_EMPTY = 45;
        public const int PTR_SUE_REC_CARTRIDGE_NEAREMPTY = 46;
        public const int PTR_SUE_REC_HEAD_CLEANING = 47;
        public const int PTR_SUE_REC_CARTRIDGE_OK = 48;
        public const int PTR_Sue_Slp_CARTRIDGE_EMPTY = 49;
        public const int PTR_Sue_Slp_CARTRIDGE_NEAREMPTY = 50;
        public const int PTR_SUE_SLP_HEAD_CLEANING = 51;
        public const int PTR_SUE_SLP_CARTRIDGE_OK = 52;

        public const int PTR_SUE_IDLE = 1001;
        #endregion

        #region Default
        public byte ESC = 0x1B;
        public byte SP = 0x14;

        public byte ESC_CR = 0x0D;
        public byte ESC_LF = 0x0A;
        public byte ESC_FF = 0xFF;

        public byte[] ESC_INITPRINTER = { 0x1B, 0x40 }; //Printer 초기화

        //1BH, 74H, n    n=1(Katakana)
        //1BH, 52H, n    n=0(USA), n=8(Japan), n=13(korea)        'Select an international characer set
        //1CH, 43H, n    n=0,48 JIS code system , n=1,49 Shift JIS code system.
        public byte[] ESC_LANGE = { 0x1B, 0x74, 0x01, 
                                    0x1B, 0x52, 0x08, 
                                    0x1C, 0x43, 0x01, 
                                    0x1C, 0x26 };

        /// <summary>
        /// Buffer clear
        /// [10H, 14H, 08H, d1......d7]
        /// [d1=1, d2=3, d3=20, d4=1, d5=6, d6=2, d7=8]
        /// </summary>
        public byte[] ESC_BUFFERCLEAR = { 0x10, 0x14, 0x08, 0x01, 0x03, 0x14, 0x01, 0x06, 0x02, 0x08 };
        #endregion

        #region Request Status (상태 전송)
        public byte[] ESC_REQ_SUATUS_PAPER_SENSOR = { 0x1D, 0x72, 0x01 }; //용지 센서 상태를 송신합니다
        public byte[] ESC_REQ_SUATUS_PAPER_SENSOR1 = { 0x1D, 0x72, 0x31 }; //용지 센서 상태를 송신합니다

        public byte[] ESC_REQ_SUATUS_DRAW_CON = { 0x1D, 0x72, 0x02 }; //캐쉬 드로어 커넥터 상태를 송신 합니다.
        public byte[] ESC_REQ_SUATUS_DRAW_CON1 = { 0x1D, 0x72, 0x32 }; //캐쉬 드로어 커넥터 상태를 송신 합니다.

        //public byte[] ESC_REQ_SUATUS_PAPER_SENSOR2 =  { 0x1B, 0x63, 0x33 }; //용지 센서 상태를 송신합니다
        #endregion

        #region BarCode Commad
        //Select printing position for HRI character
        /// <summary>
        /// HRI Print 안함
        /// </summary>
        public byte[] ESC_HRI_NOTPRINT = { 0x1D, 0x48, 0x00 };
        /// <summary>
        /// Barcode 상단에 HRI Print
        /// </summary>
        public byte[] ESC_HRI_TOPPRINT = { 0x1D, 0x48, 0x01 };
        /// <summary>
        /// Barcode 아래에 HRI Print
        /// </summary>
        public byte[] ESC_HRI_BELOWPRINT = { 0x1D, 0x48, 0x02 };
        /// <summary>
        /// Barcode 위,아래에 HRI Print
        /// </summary>
        public byte[] ESC_HRI_TOPANDBELOWPRINT = { 0x1D, 0x48, 0x03 };

        #endregion

        #region Alignment
        public byte[] ESC_CENTER = { 0x1B, 0x61, 0x01 };    // CENTER 정렬
        public byte[] ESC_RIGHT = { 0x1B, 0x61, 0x02 };	    // 오른쪽 정렬
        public byte[] ESC_LEFT = { 0x1B, 0x61, 0x00 };	    // 왼쪽   정렬
        #endregion

        #region Text

        public byte[] ESC_NORMAL = { 0x1B, 0x21, 0x00, 0x1C, 0x21, 0x00 };    //보통문자

        #region Select print mode
        // [Format]        1BH, 21H, n
        // [Valid limits]  0<=n<=255
        // [Initial value] n=0
        //┌──┬────────────┬────────────────────┐
        //│    │                        │                 Value                  │
        //│Bit │      Function          ├─────────┬──────────┤
        //│    │                        │          0       │           1        │
        //├──┼────────────┼─────────┼──────────┤
        //│ 0  │Character font          │Font A is selected│Font B/C is selected│
        //├──┼────────────┼─────────┼──────────┤
        //│ 1  │To be defined           │         --       │          --        │
        //├──┼────────────┼─────────┼──────────┤
        //│ 2  │To be defined           │         --       │          --        │
        //├──┼────────────┼─────────┼──────────┤
        //│ 3  │Emphasized printing     │       Candel     │       Specify      │
        //├──┼────────────┼─────────┼──────────┤
        //│ 4  │Double character height │       Candel     │       Specify      │
        //├──┼────────────┼─────────┼──────────┤
        //│ 5  │Double character width  │       Candel     │       Specify      │
        //├──┼────────────┼─────────┼──────────┤
        //│ 6  │To be defined           │         --       │          --        │
        //├──┼────────────┼─────────┼──────────┤
        //│ 7  │Underline               │       Candel     │       Specify      │
        //└──┴────────────┴─────────┴──────────┘


        public byte[] ESC_FontA = { 0x1B, 0x21, 0x00 };                         // Font A 인쇄
        public byte[] ESC_FontBC = { 0x1B, 0x21, 0x01 };	                    // Font B/C 인쇄

        public byte[] ESC_DOUBLE = { 0x1B, 0x21, 0x30, 0x1C, 0x57, 0x01 };	    // 가로세로 2배 확대
        public byte[] ESC_DBLHEIGH = { 0x1B, 0x21, 0x10, 0x1C, 0x21, 0x08 };    // 세로 2배 확대
        public byte[] ESC_DBLWIDTH = { 0x1B, 0x21, 0x20, 0x1C, 0x21, 0x04 };	// 가로 2배 확대        ESC + "|2hC"

        public byte[] ESC_UNDERLINE = { 0x1B, 0x21, 0x80 };	                    // UnderLine            ESC + "|uC"        
        public byte[] ESC_UNDERLINEON1DOT = { 0x1B, 0x2D, 0x01 };	            // UnderLine  Mode On 1Dot 
        public byte[] ESC_UNDERLINEON2DOT = { 0x1B, 0x2D, 0x02 };	            // UnderLine  Mode On 2Dot
        public byte[] ESC_UNDERLINEOFF = { 0x1B, 0x2D, 0x00 };	                // UnderLine  Mode Off
        #endregion

        #region Set Character size
        public byte[] ESC_VHMAG = { 0x1D, 0x21 };           // 배율확대확대 인쇄(FontSize)

        public byte[] ESC_H1MAG = { 0x1D, 0x21, 0x00 };     // 가로 1배확대 인쇄(FontSize)
        public byte[] ESC_V1MAG = { 0x1D, 0x21, 0x00 };	    // 세로 1배확대 인쇄(FontSize)

        public byte[] ESC_H2Y2MAG = { 0x1D, 0x21, 0x11 };	// 가로/세로 2배 확대
        public byte[] ESC_H2MAG = { 0x1D, 0x21, 0x10 };	// 가로 2배확대 인쇄(FontSize)
        public byte[] ESC_V2MAG = { 0x1D, 0x21, 0x01 };	    // 세로 2배확대 인쇄(FontSize)

        public byte[] ESC_H3MAG = { 0x1D, 0x21, 0x20 };	    // 가로 3배확대 인쇄(FontSize)
        public byte[] ESC_V3MAG = { 0x1D, 0x21, 0x02 };	    // 세로 3배확대 인쇄(FontSize)

        public byte[] ESC_H4MAG = { 0x1D, 0x21, 0x30 };	    // 가로 4배확대 인쇄(FontSize)
        public byte[] ESC_V4MAG = { 0x1D, 0x21, 0x03 };	    // 세로 4배확대 인쇄(FontSize)

        public byte[] ESC_H5MAG = { 0x1D, 0x21, 0x40 };	    // 가로 5배확대 인쇄(FontSize)
        public byte[] ESC_V5MAG = { 0x1D, 0x21, 0x04 };	    // 세로 5배확대 인쇄(FontSize)

        public byte[] ESC_H6MAG = { 0x1D, 0x21, 0x50 };	    // 가로 6배확대 인쇄(FontSize)
        public byte[] ESC_V6MAG = { 0x1D, 0x21, 0x05 };	    // 세로 6배확대 인쇄(FontSize)

        public byte[] ESC_H7MAG = { 0x1D, 0x21, 0x60 };	    // 가로 7배확대 인쇄(FontSize)
        public byte[] ESC_V7MAG = { 0x1D, 0x21, 0x06 };	    // 세로 7배확대 인쇄(FontSize)

        public byte[] ESC_H8MAG = { 0x1D, 0x21, 0x70 };	    // 가로 8배확대 인쇄(FontSize)
        public byte[] ESC_V8MAG = { 0x1D, 0x21, 0x07 };	    // 세로 8배확대 인쇄(FontSize)
        #endregion

        #region Set Bold On/Off
        public byte[] ESC_BOLD_ON = { 0x1B, 0x45, 0x01 };	    // 진하게 인쇄선언
        public byte[] ESC_BOLD_OFF = { 0x1B, 0x45, 0x00 };	    // 진하게 인쇄선언해제
        public byte[] ESC_BOLD = { 0x1B, 0x21, 0x08 };           //'진하게    ESC + "|bC"
        #endregion

        #region Set Reverse Mode On/Off
        /// <summary>
        /// On Reverse Mode 
        /// </summary>
        public byte[] ESC_REVERSE_MODE_ON = { 0x1D, 0x42, 0x01 };//ESC + "|rvC"
        /// <summary>
        /// Off Revers Mode
        /// </summary>
        public byte[] ESC_REVERSE_MODE_OFF = { 0x1D, 0x42, 0x00 };//ESC + "|!rvC"
        #endregion

        /*
        'ESC_CUT = Chr(&HA) + Chr(&HA) + Chr(&HA) + Chr(&HA) + Chr(&HA) + Chr(&HA) + Chr(&HA) + ESC + "|P"
        ESC_CUT = ESC + "|50P"
        'ESC_FEEDCUT = Chr(&HA) + Chr(&HA) + Chr(&HA) + Chr(&HA) + Chr(&HA) + Chr(&HA) + Chr(&HA) + ESC + "|fP"
        ESC_FEEDCUT = ESC + "|100fP"


        ESC_BITMAP1 = ESC + "|1B"
        ESC_BITMAP2 = ESC + "|2B"
        ESC_TOPLOGO = ESC + "|tL"
        ESC_BTMLOGO = ESC + "|bL"
        ESC_LINEFEED = ESC + "|lF"
        ESC_FEED = ESC + "|uF"
        
        ESC_NOT_BOLD = ESC + "|!bC"
        ESC_COLOR = ESC + "|rC"
        
        ESC_1MAG = ESC + "|1C"
        ESC_2MAG = ESC + "|4C"
        ESC_HMAG = ESC + "|2C"
        ESC_VMAG = ESC + "|3C"
        ESC_CENTER = ESC + "|cA"
        ESC_RIGHT = ESC + "|rA"
        
        */

        #endregion

        #region Cut paper
        [Browsable(false), Category("Exception"),
        Description("Cutting Command"),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [AmbientValue("")]
        public byte[] ESC_CUT = { 0x1D, 0x56, 0x31 }; //Convert.ToByte(49) };
        public byte[] ESC_FULLCUT = { 0x1B, 0x69 };
        public byte[] ESC_PARTCUT = { 0x1B, 0x6D };

        #endregion

        #region Paper sensor to outpu paper out signals
        //용지부족/용지없음 Sensor
        public byte[] ESC_PAPERSENSOR_OFF = { 0x1B, 0x63, 0x33, 0x00 };
        public byte[] ESC_PAPERSENSOR_ON = { 0x1B, 0x63, 0x33, 0x0F };
        #endregion

        #region Paper sensor to stop printing
        /// <summary>
        /// Paper near end detector Valid
        /// </summary>
        public byte[] ESC_PAPER_NEAREND_0N = { 0x1B, 0x63, 0x34, 0x01 };
        /// <summary>
        /// Paper near end detector InValid
        /// </summary>
        public byte[] ESC_PAPER_NEAREND_0FF = { 0x1B, 0x63, 0x34, 0x01 };
        #endregion

        #region Real-time status transmission
        public byte[] ESC_TRANS_STATUS = { 0x10, 0x04, 0x01 };
        /// <summary>
        /// Cover 상태 체크 명령어
        /// </summary>
        public byte[] ESC_TRANS_OFFLINE = { 0x10, 0x04, 0x02 };
        public byte[] ESC_TRANS_ERR_STUS = { 0x10, 0x04, 0x03 };
        /// <summary>
        /// Paper 상태 체크 명령어
        /// </summary>
        public byte[] ESC_TRANS_CONTI_STATUS = { 0x10, 0x04, 0x04 };
        #endregion

        #region Enable/disable automatic status back
        public byte[] ESC_STATUSBACK = { 0x1d, 0x61, 0xCF };
        #endregion

        #region Select peripheral device
        public byte[] ESC_DEVICE_PRT = { 0x1B, 0x3D, 0x01 };
        #endregion

        #region Open CashDrawer
        public byte[] cmd_OpenCashDraerBox = { 0x1B, 0x70, 0x30 };
        #endregion

        #region Print Type
        public enum PRT_CMD
        {
            NONE,       //미지원 형식
            PRT_IMG,    //Image
            PRT_BAR,    //바코드
            PRT_CUT,    //CUT
            PRT_NOR,    //일반 문자
            PRT_BLD,    //진하게
            PRT_VER,    //세로확대
            PRT_HOR,    //가로확대
            PRT_BIG,    //가로/세로확대
            PRT_CNT,    //가로확대+가운데 정렬
            PRT_JNL,    //저널데이터
            PRT_DRW,    //돈통열림
            ERROR      //Error
        }

        public string PRT_IMG = "[IMG]";   //Image
        public string PRT_BAR = "[BAR]";   //바코드
        public string PRT_CUT = "[CUT]";   //CUT
        public string PRT_NOR = "[NOR]";   //일반 문자
        public string PRT_BLD = "[BLD]";   //진하게
        public string PRT_VER = "[VER]";   //세로확대
        public string PRT_HOR = "[HOR]";   //가로확대
        public string PRT_BIG = "[BIG]";   //가로/세로확대
        public string PRT_CNT = "[CNT]";   //가로확대+가운데 정렬
        public string PRT_JNL = "[JNL]";   //저널데이터
        public string PRT_DRW = "[DRW]";   //돈통열림
        #endregion

        #region 상태체크
        /// <summary>
        /// 상태체크(Paper, Drawer 상태 )
        /// Drawer 상태는 상태체크가 가능한 돈통에 한함.
        /// </summary>
        public enum CHK_PRT_STATUS
        {
            CHK_PAPER,
            CHK_DRAWER
        }
        #endregion
    }


    /// <summary>
    /// Printer Status Information
    /// </summary>
    [Serializable]
    public class PrinterInformation
    {
        #region Printer Event
        private bool[,] Infomation = new bool[8 * 4, 2];
        private enum eStatusInfo : int
        {
            //Event First Byte
            /// <summary>
            /// State of the drawer kick connector pin 3 [false:Low, true: High]
            /// </summary>
            DrwKickLH = 7 - 2,
            /// <summary>
            /// Online.offline [false: Online, true: Offline]
            /// </summary>
            OnOffLine = 7 - 3,
            /// <summary>
            /// Cover state [false:Closed, true : Open]
            /// </summary>
            Coverstate = 7 - 5,
            /// <summary>
            /// Paper feed by paper feed switch [false:Stopped, true : Operation]
            /// </summary>
            feedswitch = 7 - 6,

            //Event Second Byte(error information)
            /// <summary>
            /// Macro executing [false:Not execute, true : execute]
            /// </summary>
            MacroExecuting = 8 + 7 - 0,
            /// <summary>
            /// Panel switch[false:Off, true:On]
            /// </summary>
            Panelswitch = 8 + 7 - 1,
            /// <summary>
            /// Mechanical error(cover Open, Cutter Jam) [false:No, true: Yes]
            /// </summary>
            MechanicalErr = 8 * 7 - 2,
            /// <summary>
            /// Cutter jam [false:No, true: Yes]
            /// </summary>
            CutterJam = 8 * 7 - 3,
            /// <summary>
            /// Unrecoverable error[false:No, true:Yes]
            /// </summary>
            UnrecoverableErr = 8 + 7 - 5,
            /// <summary>
            /// Auto-recoverrable error detected [false:No, true:Yes]
            /// </summary>
            AutoRecoverableErr = 8 + 7 - 6,

            //Third byte(paper detector information)
            /// <summary>
            /// Roll Paper Near end detecter[false:Paper present, true Nopaper]
            /// </summary>
            PaperNearEnd_1 = 16 + 7 - 0,
            /// <summary>
            /// Roll Paper Near end detecter[false:Paper present, true Nopaper]
            /// </summary>
            PaperNearEnd_2 = 16 + 7 - 0,
            /// <summary>
            /// Roll Paper end detecter[false:Paper present, true Nopaper]
            /// </summary>
            PaperEnd_1 = 16 + 7 - 2,
            /// <summary>
            /// Roll Paper end detecter[false:Paper present, true Nopaper]
            /// </summary>
            PaperEnd_2 = 16 + 7 - 3,

            //Fourth byte (paper detector information)
            /// <summary>
            /// F/W down load Fail[false: Not Fail, true: Fail]
            /// </summary>
            FWdownLoadFail = 24 + 7 - 5
        }
        public enum eSetStatusType : int
        {
            /// <summary>
            /// PRINTER STATUS[First Byte]
            /// </summary>
            PRT_PRINTERINFOMATION,
            /// <summary>
            /// ERROR INFOMATION[Second Byte]
            /// </summary>
            PRT_ERRINFOMATION,
            /// <summary>
            /// Paper Status[Third Byte]
            /// </summary>
            PRT_PAPERINFOMATION,
            /// <summary>
            /// Firm Ware[Fourth Byte]
            /// </summary>
            PRT_FIRMWAREDOWN
        }
        #endregion

        #region All Set
        public void SetAllData(char[] szData)
        {
            char[] szEvt = szData;

            //string bitStringFirst = str2bitstr(szData[0].ToString(), 1);
            //string bitStringSecond = str2bitstr(szData[1].ToString(), 1);
            //string bitStringThird = str2bitstr(szData[2].ToString(), 1);
            //string bitStringFourth = str2bitstr(szData[3].ToString(), 1);
            //string sBitInfo = bitStringFirst + bitStringSecond + bitStringThird + bitStringFourth;

            string sBitInfo = "";
            sBitInfo = str2bitstr(szData[0].ToString(), 1);
            sBitInfo += str2bitstr(szData[1].ToString(), 1);
            sBitInfo += str2bitstr(szData[2].ToString(), 1);
            sBitInfo += str2bitstr(szData[3].ToString(), 1);


            string sValue = "";
            for (int nRow = 0; nRow < Infomation.GetLength(0); nRow++)
            {
                sValue = sBitInfo.Substring(nRow, 1);

                Infomation[nRow, 1] = Infomation[nRow, 0] == (sValue == "1" ? true : false) ? false : true;
                Infomation[nRow, 0] = sValue == "1" ? true : false;
            }

            //bool DrawerKick = Infomation[eStatusInfo.DrwKickLH];
        }
        public char[] GetAllData()
        {
            string sRet = "";
            string szTemp = "";

            for (int nRow = 0; nRow < Infomation.Length; nRow++)
            {
                szTemp += Infomation[nRow, 1] == true ? "1" : "0";
            }
            return sRet.ToCharArray();
        }
        #endregion

        #region Printer Status First/Second/Third/Fourth Byte Set
        public void SetPrintStatus(eSetStatusType eType, char szData)
        {
            string sBitInfo = str2bitstr(szData.ToString(), 1);

            int nStart = 0;
            switch (eType)
            {
                case eSetStatusType.PRT_PRINTERINFOMATION: nStart = 0; break;
                case eSetStatusType.PRT_ERRINFOMATION: nStart = 8; break;
                case eSetStatusType.PRT_PAPERINFOMATION: nStart = 16; break;
                case eSetStatusType.PRT_FIRMWAREDOWN: nStart = 24; break;
                default: return;
            }
            string sValue = "";
            for (int nRow = 0; nRow < 8; nRow++)
            {
                sValue = sBitInfo.Substring(nRow, 1);

                Infomation[nStart + nRow, 1] = Infomation[nStart + nRow, 0] == (sValue == "1" ? true : false) ? false : true;
                Infomation[nStart + nRow, 0] = sValue == "1" ? true : false;
            }
        }
        #endregion

        #region First Byte(Printer Infomation)
        /// <summary>
        /// [Printer Status Infomation]
        /// State of the drawer kick connector pin3
        /// FALSE: Low, TRUE : High
        /// </summary>
        public bool IsDrawerKickLoHi { get { return Infomation[(int)eStatusInfo.DrwKickLH, 0]; } set { Infomation[(int)eStatusInfo.DrwKickLH, 0] = value; } }
        public bool IsDrawerKickLoHiChange { get { bool bRet = Infomation[(int)eStatusInfo.DrwKickLH, 1]; Infomation[(int)eStatusInfo.DrwKickLH, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.DrwKickLH, 1] = value; } }
        /// <summary>
        /// [Printer Status Infomation]
        /// OnLine / OffLine
        /// FALSE : OnLine, TRUE ; OffLine
        /// </summary>
        public bool IsOffLine { get { return Infomation[(int)eStatusInfo.OnOffLine, 0]; } set { Infomation[(int)eStatusInfo.OnOffLine, 0] = value; } }
        public bool IsOffLineChange { get { bool bRet = Infomation[(int)eStatusInfo.OnOffLine, 1]; Infomation[(int)eStatusInfo.OnOffLine, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.OnOffLine, 1] = value; } }
        /// <summary>
        /// [Printer Status Infomation]
        /// Cover Open
        /// FALSE : Closed, TRUE : Open
        /// </summary>
        public bool IsCoverOpen { get { return Infomation[(int)eStatusInfo.Coverstate, 0]; } set { Infomation[(int)eStatusInfo.Coverstate, 0] = value; } }
        public bool IsCoverOpenChange { get { bool bRet = Infomation[(int)eStatusInfo.Coverstate, 1]; Infomation[(int)eStatusInfo.Coverstate, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.Coverstate, 1] = value; } }
        /// <summary>
        /// [Printer Status Infomation]
        /// Feed Switch 
        /// FALSE : stop, TRUE : operating
        /// </summary>
        public bool Isfeedswitch { get { return Infomation[(int)eStatusInfo.feedswitch, 0]; } set { Infomation[(int)eStatusInfo.feedswitch, 0] = value; } }
        public bool IsfeedswitchChange { get { bool bRet = Infomation[(int)eStatusInfo.feedswitch, 1]; Infomation[(int)eStatusInfo.feedswitch, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.feedswitch, 1] = value; } }
        #endregion

        #region Second Byte(error information)
        /// <summary>
        /// [Error Information]
        /// IsMacroExecuting
        /// FALSE : Not Excuting,  TRUE : Excuting
        /// </summary>
        public bool IsMacroExecuting { get { return Infomation[(int)eStatusInfo.MacroExecuting, 0]; } set { Infomation[(int)eStatusInfo.MacroExecuting, 0] = value; } }
        public bool IsMacroExecutingChange { get { bool bRet = Infomation[(int)eStatusInfo.MacroExecuting, 1]; Infomation[(int)eStatusInfo.MacroExecuting, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.MacroExecuting, 1] = value; } }
        /// <summary>
        /// [Error Information]
        /// Panel switch
        /// FALSE : OFF, TRUE : ON
        /// </summary>
        public bool IsPanelswitch { get { return Infomation[(int)eStatusInfo.Panelswitch, 0]; } set { Infomation[(int)eStatusInfo.Panelswitch, 0] = value; } }
        public bool IsPanelswitchChange { get { bool bRet = Infomation[(int)eStatusInfo.Panelswitch, 1]; Infomation[(int)eStatusInfo.Panelswitch, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.Panelswitch, 1] = value; } }
        /// <summary>
        /// [Error Information]
        /// Mechanical Error
        /// (Cover oen, Cutter jam)
        /// FALSE : No, TRUE : Yes
        /// </summary>
        public bool IsMechanicalError { get { return Infomation[(int)eStatusInfo.MechanicalErr, 0]; } set { Infomation[(int)eStatusInfo.MechanicalErr, 0] = value; } }
        public bool IsMechanicalErrorChange { get { bool bRet = Infomation[(int)eStatusInfo.MechanicalErr, 1]; Infomation[(int)eStatusInfo.MechanicalErr, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.MechanicalErr, 1] = value; } }
        /// <summary>
        /// [Error Information]
        /// Cutter jam
        /// FALSE : No, TRUE : Yes
        /// </summary>
        public bool IsCutterJam { get { return Infomation[(int)eStatusInfo.CutterJam, 0]; } set { Infomation[(int)eStatusInfo.CutterJam, 0] = value; } }
        public bool IsCutterJamChange { get { bool bRet = Infomation[(int)eStatusInfo.CutterJam, 1]; Infomation[(int)eStatusInfo.CutterJam, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.CutterJam, 1] = value; } }
        /// <summary>
        /// [Error Information]
        /// Unrecoverable Error
        /// FALSE : No, TRUE : Yes
        /// </summary>
        public bool IsUnrecoverableErr { get { return Infomation[(int)eStatusInfo.UnrecoverableErr, 0]; } set { Infomation[(int)eStatusInfo.UnrecoverableErr, 0] = value; } }
        public bool IsUnrecoverableErrChange { get { bool bRet = Infomation[(int)eStatusInfo.UnrecoverableErr, 1]; Infomation[(int)eStatusInfo.UnrecoverableErr, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.UnrecoverableErr, 1] = value; } }
        /// <summary>
        /// [Error Information]
        /// Auto-Recoverable Error detected
        /// FALSE : No, TRUE : Yes
        /// </summary>
        public bool IsAutoRecoverableErr { get { return Infomation[(int)eStatusInfo.AutoRecoverableErr, 0]; } set { Infomation[(int)eStatusInfo.AutoRecoverableErr, 0] = value; } }
        public bool IsAutoRecoverableErrChange { get { bool bRet = Infomation[(int)eStatusInfo.AutoRecoverableErr, 1]; Infomation[(int)eStatusInfo.AutoRecoverableErr, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.AutoRecoverableErr, 1] = value; } }
        #endregion

        #region Third byte(paper detector information)
        /// <summary>
        /// [paper detector information]
        /// Roll paper near end detector
        /// FALSE : Paper present , TRUE : No paper
        /// </summary>
        private bool IsPaperNearEnd_1 { get { return Infomation[(int)eStatusInfo.PaperNearEnd_1, 0]; } set { Infomation[(int)eStatusInfo.PaperNearEnd_1, 0] = value; } }
        private bool IsPaperNearEnd_1Change { get { bool bRet = Infomation[(int)eStatusInfo.PaperNearEnd_1, 1]; Infomation[(int)eStatusInfo.PaperNearEnd_1, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.PaperNearEnd_1, 1] = value; } }
        /// <summary>
        /// [paper detector information]
        /// Roll paper near end detector
        /// FALSE : Paper present , TRUE : No paper
        /// </summary>
        private bool IsPaperNearEnd_2 { get { return Infomation[(int)eStatusInfo.PaperNearEnd_2, 0]; } set { Infomation[(int)eStatusInfo.PaperNearEnd_2, 0] = value; } }
        private bool IsPaperNearEnd_2Change { get { bool bRet = Infomation[(int)eStatusInfo.PaperNearEnd_2, 1]; Infomation[(int)eStatusInfo.PaperNearEnd_2, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.PaperNearEnd_2, 1] = value; } }
        /// <summary>
        /// [paper detector information]
        /// Roll paper near end detector
        /// FALSE : Paper present , TRUE : No paper
        /// </summary>
        public bool IsPaperNearEnd { get { if (IsPaperNearEnd_1 && IsPaperNearEnd_2)return true; else return false; } set { IsPaperNearEnd_1 = value; IsPaperNearEnd_2 = value; } }
        public bool IsPaperNearEndChange { get { if (IsPaperNearEnd_1Change && IsPaperNearEnd_2Change)return true; else return false; } set { IsPaperNearEnd_1Change = value; IsPaperNearEnd_2Change = value; } }

        /// <summary>
        /// [paper detector information]
        /// Roll paper end detector
        /// FALSE : Paper present , TRUE : No paper
        /// </summary>
        private bool IsPaperEnd_1 { get { return Infomation[(int)eStatusInfo.PaperEnd_1, 0]; } set { Infomation[(int)eStatusInfo.PaperEnd_1, 0] = value; } }
        private bool IsPaperEnd_1Change { get { bool bRet = Infomation[(int)eStatusInfo.PaperEnd_1, 1]; Infomation[(int)eStatusInfo.PaperEnd_1, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.PaperEnd_1, 1] = value; } }
        /// <summary>
        /// [paper detector information]
        /// Roll paper end detector
        /// FALSE : Paper present, TRUE : No paper
        /// </summary>
        private bool IsPaperEnd_2 { get { return Infomation[(int)eStatusInfo.PaperEnd_2, 0]; } set { Infomation[(int)eStatusInfo.PaperEnd_2, 0] = value; } }
        private bool IsPaperEnd_2Change { get { bool bRet = Infomation[(int)eStatusInfo.PaperEnd_2, 1]; Infomation[(int)eStatusInfo.PaperEnd_2, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.PaperEnd_2, 1] = value; } }
        /// <summary>
        /// [paper detector information]
        /// Roll paper end detector
        /// FALSE : Paper present, TRUE : No paper
        /// </summary>
        public bool IsPaperEnd { get { if (IsPaperEnd_1 && IsPaperEnd_2) return true; else return false; } set { IsPaperEnd_1 = value; IsPaperEnd_2 = value; } }
        public bool IsPaperEndChange { get { if (IsPaperEnd_1Change && IsPaperEnd_2Change) return true; else return false; } set { IsPaperEnd_1Change = value; IsPaperEnd_2Change = value; } }
        #endregion

        #region Fourth byte (paper detector information)
        /// <summary>
        /// [paper detector information]
        /// paper detector information
        /// FW down load Fail
        /// FALSE : Not Fail, TRUE : Fail
        /// </summary>
        public bool IsFWdownLoadFail { get { return Infomation[(int)eStatusInfo.FWdownLoadFail, 0]; } set { Infomation[(int)eStatusInfo.FWdownLoadFail, 0] = value; } }
        public bool IsFWdownLoadFailChange { get { bool bRet = Infomation[(int)eStatusInfo.FWdownLoadFail, 1]; Infomation[(int)eStatusInfo.FWdownLoadFail, 1] = false; return bRet; } set { Infomation[(int)eStatusInfo.FWdownLoadFail, 1] = value; } }
        #endregion

        #region 형변환
        private long chararry2Hexstr(char[] src, int st, out string dest)
        {
            long nRet = 0;
            char[] temp = null;

            dest = "";

            if (src.Length < 1)
                return 0;

            temp = new char[src.Length - st];
            for (int i = 0; i < src.Length - st; i++)
            {
                temp[i] = src[i + st];
                string tt = src[i + st].ToString();
                dest += String.Format("{0:X}", tt);
            }
            //temp.CopyTo(src, st);

            //bit
            //string sbit = int.Parse("0100", System.Globalization.NumberStyles.AllowHexSpecifier) & (2 ^ 0);

            return nRet;
        }

        // String To Hex
        private int string2Hex(string src)
        {
            return int.Parse(src, System.Globalization.NumberStyles.HexNumber);
        }
        public string string2Hexstr(string src)
        {
            string sRet = "";
            char[] values = src.ToCharArray();
            foreach (char letter in values)
            {
                uint value = Convert.ToUInt32(letter);
                string hexstr = string.Format("{0:X2}", value);
                sRet += hexstr;
            }
            return sRet;
        }
        // Hex To String
        private string Hex2string(int number)
        {
            return Convert.ToString(number, 16).ToUpper().PadLeft(2, '0');
        }
        // Byte[] To UInt32 
        private UInt32 Byte2UInt32SmallEndian(byte[] src, int i)
        {
            return Convert.ToUInt32(src[i] + (src[i + 1] << 8) + (src[i + 2] << 16) + (src[i + 3] << 24));
        }
        // Byte[] To UInt32 
        private UInt32 Byte2UInt32BigEndian(byte[] src, int i)
        {
            return Convert.ToUInt32(src[i + 3] + (src[i + 2] << 8) + (src[i + 1] << 16) + (src[i] << 24));
        }

        //UInt32 To Byte[] Small-Endian
        private void Uint322Byte(byte[] dstByte, UInt32 srcuint, int start)
        {
            dstByte[3 + start] = (byte)((srcuint & 0xff000000) >> 24);
            dstByte[2 + start] = (byte)((srcuint & 0x00ff0000) >> 16);
            dstByte[1 + start] = (byte)((srcuint & 0x0000ff00) >> 8);
            dstByte[0 + start] = (byte)((srcuint & 0x000000ff));
        }
        //UInt32 To Byte[] Big-Endian
        private void UInt32ToByteBif(byte[] dstByte, UInt32 srcuint, int start)
        {
            dstByte[0 + start] = (byte)((srcuint & 0xff000000) >> 24);
            dstByte[1 + start] = (byte)((srcuint & 0x00ff0000) >> 16);
            dstByte[2 + start] = (byte)((srcuint & 0x0000ff00) >> 8);
            dstByte[3 + start] = (byte)((srcuint & 0x000000ff));
        }

        //byte[] To string
        public String Byte2string(byte[] src)
        {
            //string sRet = Encoding.Default.GetString(src);
            return Encoding.Default.GetString(src);// UnicodeEncoding.ASCII.GetString(src);
        }
        public String Byte2string(byte[] src, int index, int size)
        {
            string sRet = "";
            char sz;
            for (int i = index; i < src.Length; i++)
            {
                sz = Convert.ToChar(src[i]);
                sRet += sz.ToString();
            }
            return sRet;// UnicodeEncoding.ASCII.GetString(src, index, size);
        }

        //string To Byte[]
        public Byte[] string2byte(String src)
        {
            return Encoding.Default.GetBytes(src); //UnicodeEncoding.ASCII.GetBytes(src); 
        }
        //string To Byte[]
        public int string2byte(String src, int sindex, int slength, byte[] dst, int bindex)
        {
            return UnicodeEncoding.ASCII.GetBytes(src, sindex, slength, dst, bindex);
        }

        /// <summary>
        /// 문자열을 byte[]으로 변환
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private byte[] ConvertToByteArrayFromString(string str)
        {
            byte[] temp = Encoding.Default.GetBytes(str);

            if (temp.Length % 16 != 0)
            {
                byte[] temp2 = new byte[((temp.Length / 16) + 1) * 16];
                Buffer.BlockCopy(temp, 0, temp2, 0, temp.Length);
                return temp2;
            }
            else
            {
                return temp;
            }
        }

        public byte[] hex2Byte(string hex)
        {
            byte[] bytes = new byte[hex.Length / 2];
            for (int i = 0; i < bytes.Length; i++)
            {
                try
                {
                    bytes[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
                }
                catch
                {
                    throw new ArgumentException("hex is not a valid hex number!", "hex");
                }
            } return bytes;
        }

        public string str2bitstr(string sValue, int nByteLen)
        {
            //char bit;

            string sRet = "";

            string hexstr = string2Hexstr(sValue);
            long value = string2Hex(hexstr);
            sRet += Convert.ToString(value, 2).PadLeft(8, '0');

            int d = Math.Abs((sRet.Length % 8) - 8);
            if (d != 8 && d != 0)
                sRet = sRet.PadLeft(d + sRet.Length, '0');

            return sRet;
        }
        #endregion
    }
}
