条码标签斑马打印

        public Form1()
        {
            InitializeComponent();
            InitPrinter(comboBox1);
            Init();
            textBox1.Focus();
        }
        Connection SATOPrinter = new Connection();
        PrinterDriver SATODriver = new PrinterDriver();
        Dictionary<string, int> Name2Idx = new Dictionary<string, int>();
        string[] ASCIIMAP = { "[NUL]", "[SOH]", "[STX]", "[ETX]", "[EOT]", "[ENQ]", "[ACK]", "[BEL]", "[BS]" };
        List<string> list = new List<string>();
        #region INI deal with
        [DllImport("kernel32")]//返回0表示失败,非0为成功
        private static extern long WritePrivateProfileString(string section,
                                                        string key,
                                                        string val,
                                                        string filePath);
        [DllImport("kernel32")]//返回取得字符串缓冲区的长度
        private static extern long GetPrivateProfileString(string section,
                                                    string key,
                                                    string def,
                                                    StringBuilder retVal,
                                                    int size,
                                                    string filePath);
        //写入INI
        private bool WriteIni(string Section, string Key, string Value, string iniFilePath)
        {
            long o = WritePrivateProfileString(Section, Key, Value, iniFilePath);
            if (o == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        //读取INI
        private string ReadIni(string Section, string Key, string NoText, string iniFilePath)
        {
            if (File.Exists(iniFilePath))
            {
                StringBuilder sb = new StringBuilder(1024);
                GetPrivateProfileString(Section, Key, NoText, sb, 1024, iniFilePath);
                return sb.ToString();
            }
            else
            {
                return String.Empty;
            }
        }
        //读配置文件
        string file = System.Windows.Forms.Application.StartupPath + @"\printset.ini";
        private void getINI(string printer, string printtype, string length, out string barx, out string bary, out string txtx, out string txty, out string barheight, out string null1, out string null2)
        {
            if (!File.Exists(file))
            {
                WriteIni("Procode", "8", "0050,0005,0050,0085,075,   ,   ,", file);
                WriteIni("Procode", "9", "0080,0005,0080,0085,075,   ,   ,", file);

                WriteIni("Package", "T8", "50,10,50,90,75", file);
                WriteIni("Package", "T9", "50,10,50,90,75", file);

                WriteIni("Package", "S8", "50,10,50,90,75", file);
                WriteIni("Package", "S9", "50,10,50,90,75", file);

                WriteIni("Other", "8", "0050,0005,0050,0085,075", file);
                WriteIni("Other", "9", "0050,0005,0050,0085,075", file);
            }
            barx = "";
            bary = "";
            txtx = "";
            txty = "";
            barheight = "";
            null1 = "";
            null2 = "";
            if (printtype.Equals("Procode"))
            {
                string data = ReadIni("Procode", length, "", file);
                barx = data.Split(',')[0];
                bary = data.Split(',')[1];
                txtx = data.Split(',')[2];
                txty = data.Split(',')[3];
                barheight = data.Split(',')[4];
                null1 = data.Split(',')[5];
                null2 = data.Split(',')[6];
            }
            else if (printtype.Equals("Package"))
            {
                if (printer.StartsWith("S"))
                {
                    string data = ReadIni("Package", "S" + length, "", file);
                    barx = data.Split(',')[0];
                    bary = data.Split(',')[1];
                    txtx = data.Split(',')[2];
                    txty = data.Split(',')[3];
                    barheight = data.Split(',')[4];
                }
                else
                {
                    string data = ReadIni("Package", "T" + length, "", file);
                    barx = data.Split(',')[0];
                    bary = data.Split(',')[1];
                    txtx = data.Split(',')[2];
                    txty = data.Split(',')[3];
                    barheight = data.Split(',')[4];
                }
            }
            else
            {
                string data = ReadIni("Attach", length, "", file);
                barx = data.Split(',')[0];
                bary = data.Split(',')[1];
                txtx = data.Split(',')[2];
                txty = data.Split(',')[3];
                barheight = data.Split(',')[4];
            }
        }
        #endregion
        #region  Initialize Name2Idx
        private void Init()
        {
            int idx = 0;
            foreach (string s in ASCIIMAP)
            {
                Name2Idx.Add(s, idx);
            }
            Name2Idx.Add("[ESC]", 0x1b);
            Name2Idx.Add("[NAK]", 0x15);
            Name2Idx.Add("[DC2]", 0x12);
        }
        private byte[] S2BA(string s)
        {
            s = DecodeStr(s);
            return SATOPrinter.String2ByteArray(s);
        }
        private string DecodeStr(string s)
        {
            string ret;
            ret = s.Replace("[{NUL}]", "" + (char)0);
            ret = ret.Replace("[{HT}]", "" + (char)0x09);
            ret = ret.Replace("[{0x85}]", "" + (char)0x85);
            ret = ret.Replace("[{0xA0}]", "" + (char)0xA0);
            return ret;
        }
        #endregion
        #region Initialize Printer
        private void InitPrinter(ComboBox combo)
        {
            PrinterSettings.StringCollection stringCollection = PrinterSettings.InstalledPrinters;//获取已安装的打印机
            string printerName = string.Empty;
            Regex regex = new Regex("^.*ZPL.*$");
            string value = "";
            foreach(string printer in stringCollection)
            {
                printerName = printer.ToString();
                combo.Items.Add(printerName);
                if (regex.IsMatch(printerName))
                {
                    value = printerName;
                }
            }
            combo.Text = value;
        }
        #endregion
        #region Bartender
        private void PrinterBar()
        {
            ApplicationClass ac;
            Format format;
            ac = new ApplicationClass();
            format = ac.Formats.Open("D:\\Template\\1.btw", true, "");
            format.Printer = comboBox1.Text;
            format.PrintOut(false, false);
        }
        #endregion
        #region test
        DataTable dt;
        private void InitTable(string procode)
        {
            dt = new DataTable();
            DataColumn[] dc = new DataColumn[3];
            dc[0] = new DataColumn("procode", typeof(string));
            dc[1] = new DataColumn("mlot", typeof(string));
            dc[2] = new DataColumn("serials", typeof(string));
            dt.Columns.AddRange(dc);

            DataRow row = dt.NewRow();
            row["procode"] = procode;
            row["mlot"] = "210928";
            row["serials"] = "0001";
            dt.Rows.Add(row);

            DataRow row2 = dt.NewRow();
            row2["procode"] = procode;
            row2["mlot"] = "210928";
            row2["serials"] = "0002";
            dt.Rows.Add(row2);

            DataRow row3 = dt.NewRow();
            row3["procode"] = procode;
            row3["mlot"] = "210928";
            row3["serials"] = "0003";
            dt.Rows.Add(row3);
        }
        #endregion
        private void button1_Click(object sender, EventArgs e)
        {
            if (textBox1.Text.Length < 8)
            {
                PrinterBar();
                return;
            }
            string barx = "";
            string bary = "";
            string txtx = "";
            string txty = "";
            string barheight = "";
            string null1 = "";
            string null2 = "";
            getINI(comboBox1.Text, "Package", textBox1.Text.Length.ToString(), out barx, out bary, out txtx, out txty, out barheight, out null1, out null2);
            InitTable(textBox1.Text);
            foreach (DataRow row in dt.Rows)
            {
                string s = row["procode"].ToString() + row["mlot"].ToString() + row["serials"].ToString();
                list.Add(s);
            }
            int numbers = 1; //打印份数
            if (comboBox1.Text.StartsWith("T"))
            {
                TSCSerials_DLL.openport(comboBox1.Text);
                //获取打印条码值
                foreach (string s in list)
                {
                    for (int i = 0; i < numbers; i++)
                    {
                        string command = "SPEED 5" + "\r\n" + "SIZE 80 mm, 20 mm" + "\r\n" + "GAP 2 mm,0" + "\r\n" + "CLS" + "\r\n" + "BARCODE " + barx + "," + bary + ",\"128\"," + barheight + ",0,0,2,2,\"" + s + "\"" + "\r\n" + "TEXT " + txtx + "," + txty + ",\"3\",0,1,2,\"" + s + "\"" + "\r\n" + "PRINT 1" + "\r\n";
                        TSCSerials_DLL.sendcommand(command);
                    }
                }
                TSCSerials_DLL.closeport();
            }
            else if (comboBox1.Text.StartsWith("Z"))
            {
                ZebraPrintHelper.PrinterProgrammingLanguage = ProgrammingLanguage.EPL;
                ZebraPrintHelper.PrinterName = comboBox1.Text;
                ZebraPrintHelper.PrinterType = DeviceType.DRV;
                foreach (string s in list)
                {
                    string zebra_cmd = "";
                    zebra_cmd = @"^XA^FO" + barx + "," + bary + "^BY2,3," + barheight + "^BCN,,N,N,N^FD" + s + "^FS^FO" + txtx + "," + txty + "^ABN,20,N^FD" + s + "^FS^XZ";
                    ZebraPrintHelper.PrintCommand(zebra_cmd);
                }
            }
            else
            {
                foreach (string s in list)
                {
                    for (int i = 0; i < numbers; i++)
                    {
                        string esc = "" + (char)Name2Idx["[ESC]"];
                        string barcode = "";
                        string txt = "";
                        barcode = esc + "A" + "\r\n" + esc + "H" + barx + esc + "V" + bary + esc + "BG02" + barheight + s + "\r\n";
                        txt = esc + "H" + txtx + esc + "V" + txty + esc + "L0102" + esc + "XM" + s + "\r\n" + esc + "Q1" + "\r\n" + esc + "Z";
                        byte[] cmd = S2BA(barcode + txt);
                        SATODriver.SendBytesViaDriver(comboBox1.Text, cmd);
                    }
                }

            }



        }

        private void textBox1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                comboBox1.Focus();
            }
        }

        private void comboBox1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                button1.Focus();
            }
        }

    }
    /// <summary>
    /// TSC打印机
    /// </summary>
    public class TSCSerials_DLL
    {
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "about")]
        public static extern int about();
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "openport")]
        public static extern int openport(string printername);
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "barcode")]
        public static extern int barcode(string x, string y, string type, string height, string readable, string rotation, string narrow, string wide, string code);
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "clearbuffer")]
        public static extern int clearbuffer();
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "closeport")]
        public static extern int closeport();
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "downloadpcx")]
        public static extern int downloadpcx(string filename, string image_name);
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "formfeed")]
        public static extern int formfeed();
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "nobackfeed")]
        public static extern int nobackfeed();
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "printerfont")]
        public static extern int printerfont(string x, string y, string fonttype, string rotation, string xmul, string ymul, string text);
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "printlabel")]
        public static extern int printlabel(string set, string copy);
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "sendcommand")]
        public static extern int sendcommand(string printercommand);
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "setup")]
        public static extern int setup(string width, string height, string speed, string density, string sensor, string vertical, string offset);
        [DllImport("Dlls\\TSCIB.dll", EntryPoint = "windowsfont")]
        public static extern int windowsfont(int x, int y, int fontheight, int rotation, int fontstyle, int fontunderline, string szFaceName, string content);
    }
    /// <summary>
    /// 斑马打印助手,支持LPT/COM/USB/TCP四种模式,适用于标签、票据、条码打印。
    /// </summary>
    public static class ZebraPrintHelper
    {
        #region 定义API方法

        #region 写打印口(LPT)方法
        private const short FILE_ATTRIBUTE_NORMAL = 0x80;
        private const short INVALID_HANDLE_VALUE = -1;
        private const uint GENERIC_READ = 0x80000000;
        private const uint GENERIC_WRITE = 0x40000000;
        private const uint CREATE_NEW = 1;
        private const uint CREATE_ALWAYS = 2;
        private const uint OPEN_EXISTING = 3;
        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern SafeFileHandle CreateFile(string strFileName,
            uint dwDesiredAccess,
            uint dwShareMode,
            IntPtr intptrSecurityAttributes,
            uint dwCreationDisposition,
            uint dwFlagsAndAttributes,
            IntPtr intptrTemplateFile);
        #endregion

        [DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Auto, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string printerName, out IntPtr intptrPrinter, IntPtr intptrPrintDocument);

        [DllImport("winspool.Drv", EntryPoint = "ClosePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool ClosePrinter(IntPtr intptrPrinter);

        [DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Auto, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool StartDocPrinter(IntPtr intptrPrinter, Int32 level, [In, MarshalAs(UnmanagedType.LPStruct)] DocInfo docInfo);

        [DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool EndDocPrinter(IntPtr intptrPrinter);

        [DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool StartPagePrinter(IntPtr intptrPrinter);

        [DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool EndPagePrinter(IntPtr intptrPrinter);

        [DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern bool WritePrinter(IntPtr intptrPrinter, IntPtr intptrBytes, Int32 count, out Int32 written);
        #endregion

        #region 定义私有字段

        /// <summary>  
        /// 线程锁,防止多线程调用。  
        /// </summary>  
        private static object SyncRoot = new object();

        /// <summary>  
        /// 字节流传递时采用的字符编码  
        /// </summary>  
        private static readonly Encoding TransferFormat = Encoding.GetEncoding("iso-8859-1");

        #endregion

        #region 定义属性
        public static int Port { get; set; }
        public static string PrinterName { get; set; }
        public static bool IsWriteLog { get; set; }
        public static DeviceType PrinterType { get; set; }
        public static ProgrammingLanguage PrinterProgrammingLanguage { get; set; }

        public static float TcpLabelMaxHeightCM { get; set; }
        public static int TcpPrinterDPI { get; set; }
        public static string TcpIpAddress { get; set; }
        public static int TcpPort { get; set; }
        public static int Copies { get; set; }

        /// <summary>  
        /// 日志保存目录,WEB应用注意不能放在BIN目录下。  
        /// </summary>  
        public static string LogsDirectory { get; set; }

        private static byte[] GraphBuffer { get; set; }
        private static int GraphWidth { get; set; }
        private static int GraphHeight { get; set; }

        private static int RowSize
        {
            get
            {
                return (((GraphWidth) + 31) >> 5) << 2;
            }
        }

        private static int RowRealBytesCount
        {
            get
            {
                if ((GraphWidth % 8) > 0)
                {
                    return GraphWidth / 8 + 1;
                }
                else
                {
                    return GraphWidth / 8;
                }
            }
        }
        #endregion

        #region 静态构造方法
        static ZebraPrintHelper()
        {
            GraphBuffer = new byte[0];
            IsWriteLog = false;
            LogsDirectory = "logs";
        }
        #endregion

        #region 定义发送原始数据到打印机的方法
        private static bool SendBytesToPrinter(string printerName, IntPtr intptrBytes, Int32 count)
        {
            Int32 error = 0, written = 0;
            IntPtr intptrPrinter = new IntPtr(0);
            DocInfo docInfo = new DocInfo();
            bool bSuccess = false;

            docInfo.DocName = ".NET RAW Document";
            docInfo.DataType = "RAW";

            // Open the printer.  
            if (OpenPrinter(printerName.Normalize(), out intptrPrinter, IntPtr.Zero))
            {
                // Start a document.  
                if (StartDocPrinter(intptrPrinter, 1, docInfo))
                {
                    // Start a page.  
                    if (StartPagePrinter(intptrPrinter))
                    {
                        // Write your bytes.  
                        bSuccess = WritePrinter(intptrPrinter, intptrBytes, count, out written);
                        EndPagePrinter(intptrPrinter);
                    }
                    EndDocPrinter(intptrPrinter);
                }
                ClosePrinter(intptrPrinter);
            }
            // If you did not succeed, GetLastError may give more information  
            // about why not.  
            if (bSuccess == false)
            {
                error = Marshal.GetLastWin32Error();
            }
            return bSuccess;
        }

        public static bool SendFileToPrinter(string printerName, string fileName)
        {
            // Open the file.  
            FileStream fs = new FileStream(fileName, FileMode.Open);
            // Create a BinaryReader on the file.  
            BinaryReader br = new BinaryReader(fs);
            // Dim an array of bytes big enough to hold the file's contents.  
            Byte[] bytes = new Byte[fs.Length];
            bool bSuccess = false;
            // Your unmanaged pointer.  
            IntPtr pUnmanagedBytes = new IntPtr(0);
            int nLength;

            nLength = Convert.ToInt32(fs.Length);
            // Read the contents of the file into the array.  
            bytes = br.ReadBytes(nLength);
            // Allocate some unmanaged memory for those bytes.  
            pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
            // Copy the managed byte array into the unmanaged array.  
            Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
            // Send the unmanaged bytes to the printer.  
            bSuccess = SendBytesToPrinter(printerName, pUnmanagedBytes, nLength);
            // Free the unmanaged memory that you allocated earlier.  
            Marshal.FreeCoTaskMem(pUnmanagedBytes);
            return bSuccess;
        }

        public static bool SendBytesToPrinter(string printerName, byte[] bytes)
        {
            bool bSuccess = false;
            IntPtr pUnmanagedBytes = new IntPtr(0);
            int nLength = bytes.Length;
            // Allocate some unmanaged memory for those bytes.  
            pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
            // Copy the managed byte array into the unmanaged array.  
            Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
            // Send the unmanaged bytes to the printer.  
            bSuccess = SendBytesToPrinter(printerName, pUnmanagedBytes, nLength);
            // Free the unmanaged memory that you allocated earlier.  
            Marshal.FreeCoTaskMem(pUnmanagedBytes);
            return bSuccess;
        }

        public static bool SendStringToPrinter(string printerName, string text)
        {
            IntPtr pBytes;
            Int32 dwCount;
            // How many characters are in the string?  
            dwCount = (text.Length + 1) * Marshal.SystemMaxDBCSCharSize;
            // Assume that the printer is expecting ANSI text, and then convert  
            // the string to ANSI text.  
            pBytes = Marshal.StringToCoTaskMemAnsi(text);
            // Send the converted ANSI string to the printer.  
            SendBytesToPrinter(printerName, pBytes, dwCount);
            Marshal.FreeCoTaskMem(pBytes);
            return true;
        }
        #endregion

        #region 日志记录方法
        private static void WriteLog(string text, LogType logType)
        {
            string endTag = string.Format("\r\n{0}\r\n", new string('=', 80));
            string path = string.Format("{0}\\{1}-{2}.log", LogsDirectory, DateTime.Now.ToString("yyyy-MM-dd"), logType);
            if (!Directory.Exists(LogsDirectory))
            {
                Directory.CreateDirectory(LogsDirectory);
            }
            if (logType == LogType.Error)
            {
                File.AppendAllText(path, string.Format("{0}{1}", text, endTag), Encoding.Default);
            }
            if (logType == LogType.Print)
            {
                if (text.StartsWith("N\r\nGW"))
                {
                    using (FileStream fs = new FileStream(path, FileMode.Append))
                    {
                        byte[] bytes = TransferFormat.GetBytes(text);
                        byte[] tag = TransferFormat.GetBytes(endTag);
                        fs.Write(bytes, 0, bytes.Length);
                        fs.Write(tag, 0, tag.Length);
                        fs.Close();
                    }
                }
                else
                {
                    File.AppendAllText(path, string.Format("{0}{1}", text, endTag), Encoding.Default);
                }
            }
        }

        private static void WriteLog(byte[] bytes, LogType logType)
        {
            string endTag = string.Format("\r\n{0}\r\n", new string('=', 80));
            string path = string.Format("{0}\\{1}-{2}.log", LogsDirectory, DateTime.Now.ToString("yyyy-MM-dd"), logType);
            if (!Directory.Exists(LogsDirectory))
            {
                Directory.CreateDirectory(LogsDirectory);
            }
            if (logType == LogType.Error)
            {
                File.AppendAllText(path, string.Format("{0}{1}", Encoding.Default.GetString(bytes), endTag), Encoding.Default);
            }
            if (logType == LogType.Print)
            {
                string transferFormat = TransferFormat.GetString(bytes);
                if (transferFormat.StartsWith("N\r\nGW"))
                {
                    using (FileStream fs = new FileStream(path, FileMode.Append))
                    {
                        byte[] tag = TransferFormat.GetBytes(endTag);
                        fs.Write(bytes, 0, bytes.Length);
                        fs.Write(tag, 0, tag.Length);
                        fs.Close();
                    }
                }
                else
                {
                    File.AppendAllText(path, string.Format("{0}{1}", Encoding.Default.GetString(bytes), endTag), Encoding.Default);
                }
            }
        }
        #endregion

        #region 封装方法,方便调用。
        public static bool PrintWithCOM(string cmd, int port, bool isWriteLog)
        {
            PrinterType = DeviceType.COM;
            Port = port;
            IsWriteLog = isWriteLog;
            return PrintCommand(cmd);
        }

        public static bool PrintWithCOM(byte[] bytes, int port, bool isWriteLog, ProgrammingLanguage progLanguage)
        {
            PrinterType = DeviceType.COM;
            Port = port;
            IsWriteLog = isWriteLog;
            PrinterProgrammingLanguage = progLanguage;
            return PrintGraphics(bytes);
        }

        public static bool PrintWithLPT(string cmd, int port, bool isWriteLog)
        {
            PrinterType = DeviceType.LPT;
            Port = port;
            IsWriteLog = isWriteLog;
            return PrintCommand(cmd);
        }

        public static bool PrintWithLPT(byte[] bytes, int port, bool isWriteLog, ProgrammingLanguage progLanguage)
        {
            PrinterType = DeviceType.LPT;
            Port = port;
            IsWriteLog = isWriteLog;
            PrinterProgrammingLanguage = progLanguage;
            return PrintGraphics(bytes);
        }

        public static bool PrintWithDRV(string cmd, string printerName, bool isWriteLog)
        {
            PrinterType = DeviceType.DRV;
            PrinterName = printerName;
            IsWriteLog = isWriteLog;
            return PrintCommand(cmd);
        }

        public static bool PrintWithDRV(byte[] bytes, string printerName, bool isWriteLog, ProgrammingLanguage progLanguage)
        {
            PrinterType = DeviceType.DRV;
            PrinterName = printerName;
            IsWriteLog = isWriteLog;
            PrinterProgrammingLanguage = progLanguage;
            return PrintGraphics(bytes);
        }
        #endregion

        #region 打印ZPL、EPL指令
        public static bool PrintCommand(string cmd)
        {
            lock (SyncRoot)
            {
                bool result = false;
                try
                {
                    switch (PrinterType)
                    {
                        case DeviceType.COM:
                            result = comPrint(Encoding.Default.GetBytes(cmd));
                            break;
                        case DeviceType.LPT:
                            result = lptPrint(Encoding.Default.GetBytes(cmd));
                            break;
                        case DeviceType.DRV:
                            result = drvPrint(Encoding.Default.GetBytes(cmd));
                            break;
                        case DeviceType.TCP:
                            result = tcpPrint(Encoding.Default.GetBytes(cmd));
                            break;
                    }
                    if (!string.IsNullOrEmpty(cmd) && IsWriteLog)
                    {
                        WriteLog(cmd, LogType.Print);
                    }
                }
                catch (Exception ex)
                {
                    //记录日志  
                    if (IsWriteLog)
                    {
                        WriteLog(string.Format("{0} => {1}\r\n{2}", DateTime.Now, ex.Message, ex), LogType.Error);
                    }
                }
                finally
                {
                    GraphBuffer = new byte[0];
                }
                return result;
            }
        }
        #endregion

        #region 打印图像字节流
        public static bool PrintGraphics(byte[] graph)
        {
            lock (SyncRoot)
            {
                bool result = false;
                try
                {
                    GraphBuffer = graph;
                    byte[] cmdBytes = new byte[0];
                    if (PrinterProgrammingLanguage == ProgrammingLanguage.ZPL)
                    {
                        cmdBytes = getZPLBytes();
                    }
                    if (PrinterProgrammingLanguage == ProgrammingLanguage.EPL)
                    {
                        cmdBytes = getEPLBytes();
                    }
                    if (PrinterProgrammingLanguage == ProgrammingLanguage.CPCL)
                    {
                        cmdBytes = getCPCLBytes();
                    }
                    switch (PrinterType)
                    {
                        case DeviceType.COM:
                            result = comPrint(cmdBytes);
                            break;
                        case DeviceType.LPT:
                            result = lptPrint(cmdBytes);
                            break;
                        case DeviceType.DRV:
                            result = drvPrint(cmdBytes);
                            break;
                        case DeviceType.TCP:
                            result = tcpPrint(cmdBytes);
                            break;
                    }
                    if (cmdBytes.Length > 0 && IsWriteLog)
                    {
                        WriteLog(cmdBytes, LogType.Print);
                    }
                }
                catch (Exception ex)
                {
                    //记录日志  
                    if (IsWriteLog)
                    {
                        WriteLog(string.Format("{0} => {1}\r\n{2}", DateTime.Now, ex.Message, ex), LogType.Error);
                    }
                }
                finally
                {
                    GraphBuffer = new byte[0];
                }
                return result;
            }
        }
        #endregion

        #region COM/LPT/DRV三种模式打印方法
        private static bool drvPrint(byte[] cmdBytes)
        {
            bool result = false;
            try
            {
                if (!string.IsNullOrEmpty(PrinterName))
                {
                    result = SendBytesToPrinter(PrinterName, cmdBytes);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return result;
        }

        private static bool comPrint(byte[] cmdBytes)
        {
            bool result = false;
            SerialPort com = new SerialPort(string.Format("{0}{1}", PrinterType, Port), 9600, Parity.None, 8, StopBits.One);
            try
            {
                com.Open();
                com.Write(cmdBytes, 0, cmdBytes.Length);
                result = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (com.IsOpen)
                {
                    com.Close();
                }
            }
            return result;
        }

        private static bool lptPrint(byte[] cmdBytes)
        {
            bool result = false;
            FileStream fileStream = null;
            StreamWriter streamWriter = null;
            SafeFileHandle handle = null;
            try
            {
                handle = CreateFile(string.Format("{0}{1}", PrinterType, Port), GENERIC_WRITE, 0, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
                if (!handle.IsInvalid)
                {
                    fileStream = new FileStream(handle, FileAccess.ReadWrite);
                    streamWriter = new StreamWriter(fileStream, Encoding.Default);
                    streamWriter.Write(cmdBytes);
                    result = true;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (fileStream != null)
                {
                    fileStream.Close();
                    fileStream = null;
                }
                if (streamWriter != null)
                {
                    streamWriter.Close();
                    streamWriter = null;
                }
                if (handle != null)
                {
                    handle.Close();
                    handle = null;
                }
            }
            return result;
        }

        private static bool tcpPrint(byte[] cmdBytes)
        {
            bool result = false;
            TcpClient tcp = null;
            try
            {
                IPAddress ip = IPAddress.Parse(TcpIpAddress);
                IPEndPoint iport = new IPEndPoint(ip, TcpPort);//9100为小票打印机指定端口
                tcp = new TcpClient(iport);
                tcp.SendTimeout = 1000;
                tcp.ReceiveTimeout = 1000;
                if (tcp.Connected)
                {
                    tcp.Client.Send(cmdBytes);
                    result = true;
                }
            }
            catch (Exception ex)
            {
                throw new Exception("打印失败,请检查打印机或网络设置。", ex);
            }
            finally
            {
                if (tcp != null)
                {
                    if (tcp.Client != null)
                    {
                        tcp.Client.Close();
                        tcp.Client = null;
                    }
                    tcp.Close();
                    tcp = null;
                }
            }
            return result;
        }
        #endregion

        #region 生成ZPL图像打印指令
        private static byte[] getZPLBytes()
        {
            byte[] result = new byte[0];
            byte[] bmpData = getBitmapData();
            string textBitmap = string.Empty;
            string textHex = BitConverter.ToString(bmpData).Replace("-", string.Empty);
            for (int i = 0; i < GraphHeight; i++)
            {
                textBitmap += textHex.Substring(i * RowRealBytesCount * 2, RowRealBytesCount * 2) + "\r\n";
            }
            string text = string.Format("~DGR:IMAGE.GRF,{0},{1},\r\n{2}^XGR:IMAGE.GRF,1,1^FS\r\n^IDR:IMAGE.GRF\r\n",
                GraphHeight * RowRealBytesCount,
                RowRealBytesCount,
                textBitmap);
            result = Encoding.Default.GetBytes(text);
            return result;
        }
        #endregion

        #region 生成EPL图像打印指令
        private static byte[] getEPLBytes()
        {
            byte[] result = new byte[0];
            byte[] buffer = getBitmapData();
            string text = string.Format("N\r\nGW{0},{1},{2},{3},{4}\r\nP\r\n",
                0,
                0,
                RowRealBytesCount,
                GraphHeight,
                TransferFormat.GetString(buffer));
            result = TransferFormat.GetBytes(text);
            return result;
        }
        #endregion

        #region 生成CPCL图像打印指令
        public static byte[] getCPCLBytes()
        {
            byte[] bmpData = getBitmapData();
            int bmpDataLength = bmpData.Length;
            for (int i = 0; i < bmpDataLength; i++)
            {
                bmpData[i] ^= 0xFF;
            }
            string textHex = BitConverter.ToString(bmpData).Replace("-", string.Empty);
            string text = string.Format("! {0} {1} {2} {3} {4}\r\nEG {5} {6} {7} {8} {9}\r\nFORM\r\nPRINT\r\n",
                0, //水平偏移量  
                TcpPrinterDPI, //横向DPI  
                TcpPrinterDPI, //纵向DPI  
                (int)(TcpLabelMaxHeightCM / 2.54f * TcpPrinterDPI), //标签最大像素高度=DPI*标签纸高度(英寸)  
                Copies, //份数  
                RowRealBytesCount, //图像的字节宽度  
                GraphHeight, //图像的像素高度  
                0, //横向的开始位置  
                0, //纵向的开始位置  
                textHex
                );
            return Encoding.UTF8.GetBytes(text);
        }
        #endregion

        #region 获取单色位图数据
        /// <summary>  
        /// 获取单色位图数据(1bpp),不含文件头、信息头、调色板三类数据。  
        /// </summary>  
        /// <returns></returns>  
        private static byte[] getBitmapData()
        {
            MemoryStream srcStream = new MemoryStream();
            MemoryStream dstStream = new MemoryStream();
            Bitmap srcBmp = null;
            Bitmap dstBmp = null;
            byte[] srcBuffer = null;
            byte[] dstBuffer = null;
            byte[] result = null;
            try
            {
                srcStream = new MemoryStream(GraphBuffer);
                srcBmp = Bitmap.FromStream(srcStream) as Bitmap;
                srcBuffer = srcStream.ToArray();
                GraphWidth = srcBmp.Width;
                GraphHeight = srcBmp.Height;
                dstBmp = srcBmp.Clone(new Rectangle(0, 0, srcBmp.Width, srcBmp.Height), PixelFormat.Format1bppIndexed);
                dstBmp.Save(dstStream, ImageFormat.Bmp);
                dstBuffer = dstStream.ToArray();

                int bfSize = BitConverter.ToInt32(dstBuffer, 2);
                int bfOffBits = BitConverter.ToInt32(dstBuffer, 10);
                int bitmapDataLength = bfSize - bfOffBits;
                result = new byte[GraphHeight * RowRealBytesCount];

                //读取时需要反向读取每行字节实现上下翻转的效果,打印机打印顺序需要这样读取。  
                for (int i = 0; i < GraphHeight; i++)
                {
                    Array.Copy(dstBuffer, bfOffBits + (GraphHeight - 1 - i) * RowSize, result, i * RowRealBytesCount, RowRealBytesCount);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (srcStream != null)
                {
                    srcStream.Dispose();
                    srcStream = null;
                }
                if (dstStream != null)
                {
                    dstStream.Dispose();
                    dstStream = null;
                }
                if (srcBmp != null)
                {
                    srcBmp.Dispose();
                    srcBmp = null;
                }
                if (dstBmp != null)
                {
                    dstBmp.Dispose();
                    dstBmp = null;
                }
            }
            return result;
        }
        #endregion

        #region 扩展

        #region CPCL命令打印24位bmp
        private static string get24BitBmpData(string filePath)
        {
            Bitmap bmp = new Bitmap(filePath);
            byte[] bitArray = { 128, 64, 32, 16, 8, 4, 2, 1 };
            string imgTxt = "";
            Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
            BitmapData data = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
            IntPtr firstPix = data.Scan0;

            int rowByteCount = bmp.Width * 3;
            int filledCount = data.Stride - rowByteCount;
            int bytes = data.Stride * data.Height;//Math.Ceiling((double)bmp.Width / 8)
            byte[] rgbValues = new byte[bytes];
            System.Runtime.InteropServices.Marshal.Copy(firstPix, rgbValues, 0, bytes);

            int printRowByteCount = Convert.ToInt32(Math.Ceiling((double)(bmp.Width) / 8));
            int printRowByteFillCount = 4 - (printRowByteCount % 4);
            //int bitFillCount = 8 - (bmp.Width % 8);
            byte[] printData = new byte[(printRowByteCount + printRowByteFillCount) * bmp.Height];

            int byteCount = 0;
            int bitCount = 0;
            int rowPoint = 0;
            for (int i = 0; i < rgbValues.Length; i += 3)
            {
                int rgbValue = rgbValues[i] + rgbValues[i + 1] + rgbValues[i + 2];
                if (rgbValue != (255 * 3))
                {
                    printData[byteCount] = Convert.ToByte(printData[byteCount] | bitArray[bitCount]);
                }
                if (bitCount == 7)
                {
                    bitCount = 0;
                    byteCount++;
                }
                else
                {
                    bitCount++;
                }
                if ((rowPoint + 3) == rowByteCount)
                {
                    rowPoint = 0;
                    if (bitCount > 0)
                    {
                        byteCount++;
                    }
                    bitCount = 0;
                    byteCount += printRowByteFillCount;
                    i = i + filledCount;
                }
                else
                {
                    rowPoint += 3;
                }
            }

            foreach (byte byteData in printData)
            {
                string hexStr = Convert.ToString(byteData, 16);
                if (hexStr.Length == 1)
                {
                    hexStr = '0' + hexStr;
                }
                imgTxt += hexStr;
            }
            bmp.UnlockBits(data);
            return imgTxt.ToUpper();
        }

        public static void Printer(string bitbmpPath)
        {
            string CRNL = "\r\n";
            string imgTxt = get24BitBmpData(bitbmpPath);
            string cmddata = "! 0 200 200 300 1" + CRNL +
                            "EG " + 24 + " " + 50 + " 10 10 " + imgTxt + CRNL +
                            "FORM" + CRNL +
                            "PRINT" + CRNL;
            try
            {
                string ipAddress = "192.168.1.212";
                int port = 9100;

                // Open connection
                System.Net.Sockets.TcpClient client = new System.Net.Sockets.TcpClient();
                client.Connect(ipAddress, port);

                // Write CPCL String to connection
                System.IO.StreamWriter writer = new System.IO.StreamWriter(client.GetStream());
                writer.Write(cmddata);
                writer.Flush();

                // Close Connection
                writer.Close();
                client.Close();
            }
            catch (Exception)
            {
                // Catch Exception
            }
        }
        #endregion
        #region ZPL
        /// <summary>
        /// ZPL指令开始
        /// </summary>
        /// <returns></returns>
        public static string ZPL_Start()
        {
            StringBuilder builder = new StringBuilder();
            builder.AppendLine("^XA");          //指令块的开始
            builder.AppendLine("^MD30");       //MD是设置色带颜色的深度(-30~30)
            return builder.ToString();
        }
        /// <summary>
        /// ZPL指令结束
        /// </summary>
        /// <returns></returns>
        public static string ZPL_End()
        {
            StringBuilder builder = new StringBuilder();
            builder.AppendLine("^XZ");         //指令块的结束
            return builder.ToString();
        }
        /// <summary>
        /// 设置打印标签纸边距
        /// </summary>
        /// <param name="printX">标签纸边距x坐标</param>
        /// <param name="printY">标签纸边距y坐标</param>
        /// <returns></returns>
        public static string ZPL_PageSet(int printX, int printY)
        {
            StringBuilder builder = new StringBuilder();
            builder.AppendLine("^LH" + printX + "," + printY);  //定义条码纸边距(单位像素)80 10
            return builder.ToString();
        }
        /// <summary>
        /// 打印凭条设置
        /// </summary>
        /// <param name="width">凭条宽度</param>
        /// <param name="height">凭条高度</param>
        /// <returns>返回ZPL命令</returns>
        public static string ZPL_SetLabel(int width, int height)
        {
            //ZPL条码设置命令:^PW640^LL480
            string sReturn = "^PW{0}^LL{1}";
            return string.Format(sReturn, width, height);
        }
        /// <summary>
        /// 打印矩形
        /// </summary>
        /// <param name="px">起点X坐标</param>
        /// <param name="py">起点Y坐标</param>
        /// <param name="thickness">边框宽度</param>
        /// <param name="width">矩形宽度,0表示打印一条竖线</param>
        /// <param name="height">矩形高度,0表示打印一条横线</param>
        /// <returns>返回ZPL命令</returns>
        public static string ZPL_DrawRectangle(int px, int py, int thickness, int width, int height)
        {
            //ZPL矩形命令:^FO50,50^GB300,200,2^FS
            string sReturn = "^FO{0},{1}^GB{3},{4},{2}^FS";
            return string.Format(sReturn, px, py, thickness, width, height);
        }
        /// <summary>
        /// 打印英文
        /// </summary>
        /// <param name="EnText">待打印文本</param>
        /// <param name="ZebraFont">打印机字体 A-Z</param>
        /// <param name="px">起点X坐标</param>
        /// <param name="py">起点Y坐标</param>
        /// <param name="Orient">旋转角度N = normal,R = rotated 90 degrees (clockwise),I = inverted 180 degrees,B = read from bottom up, 270 degrees</param>
        /// <param name="Height">字体高度</param>
        /// <param name="Width">字体宽度</param>
        /// <returns>返回ZPL命令</returns>
        public static string ZPL_DrawENText(string EnText, string ZebraFont, int px, int py, string Orient, int Height, int Width)
        {
            //ZPL打印英文命令:^FO50,50^A0N,32,25^FDZEBRA^FS
            string sReturn = "^FO{1},{2}^A" + ZebraFont + "{3},{4},{5}^FD{0}^FS";
            return string.Format(sReturn, EnText, px, py, Orient, Height, Width);
        }
        /// <summary>
        /// 中文处理,返回ZPL命令
        /// </summary>
        /// <param name="ChineseText">待转变中文内容</param>
        /// <param name="FontName">字体名称</param>
        /// <param name="startX">X坐标</param>
        /// <param name="startY">Y坐标</param>
        /// <param name="Orient">旋转角度0,90,180,270</param>
        /// <param name="Height">字体高度</param>
        /// <param name="Width">字体宽度,通常是0</param>
        /// <param name="IsBold">1 变粗,0 正常</param>
        /// <param name="IsItalic">1 斜体,0 正常</param>
        /// <returns></returns>
        public static string ZPL_DrawCHText(string ChineseText, string FontName, int startX, int startY, int Orient, int Height, int Width, int IsBold, int IsItalic)
        {
            StringBuilder sResult = new StringBuilder();
            StringBuilder hexbuf = new StringBuilder(21 * 1024);
            int count = ZebraPrintHelper.GETFONTHEX(ChineseText, FontName, Orient, Height, Width, IsBold, IsItalic, hexbuf);
            if (count > 0)
            {
                string sEnd = "^FO" + startX.ToString() + "," + startY.ToString() + "^XGOUTSTR" + ",1,2^FS ";
                sResult.AppendLine(hexbuf.ToString().Replace("OUTSTR01", "OUTSTR") + sEnd);
            }
            return sResult.ToString();
        }
        /// <summary>
        /// 打印条形码(128码)
        /// </summary>
        /// <param name="px">起点X坐标</param>
        /// <param name="py">起点Y坐标</param>
        /// <param name="width">基本单元宽度 1-10</param>
        /// <param name="ratio">宽窄比 2.0-3.0 增量0.1</param>
        /// <param name="barheight">条码高度</param>
        /// <param name="barcode">条码内容</param>
        /// <returns>返回ZPL命令</returns>
        public static string ZPL_DrawBarcode(int px, int py, int width, int ratio, int barheight, string barcode)
        {
            //ZPL打印英文命令:^FO50,260^BY1,2^BCN,100,Y,N^FDSMJH2000544610^FS
            string sReturn = "^FO{0},{1}^BY{2},{3}^BCN,{4},N,N^FD{5}^FS";
            return string.Format(sReturn, px, py, width, ratio, barheight, barcode);
        }
        /// <summary>
        /// 中文处理
        /// </summary>
        /// <param name="ChineseText">待转变中文内容</param>
        /// <param name="FontName">字体名称</param>
        /// <param name="Orient">旋转角度0,90,180,270</param>
        /// <param name="Height">字体高度</param>
        /// <param name="Width">字体宽度,通常是0</param>
        /// <param name="IsBold">1 变粗,0 正常</param>
        /// <param name="IsItalic">1 斜体,0 正常</param>
        /// <param name="ReturnPicData">返回的图片字符</param>
        /// <returns></returns>
        [DllImport("fnthex32.dll")]
        public static extern int GETFONTHEX(
          string ChineseText,
          string FontName,
          int Orient,
          int Height,
          int Width,
          int IsBold,
          int IsItalic,
          StringBuilder ReturnPicData);
        /// <summary>
        /// 中文处理
        /// </summary>
        /// <param name="ChineseText">待转变中文内容</param>
        /// <param name="FontName">字体名称</param>
        /// <param name="FileName">返回的图片字符重命</param>
        /// <param name="Orient">旋转角度0,90,180,270</param>
        /// <param name="Height">字体高度</param>
        /// <param name="Width">字体宽度,通常是0</param>
        /// <param name="IsBold">1 变粗,0 正常</param>
        /// <param name="IsItalic">1 斜体,0 正常</param>
        /// <param name="ReturnPicData">返回的图片字符</param>
        /// <returns></returns>
        [DllImport("fnthex32.dll")]
        public static extern int GETFONTHEX(
                   string ChineseText,
                   string FontName,
                   string FileName,
                   int Orient,
                   int Height,
                   int Width,
                   int IsBold,
                   int IsItalic,
                   StringBuilder ReturnPicData);
        /// <summary>
        /// 毫米转像素 取整
        /// </summary>
        /// <param name="mm">毫米</param>
        /// <param name="dpi">打印DPI 如300</param>
        /// <returns></returns>
        public static double mm2px(double mm, double dpi)
        {
            double px = (mm / 25.4) * dpi;
            return Math.Round(px, 0, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 像素转毫米 取整
        /// </summary>
        /// <param name="px">像素</param>
        /// <param name="dpi">打印DPI 如300</param>
        /// <returns></returns>
        public static double px2mm(double px, double dpi)
        {
            //像素转换成毫米公式:(宽度像素/水平DPI)*25.4;
            double mm = (px / dpi) * 25.4;
            return Math.Round(mm, 0, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 生成zpl命令 且执行
        /// </summary>
        /// <param name="path">zpl文件路径</param>
        /// <param name="zpl">zpl命令</param>
        public static void CmdDos(string path, string zpl)
        {
            FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write);
            StreamWriter sw = new StreamWriter(fs, Encoding.Default);//ANSI编码格式
            if (File.Exists(path))
            {
                sw.Write(zpl);
                sw.Flush();
                sw.Close();
            }
            fs.Close();
            RunCmd("print /d:COM1 " + path + " ");
        }
        /// <summary>
        /// 运行Dos命令
        /// </summary>
        /// <param name="command"></param>
        /// <returns></returns>
        private static bool RunCmd(string command)
        {
            //实例一个Process类,启动一个独立进程
            Process p = new Process();
            //Process类有一个StartInfo属性,這個是ProcessStartInfo类,包括了一些属性和方法,下面我們用到了他的几个属性:
            p.StartInfo.FileName = "cmd.exe";//设定程序名
            p.StartInfo.Arguments = "/c " + command;//设定程式执行参数
            p.StartInfo.UseShellExecute = false;//关闭Shell的使用
            p.StartInfo.RedirectStandardInput = true;//重定向标准输入
            p.StartInfo.RedirectStandardOutput = true;//重定向标准输出
            p.StartInfo.RedirectStandardError = true;//重定向错误输出
            p.StartInfo.CreateNoWindow = true;//设置不显示窗口
            //p.StandardInput.WriteLine(command);//也可以用这种方式输入要执行的命令
            //p.StandardInput.WriteLine("exit");//不过要记得加上Exit要不然下一行程式执行的時候会当机
            try
            {
                p.Start();//开始进程
                return true;
            }
            catch
            {
            }
            finally
            {
                if (p != null)
                    p.Close();
            }
            return false;
        }
        #endregion
        #endregion
    }


    #region 定义设备类型枚举
    public enum DeviceType
    {
        COM = 0,
        LPT = 1,
        DRV = 2,
        TCP = 3
    }
    #endregion

    #region 定义打印机指令类型枚举
    public enum ProgrammingLanguage
    {
        ZPL = 0,
        EPL = 1,
        CPCL = 2
    }
    #endregion

    #region 定义日志类型枚举
    public enum LogType
    {
        Print = 0,
        Error = 1
    }
    #endregion





    #region 定义打印文档信息类
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    public class DocInfo
    {
        [MarshalAs(UnmanagedType.LPStr)]
        public string DocName;
        [MarshalAs(UnmanagedType.LPStr)]
        public string OutputFile;
        [MarshalAs(UnmanagedType.LPStr)]
        public string DataType;
    }
    #endregion

    #region 定义图像设备信息类
    public class DeviceInfo
    {
        #region 属性说明

public Form1()
{
InitializeComponent();
InitPrinter(comboBox1);
Init();
textBox1.Focus();
}
Connection SATOPrinter = new Connection();
PrinterDriver SATODriver = new PrinterDriver();
Dictionary<string, int> Name2Idx = new Dictionary<string, int>();
string[] ASCIIMAP = { "[NUL]", "[SOH]", "[STX]", "[ETX]", "[EOT]", "[ENQ]", "[ACK]", "[BEL]", "[BS]" };
List<string> list = new List<string>();
#region INI deal with
[DllImport("kernel32")]//返回0表示失败,非0为成功
private static extern long WritePrivateProfileString(string section,
string key,
string val,
string filePath);
[DllImport("kernel32")]//返回取得字符串缓冲区的长度
private static extern long GetPrivateProfileString(string section,
string key,
string def,
StringBuilder retVal,
int size,
string filePath);
//写入INI
private bool WriteIni(string Section, string Key, string Value, string iniFilePath)
{
long o = WritePrivateProfileString(Section, Key, Value, iniFilePath);
if (o == 0)
{
return false;
}
else
{
return true;
}
}
//读取INI
private string ReadIni(string Section, string Key, string NoText, string iniFilePath)
{
if (File.Exists(iniFilePath))
{
StringBuilder sb = new StringBuilder(1024);
GetPrivateProfileString(Section, Key, NoText, sb, 1024, iniFilePath);
return sb.ToString();
}
else
{
return String.Empty;
}
}
//读配置文件
string file = System.Windows.Forms.Application.StartupPath + @"\printset.ini";
private void getINI(string printer, string printtype, string length, out string barx, out string bary, out string txtx, out string txty, out string barheight, out string null1, out string null2)
{
if (!File.Exists(file))
{
WriteIni("Procode", "8", "0050,0005,0050,0085,075, , ,", file);
WriteIni("Procode", "9", "0080,0005,0080,0085,075, , ,", file);

WriteIni("Package", "T8", "50,10,50,90,75", file);
WriteIni("Package", "T9", "50,10,50,90,75", file);

WriteIni("Package", "S8", "50,10,50,90,75", file);
WriteIni("Package", "S9", "50,10,50,90,75", file);

WriteIni("Other", "8", "0050,0005,0050,0085,075", file);
WriteIni("Other", "9", "0050,0005,0050,0085,075", file);
}
barx = "";
bary = "";
txtx = "";
txty = "";
barheight = "";
null1 = "";
null2 = "";
if (printtype.Equals("Procode"))
{
string data = ReadIni("Procode", length, "", file);
barx = data.Split(',')[0];
bary = data.Split(',')[1];
txtx = data.Split(',')[2];
txty = data.Split(',')[3];
barheight = data.Split(',')[4];
null1 = data.Split(',')[5];
null2 = data.Split(',')[6];
}
else if (printtype.Equals("Package"))
{
if (printer.StartsWith("S"))
{
string data = ReadIni("Package", "S" + length, "", file);
barx = data.Split(',')[0];
bary = data.Split(',')[1];
txtx = data.Split(',')[2];
txty = data.Split(',')[3];
barheight = data.Split(',')[4];
}
else
{
string data = ReadIni("Package", "T" + length, "", file);
barx = data.Split(',')[0];
bary = data.Split(',')[1];
txtx = data.Split(',')[2];
txty = data.Split(',')[3];
barheight = data.Split(',')[4];
}
}
else
{
string data = ReadIni("Attach", length, "", file);
barx = data.Split(',')[0];
bary = data.Split(',')[1];
txtx = data.Split(',')[2];
txty = data.Split(',')[3];
barheight = data.Split(',')[4];
}
}
#endregion
#region Initialize Name2Idx
private void Init()
{
int idx = 0;
foreach (string s in ASCIIMAP)
{
Name2Idx.Add(s, idx);
}
Name2Idx.Add("[ESC]", 0x1b);
Name2Idx.Add("[NAK]", 0x15);
Name2Idx.Add("[DC2]", 0x12);
}
private byte[] S2BA(string s)
{
s = DecodeStr(s);
return SATOPrinter.String2ByteArray(s);
}
private string DecodeStr(string s)
{
string ret;
ret = s.Replace("[{NUL}]", "" + (char)0);
ret = ret.Replace("[{HT}]", "" + (char)0x09);
ret = ret.Replace("[{0x85}]", "" + (char)0x85);
ret = ret.Replace("[{0xA0}]", "" + (char)0xA0);
return ret;
}
#endregion
#region Initialize Printer
private void InitPrinter(ComboBox combo)
{
PrinterSettings.StringCollection stringCollection = PrinterSettings.InstalledPrinters;//获取已安装的打印机
string printerName = string.Empty;
Regex regex = new Regex("^.*ZPL.*$");
string value = "";
foreach(string printer in stringCollection)
{
printerName = printer.ToString();
combo.Items.Add(printerName);
if (regex.IsMatch(printerName))
{
value = printerName;
}
}
combo.Text = value;
}
#endregion
#region Bartender
private void PrinterBar()
{
ApplicationClass ac;
Format format;
ac = new ApplicationClass();
format = ac.Formats.Open("D:\\Template\\1.btw", true, "");
format.Printer = comboBox1.Text;
format.PrintOut(false, false);
}
#endregion
#region test
DataTable dt;
private void InitTable(string procode)
{
dt = new DataTable();
DataColumn[] dc = new DataColumn[3];
dc[0] = new DataColumn("procode", typeof(string));
dc[1] = new DataColumn("mlot", typeof(string));
dc[2] = new DataColumn("serials", typeof(string));
dt.Columns.AddRange(dc);

DataRow row = dt.NewRow();
row["procode"] = procode;
row["mlot"] = "210928";
row["serials"] = "0001";
dt.Rows.Add(row);

DataRow row2 = dt.NewRow();
row2["procode"] = procode;
row2["mlot"] = "210928";
row2["serials"] = "0002";
dt.Rows.Add(row2);

DataRow row3 = dt.NewRow();
row3["procode"] = procode;
row3["mlot"] = "210928";
row3["serials"] = "0003";
dt.Rows.Add(row3);
}
#endregion
private void button1_Click(object sender, EventArgs e)
{
if (textBox1.Text.Length < 8)
{
PrinterBar();
return;
}
string barx = "";
string bary = "";
string txtx = "";
string txty = "";
string barheight = "";
string null1 = "";
string null2 = "";
getINI(comboBox1.Text, "Package", textBox1.Text.Length.ToString(), out barx, out bary, out txtx, out txty, out barheight, out null1, out null2);
InitTable(textBox1.Text);
foreach (DataRow row in dt.Rows)
{
string s = row["procode"].ToString() + row["mlot"].ToString() + row["serials"].ToString();
list.Add(s);
}
int numbers = 1; //打印份数
if (comboBox1.Text.StartsWith("T"))
{
TSCSerials_DLL.openport(comboBox1.Text);
//获取打印条码值
foreach (string s in list)
{
for (int i = 0; i < numbers; i++)
{
string command = "SPEED 5" + "\r\n" + "SIZE 80 mm, 20 mm" + "\r\n" + "GAP 2 mm,0" + "\r\n" + "CLS" + "\r\n" + "BARCODE " + barx + "," + bary + ",\"128\"," + barheight + ",0,0,2,2,\"" + s + "\"" + "\r\n" + "TEXT " + txtx + "," + txty + ",\"3\",0,1,2,\"" + s + "\"" + "\r\n" + "PRINT 1" + "\r\n";
TSCSerials_DLL.sendcommand(command);
}
}
TSCSerials_DLL.closeport();
}
else if (comboBox1.Text.StartsWith("Z"))
{
ZebraPrintHelper.PrinterProgrammingLanguage = ProgrammingLanguage.EPL;
ZebraPrintHelper.PrinterName = comboBox1.Text;
ZebraPrintHelper.PrinterType = DeviceType.DRV;
foreach (string s in list)
{
string zebra_cmd = "";
zebra_cmd = @"^XA^FO" + barx + "," + bary + "^BY2,3," + barheight + "^BCN,,N,N,N^FD" + s + "^FS^FO" + txtx + "," + txty + "^ABN,20,N^FD" + s + "^FS^XZ";
ZebraPrintHelper.PrintCommand(zebra_cmd);
}
}
else
{
foreach (string s in list)
{
for (int i = 0; i < numbers; i++)
{
string esc = "" + (char)Name2Idx["[ESC]"];
string barcode = "";
string txt = "";
barcode = esc + "A" + "\r\n" + esc + "H" + barx + esc + "V" + bary + esc + "BG02" + barheight + s + "\r\n";
txt = esc + "H" + txtx + esc + "V" + txty + esc + "L0102" + esc + "XM" + s + "\r\n" + esc + "Q1" + "\r\n" + esc + "Z";
byte[] cmd = S2BA(barcode + txt);
SATODriver.SendBytesViaDriver(comboBox1.Text, cmd);
}
}

}

 

}

private void textBox1_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Enter)
{
comboBox1.Focus();
}
}

private void comboBox1_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Enter)
{
button1.Focus();
}
}

}
/// <summary>
/// TSC打印机
/// </summary>
public class TSCSerials_DLL
{
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "about")]
public static extern int about();
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "openport")]
public static extern int openport(string printername);
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "barcode")]
public static extern int barcode(string x, string y, string type, string height, string readable, string rotation, string narrow, string wide, string code);
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "clearbuffer")]
public static extern int clearbuffer();
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "closeport")]
public static extern int closeport();
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "downloadpcx")]
public static extern int downloadpcx(string filename, string image_name);
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "formfeed")]
public static extern int formfeed();
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "nobackfeed")]
public static extern int nobackfeed();
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "printerfont")]
public static extern int printerfont(string x, string y, string fonttype, string rotation, string xmul, string ymul, string text);
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "printlabel")]
public static extern int printlabel(string set, string copy);
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "sendcommand")]
public static extern int sendcommand(string printercommand);
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "setup")]
public static extern int setup(string width, string height, string speed, string density, string sensor, string vertical, string offset);
[DllImport("Dlls\\TSCIB.dll", EntryPoint = "windowsfont")]
public static extern int windowsfont(int x, int y, int fontheight, int rotation, int fontstyle, int fontunderline, string szFaceName, string content);
}
/// <summary>
/// 斑马打印助手,支持LPT/COM/USB/TCP四种模式,适用于标签、票据、条码打印。
/// </summary>
public static class ZebraPrintHelper
{
#region 定义API方法

#region 写打印口(LPT)方法
private const short FILE_ATTRIBUTE_NORMAL = 0x80;
private const short INVALID_HANDLE_VALUE = -1;
private const uint GENERIC_READ = 0x80000000;
private const uint GENERIC_WRITE = 0x40000000;
private const uint CREATE_NEW = 1;
private const uint CREATE_ALWAYS = 2;
private const uint OPEN_EXISTING = 3;
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
private static extern SafeFileHandle CreateFile(string strFileName,
uint dwDesiredAccess,
uint dwShareMode,
IntPtr intptrSecurityAttributes,
uint dwCreationDisposition,
uint dwFlagsAndAttributes,
IntPtr intptrTemplateFile);
#endregion

[DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Auto, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string printerName, out IntPtr intptrPrinter, IntPtr intptrPrintDocument);

[DllImport("winspool.Drv", EntryPoint = "ClosePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool ClosePrinter(IntPtr intptrPrinter);

[DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Auto, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool StartDocPrinter(IntPtr intptrPrinter, Int32 level, [In, MarshalAs(UnmanagedType.LPStruct)] DocInfo docInfo);

[DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool EndDocPrinter(IntPtr intptrPrinter);

[DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool StartPagePrinter(IntPtr intptrPrinter);

[DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool EndPagePrinter(IntPtr intptrPrinter);

[DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
public static extern bool WritePrinter(IntPtr intptrPrinter, IntPtr intptrBytes, Int32 count, out Int32 written);
#endregion

#region 定义私有字段

/// <summary>
/// 线程锁,防止多线程调用。
/// </summary>
private static object SyncRoot = new object();

/// <summary>
/// 字节流传递时采用的字符编码
/// </summary>
private static readonly Encoding TransferFormat = Encoding.GetEncoding("iso-8859-1");

#endregion

#region 定义属性
public static int Port { get; set; }
public static string PrinterName { get; set; }
public static bool IsWriteLog { get; set; }
public static DeviceType PrinterType { get; set; }
public static ProgrammingLanguage PrinterProgrammingLanguage { get; set; }

public static float TcpLabelMaxHeightCM { get; set; }
public static int TcpPrinterDPI { get; set; }
public static string TcpIpAddress { get; set; }
public static int TcpPort { get; set; }
public static int Copies { get; set; }

/// <summary>
/// 日志保存目录,WEB应用注意不能放在BIN目录下。
/// </summary>
public static string LogsDirectory { get; set; }

private static byte[] GraphBuffer { get; set; }
private static int GraphWidth { get; set; }
private static int GraphHeight { get; set; }

private static int RowSize
{
get
{
return (((GraphWidth) + 31) >> 5) << 2;
}
}

private static int RowRealBytesCount
{
get
{
if ((GraphWidth % 8) > 0)
{
return GraphWidth / 8 + 1;
}
else
{
return GraphWidth / 8;
}
}
}
#endregion

#region 静态构造方法
static ZebraPrintHelper()
{
GraphBuffer = new byte[0];
IsWriteLog = false;
LogsDirectory = "logs";
}
#endregion

#region 定义发送原始数据到打印机的方法
private static bool SendBytesToPrinter(string printerName, IntPtr intptrBytes, Int32 count)
{
Int32 error = 0, written = 0;
IntPtr intptrPrinter = new IntPtr(0);
DocInfo docInfo = new DocInfo();
bool bSuccess = false;

docInfo.DocName = ".NET RAW Document";
docInfo.DataType = "RAW";

// Open the printer.
if (OpenPrinter(printerName.Normalize(), out intptrPrinter, IntPtr.Zero))
{
// Start a document.
if (StartDocPrinter(intptrPrinter, 1, docInfo))
{
// Start a page.
if (StartPagePrinter(intptrPrinter))
{
// Write your bytes.
bSuccess = WritePrinter(intptrPrinter, intptrBytes, count, out written);
EndPagePrinter(intptrPrinter);
}
EndDocPrinter(intptrPrinter);
}
ClosePrinter(intptrPrinter);
}
// If you did not succeed, GetLastError may give more information
// about why not.
if (bSuccess == false)
{
error = Marshal.GetLastWin32Error();
}
return bSuccess;
}

public static bool SendFileToPrinter(string printerName, string fileName)
{
// Open the file.
FileStream fs = new FileStream(fileName, FileMode.Open);
// Create a BinaryReader on the file.
BinaryReader br = new BinaryReader(fs);
// Dim an array of bytes big enough to hold the file's contents.
Byte[] bytes = new Byte[fs.Length];
bool bSuccess = false;
// Your unmanaged pointer.
IntPtr pUnmanagedBytes = new IntPtr(0);
int nLength;

nLength = Convert.ToInt32(fs.Length);
// Read the contents of the file into the array.
bytes = br.ReadBytes(nLength);
// Allocate some unmanaged memory for those bytes.
pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
// Copy the managed byte array into the unmanaged array.
Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
// Send the unmanaged bytes to the printer.
bSuccess = SendBytesToPrinter(printerName, pUnmanagedBytes, nLength);
// Free the unmanaged memory that you allocated earlier.
Marshal.FreeCoTaskMem(pUnmanagedBytes);
return bSuccess;
}

public static bool SendBytesToPrinter(string printerName, byte[] bytes)
{
bool bSuccess = false;
IntPtr pUnmanagedBytes = new IntPtr(0);
int nLength = bytes.Length;
// Allocate some unmanaged memory for those bytes.
pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
// Copy the managed byte array into the unmanaged array.
Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
// Send the unmanaged bytes to the printer.
bSuccess = SendBytesToPrinter(printerName, pUnmanagedBytes, nLength);
// Free the unmanaged memory that you allocated earlier.
Marshal.FreeCoTaskMem(pUnmanagedBytes);
return bSuccess;
}

public static bool SendStringToPrinter(string printerName, string text)
{
IntPtr pBytes;
Int32 dwCount;
// How many characters are in the string?
dwCount = (text.Length + 1) * Marshal.SystemMaxDBCSCharSize;
// Assume that the printer is expecting ANSI text, and then convert
// the string to ANSI text.
pBytes = Marshal.StringToCoTaskMemAnsi(text);
// Send the converted ANSI string to the printer.
SendBytesToPrinter(printerName, pBytes, dwCount);
Marshal.FreeCoTaskMem(pBytes);
return true;
}
#endregion

#region 日志记录方法
private static void WriteLog(string text, LogType logType)
{
string endTag = string.Format("\r\n{0}\r\n", new string('=', 80));
string path = string.Format("{0}\\{1}-{2}.log", LogsDirectory, DateTime.Now.ToString("yyyy-MM-dd"), logType);
if (!Directory.Exists(LogsDirectory))
{
Directory.CreateDirectory(LogsDirectory);
}
if (logType == LogType.Error)
{
File.AppendAllText(path, string.Format("{0}{1}", text, endTag), Encoding.Default);
}
if (logType == LogType.Print)
{
if (text.StartsWith("N\r\nGW"))
{
using (FileStream fs = new FileStream(path, FileMode.Append))
{
byte[] bytes = TransferFormat.GetBytes(text);
byte[] tag = TransferFormat.GetBytes(endTag);
fs.Write(bytes, 0, bytes.Length);
fs.Write(tag, 0, tag.Length);
fs.Close();
}
}
else
{
File.AppendAllText(path, string.Format("{0}{1}", text, endTag), Encoding.Default);
}
}
}

private static void WriteLog(byte[] bytes, LogType logType)
{
string endTag = string.Format("\r\n{0}\r\n", new string('=', 80));
string path = string.Format("{0}\\{1}-{2}.log", LogsDirectory, DateTime.Now.ToString("yyyy-MM-dd"), logType);
if (!Directory.Exists(LogsDirectory))
{
Directory.CreateDirectory(LogsDirectory);
}
if (logType == LogType.Error)
{
File.AppendAllText(path, string.Format("{0}{1}", Encoding.Default.GetString(bytes), endTag), Encoding.Default);
}
if (logType == LogType.Print)
{
string transferFormat = TransferFormat.GetString(bytes);
if (transferFormat.StartsWith("N\r\nGW"))
{
using (FileStream fs = new FileStream(path, FileMode.Append))
{
byte[] tag = TransferFormat.GetBytes(endTag);
fs.Write(bytes, 0, bytes.Length);
fs.Write(tag, 0, tag.Length);
fs.Close();
}
}
else
{
File.AppendAllText(path, string.Format("{0}{1}", Encoding.Default.GetString(bytes), endTag), Encoding.Default);
}
}
}
#endregion

#region 封装方法,方便调用。
public static bool PrintWithCOM(string cmd, int port, bool isWriteLog)
{
PrinterType = DeviceType.COM;
Port = port;
IsWriteLog = isWriteLog;
return PrintCommand(cmd);
}

public static bool PrintWithCOM(byte[] bytes, int port, bool isWriteLog, ProgrammingLanguage progLanguage)
{
PrinterType = DeviceType.COM;
Port = port;
IsWriteLog = isWriteLog;
PrinterProgrammingLanguage = progLanguage;
return PrintGraphics(bytes);
}

public static bool PrintWithLPT(string cmd, int port, bool isWriteLog)
{
PrinterType = DeviceType.LPT;
Port = port;
IsWriteLog = isWriteLog;
return PrintCommand(cmd);
}

public static bool PrintWithLPT(byte[] bytes, int port, bool isWriteLog, ProgrammingLanguage progLanguage)
{
PrinterType = DeviceType.LPT;
Port = port;
IsWriteLog = isWriteLog;
PrinterProgrammingLanguage = progLanguage;
return PrintGraphics(bytes);
}

public static bool PrintWithDRV(string cmd, string printerName, bool isWriteLog)
{
PrinterType = DeviceType.DRV;
PrinterName = printerName;
IsWriteLog = isWriteLog;
return PrintCommand(cmd);
}

public static bool PrintWithDRV(byte[] bytes, string printerName, bool isWriteLog, ProgrammingLanguage progLanguage)
{
PrinterType = DeviceType.DRV;
PrinterName = printerName;
IsWriteLog = isWriteLog;
PrinterProgrammingLanguage = progLanguage;
return PrintGraphics(bytes);
}
#endregion

#region 打印ZPL、EPL指令
public static bool PrintCommand(string cmd)
{
lock (SyncRoot)
{
bool result = false;
try
{
switch (PrinterType)
{
case DeviceType.COM:
result = comPrint(Encoding.Default.GetBytes(cmd));
break;
case DeviceType.LPT:
result = lptPrint(Encoding.Default.GetBytes(cmd));
break;
case DeviceType.DRV:
result = drvPrint(Encoding.Default.GetBytes(cmd));
break;
case DeviceType.TCP:
result = tcpPrint(Encoding.Default.GetBytes(cmd));
break;
}
if (!string.IsNullOrEmpty(cmd) && IsWriteLog)
{
WriteLog(cmd, LogType.Print);
}
}
catch (Exception ex)
{
//记录日志
if (IsWriteLog)
{
WriteLog(string.Format("{0} => {1}\r\n{2}", DateTime.Now, ex.Message, ex), LogType.Error);
}
}
finally
{
GraphBuffer = new byte[0];
}
return result;
}
}
#endregion

#region 打印图像字节流
public static bool PrintGraphics(byte[] graph)
{
lock (SyncRoot)
{
bool result = false;
try
{
GraphBuffer = graph;
byte[] cmdBytes = new byte[0];
if (PrinterProgrammingLanguage == ProgrammingLanguage.ZPL)
{
cmdBytes = getZPLBytes();
}
if (PrinterProgrammingLanguage == ProgrammingLanguage.EPL)
{
cmdBytes = getEPLBytes();
}
if (PrinterProgrammingLanguage == ProgrammingLanguage.CPCL)
{
cmdBytes = getCPCLBytes();
}
switch (PrinterType)
{
case DeviceType.COM:
result = comPrint(cmdBytes);
break;
case DeviceType.LPT:
result = lptPrint(cmdBytes);
break;
case DeviceType.DRV:
result = drvPrint(cmdBytes);
break;
case DeviceType.TCP:
result = tcpPrint(cmdBytes);
break;
}
if (cmdBytes.Length > 0 && IsWriteLog)
{
WriteLog(cmdBytes, LogType.Print);
}
}
catch (Exception ex)
{
//记录日志
if (IsWriteLog)
{
WriteLog(string.Format("{0} => {1}\r\n{2}", DateTime.Now, ex.Message, ex), LogType.Error);
}
}
finally
{
GraphBuffer = new byte[0];
}
return result;
}
}
#endregion

#region COM/LPT/DRV三种模式打印方法
private static bool drvPrint(byte[] cmdBytes)
{
bool result = false;
try
{
if (!string.IsNullOrEmpty(PrinterName))
{
result = SendBytesToPrinter(PrinterName, cmdBytes);
}
}
catch (Exception ex)
{
throw ex;
}
return result;
}

private static bool comPrint(byte[] cmdBytes)
{
bool result = false;
SerialPort com = new SerialPort(string.Format("{0}{1}", PrinterType, Port), 9600, Parity.None, 8, StopBits.One);
try
{
com.Open();
com.Write(cmdBytes, 0, cmdBytes.Length);
result = true;
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (com.IsOpen)
{
com.Close();
}
}
return result;
}

private static bool lptPrint(byte[] cmdBytes)
{
bool result = false;
FileStream fileStream = null;
StreamWriter streamWriter = null;
SafeFileHandle handle = null;
try
{
handle = CreateFile(string.Format("{0}{1}", PrinterType, Port), GENERIC_WRITE, 0, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
if (!handle.IsInvalid)
{
fileStream = new FileStream(handle, FileAccess.ReadWrite);
streamWriter = new StreamWriter(fileStream, Encoding.Default);
streamWriter.Write(cmdBytes);
result = true;
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (fileStream != null)
{
fileStream.Close();
fileStream = null;
}
if (streamWriter != null)
{
streamWriter.Close();
streamWriter = null;
}
if (handle != null)
{
handle.Close();
handle = null;
}
}
return result;
}

private static bool tcpPrint(byte[] cmdBytes)
{
bool result = false;
TcpClient tcp = null;
try
{
IPAddress ip = IPAddress.Parse(TcpIpAddress);
IPEndPoint iport = new IPEndPoint(ip, TcpPort);//9100为小票打印机指定端口
tcp = new TcpClient(iport);
tcp.SendTimeout = 1000;
tcp.ReceiveTimeout = 1000;
if (tcp.Connected)
{
tcp.Client.Send(cmdBytes);
result = true;
}
}
catch (Exception ex)
{
throw new Exception("打印失败,请检查打印机或网络设置。", ex);
}
finally
{
if (tcp != null)
{
if (tcp.Client != null)
{
tcp.Client.Close();
tcp.Client = null;
}
tcp.Close();
tcp = null;
}
}
return result;
}
#endregion

#region 生成ZPL图像打印指令
private static byte[] getZPLBytes()
{
byte[] result = new byte[0];
byte[] bmpData = getBitmapData();
string textBitmap = string.Empty;
string textHex = BitConverter.ToString(bmpData).Replace("-", string.Empty);
for (int i = 0; i < GraphHeight; i++)
{
textBitmap += textHex.Substring(i * RowRealBytesCount * 2, RowRealBytesCount * 2) + "\r\n";
}
string text = string.Format("~DGR:IMAGE.GRF,{0},{1},\r\n{2}^XGR:IMAGE.GRF,1,1^FS\r\n^IDR:IMAGE.GRF\r\n",
GraphHeight * RowRealBytesCount,
RowRealBytesCount,
textBitmap);
result = Encoding.Default.GetBytes(text);
return result;
}
#endregion

#region 生成EPL图像打印指令
private static byte[] getEPLBytes()
{
byte[] result = new byte[0];
byte[] buffer = getBitmapData();
string text = string.Format("N\r\nGW{0},{1},{2},{3},{4}\r\nP\r\n",
0,
0,
RowRealBytesCount,
GraphHeight,
TransferFormat.GetString(buffer));
result = TransferFormat.GetBytes(text);
return result;
}
#endregion

#region 生成CPCL图像打印指令
public static byte[] getCPCLBytes()
{
//GRAPHICS Commands
//Bit-mapped graphics can be printed by using graphics commands. ASCII hex (hexadecimal) is
//used for expanded graphics data (see example). Data size can be reduced to one-half by utilizing the
//COMPRESSED-GRAPHICS commands with the equivalent binary character(s) of the hex data. When
//using CG, a single 8 bit character is sent for every 8 bits of graphics data. When using EG two characters
//(16 bits) are used to transmit 8 bits of graphics data, making EG only half as efficient. Since this data is
//character data, however, it can be easier to handle and transmit than binary data.
//Format:
//{command} {width} {height} {x} {y} {data}
//where:
//{command}: Choose from the following:
//EXPANDED-GRAPHICS (or EG): Prints expanded graphics horizontally.
//VEXPANDED-GRAPHICS (or VEG): Prints expanded graphics vertically.
//COMPRESSED-GRAPHICS (or CG): Prints compressed graphics horizontally.
//VCOMPRESSED-GRAPHICS (or VCG): Prints compressed graphics vertically.
//{width}: Byte-width of image.
//{height} Dot-height of image.
//{x}: Horizontal starting position.
//{y}: Vertical starting position.
//{data}: Graphics data.
//Graphics command example
//Input:
//! 0 200 200 210 1
//EG 2 16 90 45 F0F0F0F0F0F0F0F00F0F0F0F0F0F0F0F
//F0F0F0F0F0F0F0F00F0F0F0F0F0F0F0F
//FORM
//PRINT

byte[] bmpData = getBitmapData();
int bmpDataLength = bmpData.Length;
for (int i = 0; i < bmpDataLength; i++)
{
bmpData[i] ^= 0xFF;
}
string textHex = BitConverter.ToString(bmpData).Replace("-", string.Empty);
string text = string.Format("! {0} {1} {2} {3} {4}\r\nEG {5} {6} {7} {8} {9}\r\nFORM\r\nPRINT\r\n",
0, //水平偏移量
TcpPrinterDPI, //横向DPI
TcpPrinterDPI, //纵向DPI
(int)(TcpLabelMaxHeightCM / 2.54f * TcpPrinterDPI), //标签最大像素高度=DPI*标签纸高度(英寸)
Copies, //份数
RowRealBytesCount, //图像的字节宽度
GraphHeight, //图像的像素高度
0, //横向的开始位置
0, //纵向的开始位置
textHex
);
return Encoding.UTF8.GetBytes(text);
}
#endregion

#region 获取单色位图数据
/// <summary>
/// 获取单色位图数据(1bpp),不含文件头、信息头、调色板三类数据。
/// </summary>
/// <returns></returns>
private static byte[] getBitmapData()
{
MemoryStream srcStream = new MemoryStream();
MemoryStream dstStream = new MemoryStream();
Bitmap srcBmp = null;
Bitmap dstBmp = null;
byte[] srcBuffer = null;
byte[] dstBuffer = null;
byte[] result = null;
try
{
srcStream = new MemoryStream(GraphBuffer);
srcBmp = Bitmap.FromStream(srcStream) as Bitmap;
srcBuffer = srcStream.ToArray();
GraphWidth = srcBmp.Width;
GraphHeight = srcBmp.Height;
dstBmp = srcBmp.Clone(new Rectangle(0, 0, srcBmp.Width, srcBmp.Height), PixelFormat.Format1bppIndexed);
dstBmp.Save(dstStream, ImageFormat.Bmp);
dstBuffer = dstStream.ToArray();

int bfSize = BitConverter.ToInt32(dstBuffer, 2);
int bfOffBits = BitConverter.ToInt32(dstBuffer, 10);
int bitmapDataLength = bfSize - bfOffBits;
result = new byte[GraphHeight * RowRealBytesCount];

//读取时需要反向读取每行字节实现上下翻转的效果,打印机打印顺序需要这样读取。
for (int i = 0; i < GraphHeight; i++)
{
Array.Copy(dstBuffer, bfOffBits + (GraphHeight - 1 - i) * RowSize, result, i * RowRealBytesCount, RowRealBytesCount);
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (srcStream != null)
{
srcStream.Dispose();
srcStream = null;
}
if (dstStream != null)
{
dstStream.Dispose();
dstStream = null;
}
if (srcBmp != null)
{
srcBmp.Dispose();
srcBmp = null;
}
if (dstBmp != null)
{
dstBmp.Dispose();
dstBmp = null;
}
}
return result;
}
#endregion

#region 扩展

#region CPCL命令打印24位bmp
private static string get24BitBmpData(string filePath)
{
Bitmap bmp = new Bitmap(filePath);
byte[] bitArray = { 128, 64, 32, 16, 8, 4, 2, 1 };
string imgTxt = "";
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
BitmapData data = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
IntPtr firstPix = data.Scan0;

int rowByteCount = bmp.Width * 3;
int filledCount = data.Stride - rowByteCount;
int bytes = data.Stride * data.Height;//Math.Ceiling((double)bmp.Width / 8)
byte[] rgbValues = new byte[bytes];
System.Runtime.InteropServices.Marshal.Copy(firstPix, rgbValues, 0, bytes);

int printRowByteCount = Convert.ToInt32(Math.Ceiling((double)(bmp.Width) / 8));
int printRowByteFillCount = 4 - (printRowByteCount % 4);
//int bitFillCount = 8 - (bmp.Width % 8);
byte[] printData = new byte[(printRowByteCount + printRowByteFillCount) * bmp.Height];

int byteCount = 0;
int bitCount = 0;
int rowPoint = 0;
for (int i = 0; i < rgbValues.Length; i += 3)
{
int rgbValue = rgbValues[i] + rgbValues[i + 1] + rgbValues[i + 2];
if (rgbValue != (255 * 3))
{
printData[byteCount] = Convert.ToByte(printData[byteCount] | bitArray[bitCount]);
}
if (bitCount == 7)
{
bitCount = 0;
byteCount++;
}
else
{
bitCount++;
}
if ((rowPoint + 3) == rowByteCount)
{
rowPoint = 0;
if (bitCount > 0)
{
byteCount++;
}
bitCount = 0;
byteCount += printRowByteFillCount;
i = i + filledCount;
}
else
{
rowPoint += 3;
}
}

foreach (byte byteData in printData)
{
string hexStr = Convert.ToString(byteData, 16);
if (hexStr.Length == 1)
{
hexStr = '0' + hexStr;
}
imgTxt += hexStr;
}
bmp.UnlockBits(data);
return imgTxt.ToUpper();
}

public static void Printer(string bitbmpPath)
{
string CRNL = "\r\n";
string imgTxt = get24BitBmpData(bitbmpPath);
string cmddata = "! 0 200 200 300 1" + CRNL +
"EG " + 24 + " " + 50 + " 10 10 " + imgTxt + CRNL +
"FORM" + CRNL +
"PRINT" + CRNL;
try
{
string ipAddress = "192.168.1.212";
int port = 9100;

// Open connection
System.Net.Sockets.TcpClient client = new System.Net.Sockets.TcpClient();
client.Connect(ipAddress, port);

// Write CPCL String to connection
System.IO.StreamWriter writer = new System.IO.StreamWriter(client.GetStream());
writer.Write(cmddata);
writer.Flush();

// Close Connection
writer.Close();
client.Close();
}
catch (Exception)
{
// Catch Exception
}
}
#endregion
#region ZPL
/// <summary>
/// ZPL指令开始
/// </summary>
/// <returns></returns>
public static string ZPL_Start()
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("^XA"); //指令块的开始
builder.AppendLine("^MD30"); //MD是设置色带颜色的深度(-30~30)
return builder.ToString();
}
/// <summary>
/// ZPL指令结束
/// </summary>
/// <returns></returns>
public static string ZPL_End()
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("^XZ"); //指令块的结束
return builder.ToString();
}
/// <summary>
/// 设置打印标签纸边距
/// </summary>
/// <param name="printX">标签纸边距x坐标</param>
/// <param name="printY">标签纸边距y坐标</param>
/// <returns></returns>
public static string ZPL_PageSet(int printX, int printY)
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("^LH" + printX + "," + printY); //定义条码纸边距(单位像素)80 10
return builder.ToString();
}
/// <summary>
/// 打印凭条设置
/// </summary>
/// <param name="width">凭条宽度</param>
/// <param name="height">凭条高度</param>
/// <returns>返回ZPL命令</returns>
public static string ZPL_SetLabel(int width, int height)
{
//ZPL条码设置命令:^PW640^LL480
string sReturn = "^PW{0}^LL{1}";
return string.Format(sReturn, width, height);
}
/// <summary>
/// 打印矩形
/// </summary>
/// <param name="px">起点X坐标</param>
/// <param name="py">起点Y坐标</param>
/// <param name="thickness">边框宽度</param>
/// <param name="width">矩形宽度,0表示打印一条竖线</param>
/// <param name="height">矩形高度,0表示打印一条横线</param>
/// <returns>返回ZPL命令</returns>
public static string ZPL_DrawRectangle(int px, int py, int thickness, int width, int height)
{
//ZPL矩形命令:^FO50,50^GB300,200,2^FS
string sReturn = "^FO{0},{1}^GB{3},{4},{2}^FS";
return string.Format(sReturn, px, py, thickness, width, height);
}
/// <summary>
/// 打印英文
/// </summary>
/// <param name="EnText">待打印文本</param>
/// <param name="ZebraFont">打印机字体 A-Z</param>
/// <param name="px">起点X坐标</param>
/// <param name="py">起点Y坐标</param>
/// <param name="Orient">旋转角度N = normal,R = rotated 90 degrees (clockwise),I = inverted 180 degrees,B = read from bottom up, 270 degrees</param>
/// <param name="Height">字体高度</param>
/// <param name="Width">字体宽度</param>
/// <returns>返回ZPL命令</returns>
public static string ZPL_DrawENText(string EnText, string ZebraFont, int px, int py, string Orient, int Height, int Width)
{
//ZPL打印英文命令:^FO50,50^A0N,32,25^FDZEBRA^FS
string sReturn = "^FO{1},{2}^A" + ZebraFont + "{3},{4},{5}^FD{0}^FS";
return string.Format(sReturn, EnText, px, py, Orient, Height, Width);
}
/// <summary>
/// 中文处理,返回ZPL命令
/// </summary>
/// <param name="ChineseText">待转变中文内容</param>
/// <param name="FontName">字体名称</param>
/// <param name="startX">X坐标</param>
/// <param name="startY">Y坐标</param>
/// <param name="Orient">旋转角度0,90,180,270</param>
/// <param name="Height">字体高度</param>
/// <param name="Width">字体宽度,通常是0</param>
/// <param name="IsBold">1 变粗,0 正常</param>
/// <param name="IsItalic">1 斜体,0 正常</param>
/// <returns></returns>
public static string ZPL_DrawCHText(string ChineseText, string FontName, int startX, int startY, int Orient, int Height, int Width, int IsBold, int IsItalic)
{
StringBuilder sResult = new StringBuilder();
StringBuilder hexbuf = new StringBuilder(21 * 1024);
int count = ZebraPrintHelper.GETFONTHEX(ChineseText, FontName, Orient, Height, Width, IsBold, IsItalic, hexbuf);
if (count > 0)
{
string sEnd = "^FO" + startX.ToString() + "," + startY.ToString() + "^XGOUTSTR" + ",1,2^FS ";
sResult.AppendLine(hexbuf.ToString().Replace("OUTSTR01", "OUTSTR") + sEnd);
}
return sResult.ToString();
}
/// <summary>
/// 打印条形码(128码)
/// </summary>
/// <param name="px">起点X坐标</param>
/// <param name="py">起点Y坐标</param>
/// <param name="width">基本单元宽度 1-10</param>
/// <param name="ratio">宽窄比 2.0-3.0 增量0.1</param>
/// <param name="barheight">条码高度</param>
/// <param name="barcode">条码内容</param>
/// <returns>返回ZPL命令</returns>
public static string ZPL_DrawBarcode(int px, int py, int width, int ratio, int barheight, string barcode)
{
//ZPL打印英文命令:^FO50,260^BY1,2^BCN,100,Y,N^FDSMJH2000544610^FS
string sReturn = "^FO{0},{1}^BY{2},{3}^BCN,{4},N,N^FD{5}^FS";
return string.Format(sReturn, px, py, width, ratio, barheight, barcode);
}
/// <summary>
/// 中文处理
/// </summary>
/// <param name="ChineseText">待转变中文内容</param>
/// <param name="FontName">字体名称</param>
/// <param name="Orient">旋转角度0,90,180,270</param>
/// <param name="Height">字体高度</param>
/// <param name="Width">字体宽度,通常是0</param>
/// <param name="IsBold">1 变粗,0 正常</param>
/// <param name="IsItalic">1 斜体,0 正常</param>
/// <param name="ReturnPicData">返回的图片字符</param>
/// <returns></returns>
[DllImport("fnthex32.dll")]
public static extern int GETFONTHEX(
string ChineseText,
string FontName,
int Orient,
int Height,
int Width,
int IsBold,
int IsItalic,
StringBuilder ReturnPicData);
/// <summary>
/// 中文处理
/// </summary>
/// <param name="ChineseText">待转变中文内容</param>
/// <param name="FontName">字体名称</param>
/// <param name="FileName">返回的图片字符重命</param>
/// <param name="Orient">旋转角度0,90,180,270</param>
/// <param name="Height">字体高度</param>
/// <param name="Width">字体宽度,通常是0</param>
/// <param name="IsBold">1 变粗,0 正常</param>
/// <param name="IsItalic">1 斜体,0 正常</param>
/// <param name="ReturnPicData">返回的图片字符</param>
/// <returns></returns>
[DllImport("fnthex32.dll")]
public static extern int GETFONTHEX(
string ChineseText,
string FontName,
string FileName,
int Orient,
int Height,
int Width,
int IsBold,
int IsItalic,
StringBuilder ReturnPicData);
/// <summary>
/// 毫米转像素 取整
/// </summary>
/// <param name="mm">毫米</param>
/// <param name="dpi">打印DPI 如300</param>
/// <returns></returns>
public static double mm2px(double mm, double dpi)
{
double px = (mm / 25.4) * dpi;
return Math.Round(px, 0, MidpointRounding.AwayFromZero);
}
/// <summary>
/// 像素转毫米 取整
/// </summary>
/// <param name="px">像素</param>
/// <param name="dpi">打印DPI 如300</param>
/// <returns></returns>
public static double px2mm(double px, double dpi)
{
//像素转换成毫米公式:(宽度像素/水平DPI)*25.4;
double mm = (px / dpi) * 25.4;
return Math.Round(mm, 0, MidpointRounding.AwayFromZero);
}
/// <summary>
/// 生成zpl命令 且执行
/// </summary>
/// <param name="path">zpl文件路径</param>
/// <param name="zpl">zpl命令</param>
public static void CmdDos(string path, string zpl)
{
FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs, Encoding.Default);//ANSI编码格式
if (File.Exists(path))
{
sw.Write(zpl);
sw.Flush();
sw.Close();
}
fs.Close();
RunCmd("print /d:COM1 " + path + " ");
}
/// <summary>
/// 运行Dos命令
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
private static bool RunCmd(string command)
{
//实例一个Process类,启动一个独立进程
Process p = new Process();
//Process类有一个StartInfo属性,這個是ProcessStartInfo类,包括了一些属性和方法,下面我們用到了他的几个属性:
p.StartInfo.FileName = "cmd.exe";//设定程序名
p.StartInfo.Arguments = "/c " + command;//设定程式执行参数
p.StartInfo.UseShellExecute = false;//关闭Shell的使用
p.StartInfo.RedirectStandardInput = true;//重定向标准输入
p.StartInfo.RedirectStandardOutput = true;//重定向标准输出
p.StartInfo.RedirectStandardError = true;//重定向错误输出
p.StartInfo.CreateNoWindow = true;//设置不显示窗口
//p.StandardInput.WriteLine(command);//也可以用这种方式输入要执行的命令
//p.StandardInput.WriteLine("exit");//不过要记得加上Exit要不然下一行程式执行的時候会当机
try
{
p.Start();//开始进程
return true;
}
catch
{
}
finally
{
if (p != null)
p.Close();
}
return false;
}
#endregion
#endregion
}


#region 定义设备类型枚举
public enum DeviceType
{
COM = 0,
LPT = 1,
DRV = 2,
TCP = 3
}
#endregion

#region 定义打印机指令类型枚举
public enum ProgrammingLanguage
{
ZPL = 0,
EPL = 1,
CPCL = 2
}
#endregion

#region 定义日志类型枚举
public enum LogType
{
Print = 0,
Error = 1
}
#endregion

 

 

#region 定义打印文档信息类
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public class DocInfo
{
[MarshalAs(UnmanagedType.LPStr)]
public string DocName;
[MarshalAs(UnmanagedType.LPStr)]
public string OutputFile;
[MarshalAs(UnmanagedType.LPStr)]
public string DataType;
}
#endregion

#region 定义图像设备信息类
public class DeviceInfo
{
#region 属性说明
/*
ColorDepth
图像输出支持的颜色范围的像素深度。有效值为 1、4、8、24 和 32。默认值为 24。仅对 TIFF 呈现支持 ColorDepth,对于其他图像输出格式报表服务器将忽略此设置。

注意:
对于此版本的 SQL Server,此设置的值将被忽略,且通常将 TIFF 图像呈现为 24 位。

Columns
要为报表设置的列数。此值将覆盖报表的原始设置。

ColumnSpacing
要为报表设置的列间距。此值将覆盖报表的原始设置。

DpiX
输出设备在 X 方向的分辨率。默认值为 96。

DpiY
输出设备在 Y 方向的分辨率。默认值为 96。

EndPage
要呈现的报表的最后一页。默认值为 StartPage 的值。

MarginBottom
要为报表设置的下边距值,以英寸为单位。您必须包含一个整数或小数值,后跟“in”(例如,1in)。此值将覆盖报表的原始设置。

MarginLeft
要为报表设置的左边距值,以英寸为单位。您必须包含一个整数或小数值,后跟“in”(例如,1in)。此值将覆盖报表的原始设置。

MarginRight
要为报表设置的右边距值,以英寸为单位。您必须包含一个整数或小数值,后跟“in”(例如,1in)。此值将覆盖报表的原始设置。

MarginTop
要为报表设置的上边距值,以英寸为单位。您必须包含一个整数或小数值,后跟“in”(例如,1in)。此值将覆盖报表的原始设置。

OutputFormat
图形设备接口 (GDI) 支持的输出格式之一:BMP、EMF、GIF、JPEG、PNG 或 TIFF。

PageHeight
要为报表设置的页高,以英寸为单位。您必须包含一个整数或小数值,后跟“in”(例如,11in)。此值将覆盖报表的原始设置。

PageWidth
要为报表设置的页宽,以英寸为单位。您必须包含一个整数或小数值,后跟“in”(例如,8.5in)。此值将覆盖报表的原始设置。

StartPage
要呈现的报告的第一页。值为 0 指示将呈现所有页。默认值为 1。
*/
#endregion

public enum GDIOutputFormat { BMP, EMF, GIF, JPEG, PNG, TIFF }

public int ColorDepth { get; set; }
public int Columns { get; set; }
public int ColumnSpacing { get; set; }
public int DpiX { get; set; }
public int DpiY { get; set; }
public int EndPage { get; set; }
public int MarginBottom { get; set; }
public int MarginLeft { get; set; }
public int MarginRight { get; set; }
public int MarginTop { get; set; }
public GDIOutputFormat OutputFormat { get; set; }
public int PageHeight { get; set; }
public int PageWidth { get; set; }
public int StartPage { get; set; }

private const string xmlFormater = @"<DeviceInfo>
<ColorDepth>{0}</ColorDepth>
<Columns>{1}</Columns>
<ColumnSpacing>{2}</ColumnSpacing>
<DpiX>{3}</DpiX>
<DpiY>{4}</DpiY>
<EndPage>{5}</EndPage>
<MarginBottom>{6}</MarginBottom>
<MarginLeft>{7}</MarginLeft>
<MarginRight>{8}</MarginRight>
<MarginTop>{9}</MarginTop>
<OutputFormat>{10}</OutputFormat>
<PageHeight>{11}</PageHeight>
<PageWidth>{12}</PageWidth>
<StartPage>{13}</StartPage>
</DeviceInfo>";

public DeviceInfo()
{
this.ColorDepth = 24;
this.Columns = 0;
this.StartPage = 1;
this.EndPage = 1;
}

public string GetDeviceInfo()
{
string result = string.Format(xmlFormater,
this.ColorDepth,
this.Columns,
this.ColumnSpacing,
this.DpiX,
this.DpiY,
this.EndPage,
this.MarginBottom,
this.MarginLeft,
this.MarginRight,
this.MarginTop,
this.OutputFormat,
this.PageHeight,
this.PageWidth,
this.StartPage);
return result;
}

public string GetDeviceInfoForImage()
{
string result = string.Format("<DeviceInfo><StartPage>{0}</StartPage><EndPage>{1}</EndPage><OutputFormat>{2}</OutputFormat><DpiX>{3}</DpiX><DpiY>{4}</DpiY></DeviceInfo>",
this.StartPage,
this.EndPage,
this.OutputFormat,
this.DpiX,
this.DpiY);
return result;
}
}
#endregion

        #endregion

        public enum GDIOutputFormat { BMP, EMF, GIF, JPEG, PNG, TIFF }

        public int ColorDepth { get; set; }
        public int Columns { get; set; }
        public int ColumnSpacing { get; set; }
        public int DpiX { get; set; }
        public int DpiY { get; set; }
        public int EndPage { get; set; }
        public int MarginBottom { get; set; }
        public int MarginLeft { get; set; }
        public int MarginRight { get; set; }
        public int MarginTop { get; set; }
        public GDIOutputFormat OutputFormat { get; set; }
        public int PageHeight { get; set; }
        public int PageWidth { get; set; }
        public int StartPage { get; set; }

        private const string xmlFormater = @"<DeviceInfo>  
                <ColorDepth>{0}</ColorDepth>  
                <Columns>{1}</Columns>  
                <ColumnSpacing>{2}</ColumnSpacing>  
                <DpiX>{3}</DpiX>  
                <DpiY>{4}</DpiY>  
                <EndPage>{5}</EndPage>  
                <MarginBottom>{6}</MarginBottom>  
                <MarginLeft>{7}</MarginLeft>  
                <MarginRight>{8}</MarginRight>  
                <MarginTop>{9}</MarginTop>  
                <OutputFormat>{10}</OutputFormat>  
                <PageHeight>{11}</PageHeight>  
                <PageWidth>{12}</PageWidth>  
                <StartPage>{13}</StartPage>  
                </DeviceInfo>";

        public DeviceInfo()
        {
            this.ColorDepth = 24;
            this.Columns = 0;
            this.StartPage = 1;
            this.EndPage = 1;
        }

        public string GetDeviceInfo()
        {
            string result = string.Format(xmlFormater,
                this.ColorDepth,
                this.Columns,
                this.ColumnSpacing,
                this.DpiX,
                this.DpiY,
                this.EndPage,
                this.MarginBottom,
                this.MarginLeft,
                this.MarginRight,
                this.MarginTop,
                this.OutputFormat,
                this.PageHeight,
                this.PageWidth,
                this.StartPage);
            return result;
        }

        public string GetDeviceInfoForImage()
        {
            string result = string.Format("<DeviceInfo><StartPage>{0}</StartPage><EndPage>{1}</EndPage><OutputFormat>{2}</OutputFormat><DpiX>{3}</DpiX><DpiY>{4}</DpiY></DeviceInfo>",
                this.StartPage,
                this.EndPage,
                this.OutputFormat,
                this.DpiX,
                this.DpiY);
            return result;
        }
    }
    #endregion  

 

posted @ 2021-10-09 21:05  tiger_yj  阅读(253)  评论(0编辑  收藏  举报