public static ZebraPrinter Disconnect(ZebraPrinter printer)
 {
     try
     {
         printer.Connection.Close();
         Console.WriteLine($"Printer Disconnected");
     }
     catch (ConnectionException e)
     {
         Console.WriteLine($"Error disconnecting from printer: {e.Message}");
     }
     return(printer);
 }
示例#2
0
        private void ImprimirEtiqueta(string shipTo, string caja)
        {
            var info = InfoShippingBusiness.GetInfoShipping(shipTo);

            if (info != null && impresora != "")
            {
                zebraInstructions = new StringBuilder();
                zebraInstructions.Append("^XA");

                zebraInstructions.Append("^FT413,153^A0N,39,38^FH\\^FDCountry:^FS");
                zebraInstructions.Append("^FT572,153^A0N,39,38^FH\\^FD" + info.country + "^FS" + Environment.NewLine);

                zebraInstructions.Append("^FT21,371^A0N,39,38^FH\\^FDState:^FS");
                zebraInstructions.Append("^FT192,367^A0N,28,28^FH\\^FD" + info.state + "^FS" + Environment.NewLine);

                zebraInstructions.Append("^FT21,270^A0N,39,38^FH\\^FDCity:^FS");
                zebraInstructions.Append("^FT167,263^A0N,25,24^FH\\^FD" + info.city + "^FS" + Environment.NewLine);

                zebraInstructions.Append("^FT21,219^A0N,39,38^FH\\^FDAddress:^FS");
                zebraInstructions.Append("^FT165,213^A0N,25,24^FH\\^FD" + info.address + "^FS" + Environment.NewLine);

                zebraInstructions.Append("^FT23,420^A0N,39,38^FH\\^FDClient:^FS");
                zebraInstructions.Append("^FT175,420^A0N,39,30^FH\\^FD" + info.client + "^FS" + Environment.NewLine);

                zebraInstructions.Append("^FT23,465^A0N,39,38^FH\\^FDContact:^FS");
                zebraInstructions.Append("^FT175,465^A0N,39,38^FH\\^FD" + info.contact + "^FS" + Environment.NewLine);

                zebraInstructions.Append("^FT22,153^A0N,39,38^FH\\^FDShip To:^FS");
                zebraInstructions.Append("^^FT184,153^A0N,39,38^FH\\^FD" + info.shipTo + "^FS" + Environment.NewLine);

                zebraInstructions.Append("^FT195,66^A0N,39,38^FH\\^FDBOXID:^FS" + Environment.NewLine);
                zebraInstructions.Append("^BY3,3,56^FT327,76^BCN,,Y,N");
                zebraInstructions.Append("^FD>:" + caja + "^FS" + Environment.NewLine);

                //Codigo QR
                zebraInstructions.Append("^FT687,112^BQN,2,4" + Environment.NewLine);
                zebraInstructions.Append(@"^FH\^FDLA" + caja + "^FS");

                zebraInstructions.Append("^FT21,320^A0N,39,38^FH\\^FDZip Code:^FS");
                zebraInstructions.Append("^FT192,316^A0N,28,28^FH\\^FD" + info.zipcode + "^FS" + Environment.NewLine);

                zebraInstructions.Append("^FT23,506^A0N,39,38^FH\\^FDEmail:^FS");
                zebraInstructions.Append("^FT175,505^A0N,39,38^FH\\^FD" + info.email + "^FS" + Environment.NewLine);
                zebraInstructions.Append("^PQ1,0,1,Y^XZ");

                string selectedPrinterName = impresora;
                var    z = new ZebraPrinter(selectedPrinterName);
                z.Print(zebraInstructions.ToString());
                z.Print(zebraInstructions.ToString());
            }
        }
示例#3
0
        private void Print(string ipAddress, List <DataPrinter> dataPrint)
        {
            Connection   connection = new TcpConnection(ipAddress, TcpConnection.DEFAULT_ZPL_TCP_PORT);
            ZebraPrinter printer    = Connect(connection);

            if (printer == null)
            {
                MessageBox.Show("Printer not connected!");
                return;
            }

            var status = GetPrinterStatus(printer);

            if (status != Status.Ready)
            {
                MessageBox.Show("Printer status: " + status);
                return;
            }

            foreach (var data in dataPrint)
            {
                if (PrintOne(printer, data.ZplData))
                {
                    data.Send = true;

                    if (CheckPrintingStatus(printer))
                    {
                        data.Print = true;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            var noPrinted = dataPrint.Where(x => x.Print == false).ToList();

            if (noPrinted != null && noPrinted.Count > 0)
            {
                MessageBox.Show("Press OK to Continue...");

                Print(ipAddress, noPrinted);
            }

            Disconnect(printer);

            MessageBox.Show("Done!");
        }
        private void CreateFormatTableDialog()
        {
            SetButtonState(retrieveFormatsButton, false);
            SetFormatListState(false);

            string     formatName        = (string)storedFilesList.SelectedValue;
            Connection printerConnection = null;

            Task.Run(() => {
                try {
                    printerConnection = connectionSelector.GetConnection();
                    printerConnection.Open();

                    ZebraPrinter printer = ZebraPrinterFactory.GetInstance(printerConnection);
                    byte[] formatData    = printer.RetrieveFormatFromPrinter(formatName);

                    fieldDescDataVars = printer.GetVariableFields(Encoding.UTF8.GetString(formatData)).ToList();
                    fieldDescDataVars = FormatFieldDescriptionDataVars(fieldDescDataVars);

                    formatVariables = new ObservableCollection <FormatVariable>();
                    for (int i = 0; i < fieldDescDataVars.Count; ++i)
                    {
                        formatVariables.Add(new FormatVariable {
                            FieldName = fieldDescDataVars[i].FieldName, FieldValue = ""
                        });
                    }

                    try {
                        if (printerConnection != null)
                        {
                            printerConnection.Close();
                        }
                    } catch (ConnectionException) { }

                    ShowStoredFormatDialog(formatName);
                } catch (Exception e) {
                    MessageBoxCreator.ShowError(e.Message, "Communication Error");
                    SetButtonState(retrieveFormatsButton, true);
                    SetFormatListState(true);
                } finally {
                    try {
                        if (printerConnection != null && printerConnection.Connected)
                        {
                            printerConnection.Close();
                        }
                    } catch (ConnectionException) { }
                }
            });
        }
        private FieldDescriptionData[] GetVarFieldNames()
        {
            String formatName = formatListBox.SelectedItem.ToString();

            FieldDescriptionData[] fieldNames = new FieldDescriptionData[] { };
            try {
                ZebraPrinter printer      = getPrinter();
                byte[]       formatData   = printer.GetFormatUtil().RetrieveFormatFromPrinter(formatName);
                String       formatString = Encoding.UTF8.GetString(formatData, 0, formatData.Length);
                fieldNames = printer.GetFormatUtil().GetVariableFields(formatString);
            } catch (ZebraPrinterConnectionException) {
                updateGuiFromWorkerThread("Communication Error", Color.Red);
            }
            return(fieldNames);
        }
        private void TestConnectionString()
        {
            Task.Run(() => {
                try {
                    ClearProgress();
                    connection = ZebraConnectionBuilder.Build(GetConnectionStringForSdk());
                    PublishProgress("Connection string evaluated as class type " + connection.GetType().Name);
                    connection.Open();

                    PublishProgress("Connection opened successfully");

                    if (IsAttemptingStatusConnection())
                    {
                        ZebraPrinterLinkOs printer = ZebraPrinterFactory.GetLinkOsPrinter(connection);
                        PublishProgress("Created a printer, attempting to retrieve status");

                        ZebraPrinterStatus status = printer.GetCurrentStatus();
                        PublishProgress("Is printer ready to print? " + status.isReadyToPrint);
                    }
                    else
                    {
                        ZebraPrinter printer = ZebraPrinterFactory.GetInstance(connection);
                        PublishProgress("Created a printer, attempting to print a config label");
                        printer.PrintConfigurationLabel();
                    }

                    PublishProgress("Closing connection");
                } catch (ConnectionException) {
                    MessageBoxCreator.ShowError("Connection could not be opened", "Error");
                } catch (ZebraPrinterLanguageUnknownException) {
                    MessageBoxCreator.ShowError("Could not create printer", "Error");
                } finally {
                    if (connection != null)
                    {
                        try {
                            connection.Close();
                        } catch (ConnectionException) { } finally {
                            connection = null;
                            SetTestButtonState(true);
                        }
                    }
                    else
                    {
                        SetTestButtonState(true);
                    }
                }
            });
        }
示例#7
0
            public void disconnect(IMethodResult oResult)
            {
                Logger.Write("disconnect call");

                if (m_connection != null && m_connection.IsConnected())
                {
                    Thread.Sleep(1000);
                    m_connection.Close();
                    Thread.Sleep(1000);
                }

                m_connection = null;
                m_printer    = null;

                oResult.set(ZebraConstants.PRINTER_STATUS_SUCCESS);
            }
示例#8
0
        public static bool Print(ZebraPrinter printer, string printstring)
        {
            bool sent = false;

            try
            {
                VerifyConnection(printer);
                printer.Connection.Write(Encoding.UTF8.GetBytes(printstring));
                sent = true;
            }
            catch (ConnectionException e)
            {
                Console.WriteLine($"Unable to write to printer: {e.Message}");
            }
            return(sent);
        }
        private async void PrintButton_Clicked(object sender, EventArgs eventArgs)
        {
            SetInputEnabled(false);

            Connection connection = null;

            try {
                await Task.Factory.StartNew(() => {
                    connection = CreateConnection();
                    connection.Open();

                    ZebraPrinter printer = ZebraPrinterFactory.GetInstance(connection);

                    if (printer.PrinterControlLanguage == PrinterLanguage.LINE_PRINT)
                    {
                        throw new ConnectionException("Operation cannot be performed with a printer set to line print mode");
                    }

                    string signaturePath = Path.Combine(LocalApplicationDataFolderPath, "signature.jpeg");
                    double printWidth    = double.Parse(SGD.GET("ezpl.print_width", connection));

                    if (File.Exists(signaturePath))
                    {
                        File.Delete(signaturePath);
                    }

                    using (Stream stream = SignaturePad.GetImageStream(printWidth)) {
                        using (BinaryReader br = new BinaryReader(stream)) {
                            br.BaseStream.Position = 0;
                            byte[] signatureBytes  = br.ReadBytes((int)stream.Length);
                            File.WriteAllBytes(signaturePath, signatureBytes);
                        }
                    }

                    ZebraImageI image = ZebraImageFactory.Current.GetImage(signaturePath);
                    printer.PrintImage(image, 0, 0, image.Width, image.Height, false);
                });
            } catch (Exception e) {
                await DisplayAlert("Error", e.Message, "OK");
            } finally {
                try {
                    connection?.Close();
                } catch (ConnectionException) { }

                SetInputEnabled(true);
            }
        }
        private bool SaveModifiedSettingsToPrinter()
        {
            bool       result     = false;
            Connection connection = null;

            try {
                connection = connectionSelector.GetConnection();
                connection.Open();

                ZebraPrinter       genericPrinter = ZebraPrinterFactory.GetInstance(connection);
                ZebraPrinterLinkOs printer        = ZebraPrinterFactory.CreateLinkOsPrinter(genericPrinter);

                if (printer != null)
                {
                    foreach (string key in viewModel.ModifiedSettings.Keys)
                    {
                        if (printer.IsSettingReadOnly(key) == false)
                        {
                            printer.SetSetting(key, viewModel.ModifiedSettings[key]);
                        }
                    }

                    viewModel.ModifiedSettings.Clear();
                    result = true;
                }
                else
                {
                    MessageBoxCreator.ShowError("Connected printer does not support settings", "Connection Error");
                }
            } catch (ConnectionException e) {
                MessageBoxCreator.ShowError(e.Message, "Connection Error");
            } catch (ZebraPrinterLanguageUnknownException e) {
                MessageBoxCreator.ShowError(e.Message, "Connection Error");
            } catch (SettingsException e) {
                MessageBoxCreator.ShowError(e.Message, "Settings Error");
            } catch (Exception e) {
                MessageBoxCreator.ShowError(e.Message, "Save Settings Error");
            } finally {
                try {
                    if (connection != null)
                    {
                        connection.Close();
                    }
                } catch (ConnectionException) { }
            }
            return(result);
        }
示例#11
0
        public bool Print()
        {
            bool error = true;

            try
            {
                // Open the connection - physical connection is established here.
                ThePrinterConn.Open();

                printer = ZebraPrinterFactory.GetInstance(ThePrinterConn);
                PrinterStatus printerStatus = printer.GetCurrentStatus();
                bool          ready         = printerStatus.IsReadyToPrint;
                if (ready == false)
                {
                    return(error);
                }



                //stvaranje oblika za slanje na printer
                String output = "! 0 200 200" + " " + (lastYPos + 100).ToString() + " " + "1\r\n";
                //output += "IN-MILLIMETERS\r\n";
                foreach (String s in buffer)
                {
                    output += s + "\r\n";
                }
                output += "PRINT\r\n";

                // Send the data to the printer as a byte array.
                ThePrinterConn.Write(Encoding.UTF8.GetBytes(output));
                //thePrinterConn.Close();
                error = false;
            }
            catch (Exception e)
            {
                Logger.Logger.Log(e);
                error = true;
            }
            finally
            {
                //brisi buffer
                buffer.Clear();

                //na kraju, baci gresku ako nije izvrseno do kraja...
            }
            return(error);
        }
示例#12
0
        public static IPrinter CreatePrinter(PrinterType printerType)
        {
            IPrinter printer = null;

            switch (printerType)
            {
            case PrinterType.BradyPrinter:
                printer = new Printers.BradyPrinter();
                break;

            case PrinterType.ZebraPrinter:
                printer = new ZebraPrinter();
                break;
            }

            return(printer);
        }
示例#13
0
        public void PrintLabel(string IpAddress, int number, string name)
        {
            string ZPL_STRING = Resources.HeadBarcode + "^FS^FO200,50^A0,25,25^FD" + "Baza narzedzi robotow" + "^FS^FO200,100^A0,25,25^FDNarzedzie numer:" + number + " ^FS^FO200,150^A0,25,25^FDNazwa narzedzia:" + name + " ^FS^FO200,200^A0,25,25^FDData przegladu:" + DateTime.Now.ToString("MM/dd/yyyy") + " ^FS^XZ";

            ZebraPrinter zebraPrinter = ZebraPrintHelper.Connect(new TcpConnection(IpAddress, TcpConnection.DEFAULT_ZPL_TCP_PORT), PrinterLanguage.ZPL);

            if (ZebraPrintHelper.CheckStatus(zebraPrinter))
            {
                ZebraPrintHelper.Print(zebraPrinter, ZPL_STRING);

                if (ZebraPrintHelper.CheckStatusAfter(zebraPrinter))
                {
                    Console.WriteLine($"Label Printed");
                }
            }
            zebraPrinter = ZebraPrintHelper.Disconnect(zebraPrinter);
        }
示例#14
0
        private void ReadMagCard()
        {
            Connection connection = null;
            Task       t          = Task.Run(() => {
                try {
                    connection = connectionSelector.GetConnection();
                    connection.Open();

                    ZebraPrinter printer        = ZebraPrinterFactory.GetInstance(connection);
                    MagCardReader magCardReader = MagCardReaderFactory.Create(printer);

                    if (magCardReader != null)
                    {
                        UpdateMagCardOutput("");
                        SetButtonText("Swipe Card Now");
                        string[] trackData = magCardReader.Read(30000);

                        if (trackData[0].Equals("") && trackData[1].Equals("") && trackData[2].Equals(""))
                        {
                            MessageBoxCreator.ShowError("Connection timed out", "Mag Card Error");
                        }
                        else
                        {
                            UpdateMagCardOutput(trackData[0] + "\r\n" + trackData[1] + "\r\n" + trackData[2]);
                        }
                    }
                    else
                    {
                        MessageBoxCreator.ShowError("Printer does not have a mag card reader", "Mag Card Error");
                    }
                } catch (ConnectionException e) {
                    MessageBoxCreator.ShowError(e.Message, "Connection Error");
                } catch (ZebraPrinterLanguageUnknownException e) {
                    MessageBoxCreator.ShowError(e.Message, "Connection Error");
                } finally {
                    if (connection != null)
                    {
                        try {
                            connection.Close();
                        } catch (ConnectionException) { }
                    }
                    SetButtonText("Read Mag Card");
                    SetButtonState(true);
                }
            });
        }
        private void GetListOfFormats()
        {
            ZebraPrinterConnection connection = getConnection();
            ZebraPrinter           printer    = ZebraPrinterFactory.GetInstance(connection);

            String[] zplFormatExtensions  = new String[] { "ZPL" };
            String[] cpclFormatExtensions = new String[] { "FMT", "LBL" };
            String[] extensions           = printer.GetPrinterControlLanguage() == PrinterLanguage.ZPL ? zplFormatExtensions : cpclFormatExtensions;

            List <String> formatList = new List <String>();

            foreach (String format in printer.GetFileUtil().RetrieveFileNames(extensions))
            {
                formatList.Add(format);
            }
            Invoke(new FormatListEventHandler(DisplayNames), new object[] { formatList });
        }
        private void PrintLabel(string theIpAddress)
        {
            string ZPL_STRING = Resources.HeadBarcode + "^FS^FO250,50^A0,25,25^FD" + BarcodeDescription + "^FS^FO230,90^BCN,100,Y,N,N^FD" + BarcodeNumber + "^FS^XZ";

            ZebraPrinter zebraPrinter = ZebraPrintHelper.Connect(new TcpConnection(theIpAddress, TcpConnection.DEFAULT_ZPL_TCP_PORT), PrinterLanguage.ZPL);

            if (ZebraPrintHelper.CheckStatus(zebraPrinter))
            {
                ZebraPrintHelper.Print(zebraPrinter, ZPL_STRING);

                if (ZebraPrintHelper.CheckStatusAfter(zebraPrinter))
                {
                    Console.WriteLine($"Label Printed");
                }
            }
            zebraPrinter = ZebraPrintHelper.Disconnect(zebraPrinter);
        }
示例#17
0
        private bool PrintOne(ZebraPrinter printer, string zplData)
        {
            try
            {
                if (GetPrinterStatus(printer) == Status.Ready)
                {
                    printer.Connection.Write(Encoding.UTF8.GetBytes(zplData));
                    return(true);
                }

                return(false);
            }
            catch (ConnectionException)
            {
                return(false);
            }
        }
        private void threadedConnect(String addressName)
        {
            try
            {
                connection.Open();
                Thread.Sleep(1000);
            }
            catch (ZebraPrinterConnectionException)
            {
                updateGuiFromWorkerThread("Unable to connect with printer", Color.Red);
                disconnect();
            }
            catch (Exception)
            {
                updateGuiFromWorkerThread("Error communicating with printer", Color.Red);
                disconnect();
            }

            printer = null;
            if (connection != null && connection.IsConnected())
            {
                try
                {
                    printer = ZebraPrinterFactory.GetInstance(connection);
                    PrinterLanguage pl = printer.GetPrinterControlLanguage();
                    updateGuiFromWorkerThread("Printer Language " + pl.ToString(), Color.LemonChiffon);
                    Thread.Sleep(1000);
                    updateGuiFromWorkerThread("Connected to " + addressName, Color.Green);
                    Thread.Sleep(1000);
                }
                catch (ZebraPrinterConnectionException)
                {
                    updateGuiFromWorkerThread("Unknown Printer Language", Color.Red);
                    printer = null;
                    Thread.Sleep(1000);
                    disconnect();
                }
                catch (ZebraPrinterLanguageUnknownException)
                {
                    updateGuiFromWorkerThread("Unknown Printer Language", Color.Red);
                    printer = null;
                    Thread.Sleep(1000);
                    disconnect();
                }
            }
        }
示例#19
0
        public static bool CheckStatusAfter(ZebraPrinter printer)
        {
            PrinterStatus printerStatus = null;

            try
            {
                VerifyConnection(printer);
                printerStatus = printer.GetCurrentStatus();

                while ((printerStatus.numberOfFormatsInReceiveBuffer > 0) && (printerStatus.isReadyToPrint))
                {
                    Thread.Sleep(500);
                    printerStatus = printer.GetCurrentStatus();
                }
            }
            catch (ConnectionException e)
            {
                throw new ConnectionException($"Error getting status from printer: {e.Message}");
            }

            if (printerStatus.isReadyToPrint)
            {
                Console.WriteLine($"Ready To Print");
                return(true);
            }
            else if (printerStatus.isPaused)
            {
                throw new NotSupportedException($"Cannot Print because the printer is paused.");
            }
            else if (printerStatus.isHeadOpen)
            {
                throw new NotSupportedException($"Cannot Print because the printer head is open.");
            }
            else if (printerStatus.isPaperOut)
            {
                throw new NotSupportedException($"Cannot Print because the paper is out.");
            }
            else
            {
                throw new NotSupportedException($"Cannot Print.");
            }
            return(false);
        }
示例#20
0
 /// <summary>
 /// 라벨 프린트
 /// </summary>
 /// <param name="command">ZPL 라벨 프린트 커맨드</param>
 public static void PrintByCommand(string command)
 {
     try
     {
         if (!LabelPrint.PrinterConnectionOpen())
         {
             return;
         }
         if (Printer == null)
         {
             Printer = ZebraPrinterFactory.GetInstance(PrinterConnection);
         }
         Printer.SendCommand(command);
     }
     catch (ConnectionException ex)
     {
         MessageBox.Show("프린트 실패" + Environment.NewLine + ex.ToString(), "실패", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
 }
        private void PerformListFiles(bool isFormat)
        {
            Connection printerConnection = null;

            try {
                Application.Current.Dispatcher.Invoke(() => {
                    printerConnection = connectionSelector.GetConnection();
                });

                printerConnection.Open();
                ZebraPrinter printer = ZebraPrinterFactory.GetInstance(printerConnection);

                string[] formatExtensions;
                if (printer.PrinterControlLanguage == PrinterLanguage.ZPL)
                {
                    formatExtensions = new string[] { "ZPL" };
                }
                else
                {
                    formatExtensions = new string[] { "FMT", "LBL" };
                }

                string[] formats = isFormat ? printer.RetrieveFileNames(formatExtensions) : printer.RetrieveFileNames();

                Application.Current.Dispatcher.Invoke(() => {
                    foreach (string format in formats)
                    {
                        viewModel.FormatsList.Add(format);
                    }
                });
            } catch (ConnectionException e) {
                MessageBoxCreator.ShowError(e.Message, "Connection Error");
            } catch (ZebraIllegalArgumentException e) {
                MessageBoxCreator.ShowError(e.Message, "Connection Error");
            } catch (ZebraPrinterLanguageUnknownException e) {
                MessageBoxCreator.ShowError(e.Message, "Connection Error");
            } finally {
                if (printerConnection != null)
                {
                    printerConnection.Close();
                }
            }
        }
示例#22
0
        private void ReadSmartCard(bool sendData)
        {
            Connection connection = null;

            Task.Run(() => {
                try {
                    UpdateSmartCardOutput("");

                    Application.Current.Dispatcher.Invoke(() => {
                        connection = connectionSelector.GetConnection();
                    });

                    connection.Open();

                    ZebraPrinter printer            = ZebraPrinterFactory.GetInstance(connection);
                    SmartcardReader smartcardReader = SmartcardReaderFactory.Create(printer);
                    if (smartcardReader != null)
                    {
                        byte[] response = sendData ? smartcardReader.DoCommand("8010000008") : smartcardReader.GetATR();

                        UpdateSmartCardOutput(string.Concat(response.Select(x => x.ToString("x2"))));
                        smartcardReader.Close();
                    }
                    else
                    {
                        MessageBoxCreator.ShowError("Printer does not have a smart card reader", "Smart Card Error");
                    }
                } catch (ConnectionException e) {
                    MessageBoxCreator.ShowError(e.Message, "Connection Error");
                } catch (ZebraPrinterLanguageUnknownException e) {
                    MessageBoxCreator.ShowError(e.Message, "Connection Error");
                } finally {
                    if (connection != null)
                    {
                        try {
                            connection.Close();
                        } catch (ConnectionException) { }
                    }
                    SetButtonStates(true);
                }
            });
        }
示例#23
0
        public static bool CheckStatus(ZebraPrinter printer)
        {
            PrinterStatus printerStatus = null;

            try
            {
                VerifyConnection(printer);

                printerStatus = printer.GetCurrentStatus();
            }
            catch (ConnectionException e)
            {
                throw new NotSupportedException($"Error getting status from printer: {e.Message}");
            }

            if (null == printerStatus)
            {
                throw new NotSupportedException($"Unable to get status.");
            }
            else if (printerStatus.isReadyToPrint)
            {
                Console.WriteLine($"Ready To Print");
                return(true);
            }
            else if (printerStatus.isPaused)
            {
                throw new NotSupportedException($"Cannot Print because the printer is paused.");
            }
            else if (printerStatus.isHeadOpen)
            {
                throw new NotSupportedException($"Cannot Print because the printer head is open.");
            }
            else if (printerStatus.isPaperOut)
            {
                throw new NotSupportedException($"Cannot Print because the paper is out.");
            }
            else
            {
                throw new NotSupportedException($"Cannot Print.");
            }
            return(false);
        }
示例#24
0
        private ZebraPrinter Connect(Connection printerConn)
        {
            ZebraPrinter printer = null;

            try
            {
                printerConn.Open();
                printer = ZebraPrinterFactory.GetInstance(printerConn);
            }
            catch (ConnectionException e)
            {
                Debug.WriteLine("Connection Exception: " + e.ToString());
            }
            catch (ZebraPrinterLanguageUnknownException e)
            {
                Debug.WriteLine("PrinterLanguage Exception: " + e.ToString());
            }

            return(printer);
        }
示例#25
0
        public void Beep(int lenght)
        {
            try
            {
                printer = ZebraPrinterFactory.GetInstance(ThePrinterConn);

                PrinterStatus printerStatus = printer.GetCurrentStatus();
                bool          ready         = printerStatus.IsReadyToPrint;
                if (ready)
                {
                    String header = "! 0 200 200 0 1";
                    ThePrinterConn.Write(Encoding.UTF8.GetBytes(header + "\r\nBEEP " + lenght.ToString() + "\r\nPRINT\r\n"));
                }
            }
            catch (Exception e)
            {
                Logger.Logger.Log(e);
                return;
            }
        }
示例#26
0
        public PrinterStatus getPrinterStatus(rho.PrinterZebraImpl.PrinterZebra.EPrinterConnectionType connType, string address, Int32 port)
        {
            Logger.Write("MainWindow.getPrinterStatus call, address=" + address + " port=" + port.ToString());

            PrinterStatus          status     = null;
            ZebraPrinterConnection connection = null;
            ZebraPrinter           printer    = null;

            if (connType == rho.PrinterZebraImpl.PrinterZebra.EPrinterConnectionType.eTCP)
            {
                connection = new TcpPrinterConnection(address, port);
            }
            else if (connType == rho.PrinterZebraImpl.PrinterZebra.EPrinterConnectionType.eBluetooth)
            {
                connection = new BluetoothPrinterConnection(address);
            }
            else if (connType == rho.PrinterZebraImpl.PrinterZebra.EPrinterConnectionType.eUSB)
            {
                connection = new UsbPrinterConnection(address);
            }
            else
            {
                Logger.Write("MainWindow.getPrinterStatus undifined connection type");
                return(null);
            }

            connection.Open();

            if (connection.IsConnected())
            {
                printer = ZebraPrinterFactory.GetInstance(PrinterLanguage.ZPL, connection);

                status = printer.GetCurrentStatus();
            }

            connection.Close();

            Logger.Write("MainWindow.getPrinterStatus call finished");

            return(status);
        }
示例#27
0
        public static string LinkPrinter(string printerName, int port)
        {
            try
            {
                string ip = Printer.GetRegistryData(printerName + "\\DsSpooler", "portName");

                if (ip == "" || ip.Split(new char[] { '.' }).Length != 4)
                {
                    throw new ConnectionException("没找到IP");
                }
                foreach (string s in ip.Split(new char[] { '.' }))
                {
                    int.Parse(s);
                }

                Ping      pingSender = new Ping();
                PingReply reply      = pingSender.Send(ip, 1);           //第一个参数为ip地址,第二个参数为ping的时间
                if (reply.Status != IPStatus.Success)
                {
                    throw new ConnectionException("链接失败!");
                }

                TcpConnection connection = new TcpConnection(ip, port);
                connection.Open();
                printer = ZebraPrinterFactory.GetInstance(connection);
            }
            catch (ConnectionException e)
            {
                printer = null;
                FileTools.WriteLineFile(FileTools.exceptionFilePath, DateTime.Now.ToString() + " " + printerName + e.Message);
                return(printerName + e.Message);
            }
            catch (FormatException e)
            {
                printer = null;
                FileTools.WriteLineFile(FileTools.exceptionFilePath, DateTime.Now.ToString() + " " + printerName + "IP地址不正确!");
                return(printerName + "IP地址不正确!");
            }

            return("");
        }
示例#28
0
        /// <summary>
        /// 重启打印机
        /// </summary>
        internal void ResetPrinter()
        {
            if (TryOpenPrinterConnection())
            {
                if (printer != null)
                {
                    lock (printerHelper)
                    {
                        printer.Reset();
                        printer = null;
                    }
                    lock (connectionHelper)
                    {
                        connection = null;
                    }

                    //printer = GetPrinter();
                    myEventLog.Log.Warn("正在重置打印机状态!");
                }
            }
        }
示例#29
0
        private bool CheckPrintingStatus(ZebraPrinter printer)
        {
            PrinterStatus printerStatus = null;

            try
            {
                printerStatus = printer.GetCurrentStatus();

                while (printerStatus.numberOfFormatsInReceiveBuffer > 0 && printerStatus.isReadyToPrint)
                {
                    Thread.Sleep(100);
                    printerStatus = printer.GetCurrentStatus();
                }
            }
            catch (ConnectionException e)
            {
                Debug.WriteLine("Connection Exception: " + e.ToString());
            }

            return(printerStatus.isReadyToPrint);
        }
示例#30
0
        private string GetPrinterStatus(ZebraPrinter printer)
        {
            try
            {
                PrinterStatus printerStatus = printer.GetCurrentStatus();

                if (printerStatus.isReadyToPrint)
                {
                    return(Status.Ready);
                }
                else if (printerStatus.isPaused)
                {
                    return(Status.Paused);
                }
                else if (printerStatus.isHeadOpen)
                {
                    return(Status.HeadOpen);
                }
                else if (printerStatus.isPaperOut)
                {
                    return(Status.MediaOut);
                }
                else if (printerStatus.isRibbonOut)
                {
                    return(Status.RibbonOut);
                }
                else
                {
                    return(Status.CannotPrint);
                }
            }
            catch (ConnectionException e)
            {
                return(e.ToString());
            }
            catch (ZebraPrinterLanguageUnknownException e)
            {
                return(e.ToString());
            }
        }
示例#31
0
        public void disconnect(IMethodResult oResult)
        {
            Logger.Write("disconnect call");

            if (m_connection != null && m_connection.IsConnected())
            {
                Thread.Sleep(1000);
                m_connection.Close();
                Thread.Sleep(1000);
            }

            m_connection = null;
            m_printer = null;

            oResult.set(ZebraConstants.PRINTER_STATUS_SUCCESS);
        }
示例#32
0
        public void connectWithOptions(IReadOnlyDictionary<string, string> options, IMethodResult oResult)
        {
            Logger.Write("connectWithOptions call");
            Logger.Write("options:", options);

            string valueObj = null;
            Int32  connectionTimeout = 0;

            if (m_connection != null && m_connection.IsConnected() && m_printer != null)
            {
                m_connection.Close();

                Thread.Sleep(1000);

                m_connection = null;
                m_printer    = null;
            }

            if (options.ContainsKey(ZebraConstants.HK_TIMEOUT))
            {
                valueObj = options[ZebraConstants.HK_TIMEOUT];

                if ((valueObj != null) && (valueObj is String))
                {
                    try
                    {
                        connectionTimeout = Int32.Parse(valueObj.ToString());
                    }
                    catch (System.FormatException)
                    {
                        m_maxTimeoutForRead = 0;
                    }
                }
            }

            if (options.ContainsKey(ZebraConstants.PROPERTY_MAX_TIMEOUT_FOR_READ))
            {
                valueObj = options[ZebraConstants.PROPERTY_MAX_TIMEOUT_FOR_READ];
                
                if ((valueObj != null) && (valueObj is String))
                {
                    try
                    {
                        m_maxTimeoutForRead = Int32.Parse(valueObj.ToString());
                    }
                    catch (System.FormatException)
                    {
                        m_maxTimeoutForRead = 0;
                    }
                }
            }

            if (options.ContainsKey(ZebraConstants.PROPERTY_TIME_TO_WAIT_FOR_MORE_DATA))
            {
                valueObj = options[ZebraConstants.PROPERTY_TIME_TO_WAIT_FOR_MORE_DATA];

                if ((valueObj != null) && (valueObj is String))
                {
                    try
                    {
                        m_timeToWaitForMoreData = Int32.Parse(valueObj.ToString());
                    }
                    catch (System.FormatException)
                    {
                        m_maxTimeoutForRead = 0;
                    }
                }
            }
            
            ConnecttionJob job = new ConnecttionJob();

            job.Address               = ID;
            job.Port                  = Port;
            job.ConnectionType        = connectionType;
            job.MaxTimeoutForRead     = m_maxTimeoutForRead;
            job.TimeToWaitForMoreData = m_timeToWaitForMoreData;

            if (connectionTimeout == 0)
            {
                job.Connect();
            }
            else
            {
                if (!job.Connect(connectionTimeout))
                {
                    oResult.set(ZebraConstants.PRINTER_STATUS_ERR_TIMEOUT);
                    return;
                }
            }
            
            if (job.Connection != null && job.Printer != null)
            {
                m_connection = job.Connection;
                m_printer    = job.Printer;

                oResult.set(ZebraConstants.PRINTER_STATUS_SUCCESS);
                return;
            }

            oResult.set(ZebraConstants.PRINTER_STATUS_ERR_NOT_CONNECTED);
        }