wake-up-neo.net

Von einer Website/Webanwendung auf einem Etikettendrucker drucken?

Gibt es bekannte Etikettendrucker, die Druckbefehle von einer Website oder einer Webanwendung akzeptieren?

Insbesondere die Einzeletikettendrucker wie Dymo, Brother, Zebra usw.

Hat jemand Erfolg beim Drucken auf diesen Druckern gehabt (ohne einen Internet Explorer-Only-Hack oder ein ActiveX-Steuerelement zu verwenden)?

Ich würde denken, dass es irgendwann eine Lösung geben muss, wenn wir in eine browserzentriertere Welt vordringen.

31
toddb

Beeindruckend. Ich weiß, dass dies vor über 4 Jahren gefragt wurde, aber nachdem ich die meiste Zeit auf der Suche nach einer robusten Methode zum Drucken von Etiketten aus einer Web-App verbrannt hatte, musste ich mich hier äußern.

Folgendes habe ich gefunden:

  • DYMO scheint der wahrscheinlichste Kandidat für hervorragende Leistungen zu sein. Aber nein, es stellt sich heraus, dass nur von (a) einer eigenen App oder (b) etwas mit dem SDK gedruckt wird. Das DYMO-SDK verwendet ein XML-Zeichnungsmodell, das sowohl zu komplex als auch in Layout und Stil begrenzt ist. Die Dokumentation ist verstreut und unverständlich (z. B. sind dies die <Bounds>-Werte für die gängigen Etikettengrößen? Es gibt keine Beschreibung der Tag-Parameter an einer beliebigen Stelle!).

  • Es gibt qz (war jzebra) , das den Browserdruck für Geräte ermöglicht, die EPL, ZPL, FGL, ESC/POS, EPCL und CPCL ... mit der Zebra-Serie sprechen. Es erfordert eine gewisse Integration (Ausführen eines Webservers auf dem Gerät, an das der Etikettendrucker angeschlossen ist), funktioniert jedoch.

  • Es gibt eine gut entworfene 3rd Party-App von Peninsula , die unter anderem für DYMO funktioniert, aber einen mittleren Druckschritt vom Browser bis zum PDF erfordert. Sie gehen auch davon aus, dass Sie das, was Sie drucken möchten, nie unter 70% verkleinern möchten, was falsch ist.

Das OP sagt: "Ich würde denken, dass es irgendwann eine Lösung geben muss, wenn wir uns in eine Browserorientiertere Welt bewegen." Vier Jahre später würde ich noch einen Schritt weiter gehen und vorschlagen, dass jeder Etikettendrucker, der nicht von einem Browser aus drucken kann (oder sich nur wie ein normaler Drucker mit kleinem Papier verhält), sein Potenzial verfehlt. Das Layout in HTML + CSS ist ein Kinderspiel. Browser parsen es perfekt und rendern es mit einer beliebigen Auflösung für jedes Ausgabegerät. Es scheint so offensichtlich zu sein.

Wenn jemand einen Thermoetikettendrucker kennt, der vom Browser aus druckt, anstatt Sie in archaische Integrationsmethoden einzusperren, würde ich das sehr gerne wissen!

28
neokio

Die Dymo-Drucker verfügen über ein Browser-Plugin, mit dem Sie von javascript aus drucken können. Sehr einfach zu bedienen.

Wiederholen Sie diese Frage einige Jahre später.

Die vernetzten Zebra-Drucker sind einfach zu bedrucken. In einem Projekt hatte ich die Webapplikation einen Socket zum Drucker geöffnet und ihm Anweisungen in ZPL zugeführt. 

9
NA.

Sie können auch versuchen, PrintNode zu suchen, um eine Cloud-Drucklösung bereitzustellen, und Sie können direkt über das Internet auf jeden Drucker drucken.

6
user1912424

Ein browser-/plattformkompatibles Webseiten-/Webseiten-Skript verfügt nicht über den erforderlichen Zugriff, um einen Druckersprachenbefehl (wie Zebra Printer Language [ZPL]) an den Drucker zu übertragen. Dazu ist ein ActiveX-Steuerelement/Browser-Plugin/Applet/ein ähnliches Bit ausführbaren Codes erforderlich. Diese Einschränkung ist nicht druckerspezifisch und stammt vom Browser und nicht vom Druckerhersteller.

Bei vielen Etikettendruckern können Sie jedoch wie normale Drucker drucken - nur Drucker, die auf sehr kleine Papierstücke drucken. Sie können Ihr Etikett mit HTML/CSS gestalten. Weisen Sie den Benutzer beim Anzeigen der Ergebnisse an, "Datei> Drucken" zu wählen und den Etikettendrucker auszuwählen, bevor Sie auf Drucken klicken. 

Hoffe das hilft,
Ben

4
Ben Gribaudo

Zebra verfügt jetzt über ein Tool namens 'BrowserPrint', das wie PrintNode speziell für Zebra-Drucker funktioniert. (Im Gegensatz zu Printnode ist die Verwendung mit Zebra-Druckern kostenlos.)

Einige Drucker verfügen auch über ppd-Dateien und/oder können in Cups auf einem Linux-Plattformsystem konfiguriert oder anderweitig über Linux verbunden und auch gesprochen werden. (was bedeutet, dass es nicht unmöglich ist, etwas von Shell - Scripting, PHP, Perl oder anderen Methoden zu verwenden, um darauf zu drucken, indem Sie einen einfachen Server - Daemon erstellen oder etwas wie Apache oder lighttpd auf einer Linux - Box oder sogar ein mit dem Drucker)

2
Scott

Sie können von einem signierten Java-Applet oder von einer Anwendung { Java Web Start aus drucken:

http://Java.Sun.com/javase/technologies/desktop/printing/

Das sollte funktionieren, wenn Sie Ihre Druckausgabe so formatieren, dass sie auf die Etiketten passt.

Beachten Sie, dass die meisten modernen Browser die Unterstützung für Java-Applets einschränken. In Abhängigkeit von den verwendeten Browsern können Probleme mit einem Applet auftreten. Insbesondere wird Google Chrome keine Java-Applets im September 2015 mehr unterstützen . Diese Einschränkungen gelten für Java Web Start nicht , das weiterhin funktionieren sollte.

0
sleske
using System;
using System.Collections.Generic;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Drawing;
using System.Drawing.Printing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;
using System.Management;
using System.Reflection;

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {

        GetAllPrinterList();
        this.textBox1.Attributes.Add(
    "onkeypress", "button_click(this,'" + this.Button1.ClientID + "')");
        this.lstPrinterList.Attributes.Add(
    "onkeypress", "button_click(this,'" + this.Button1.ClientID + "')");

    }

    private void GetAllPrinterList()
    {
        //ManagementScope objScope = new ManagementScope(ManagementPath.DefaultPath); //For the local Access
        //objScope.Connect();

        //SelectQuery selectQuery = new SelectQuery();
        //selectQuery.QueryString = "Select * from win32_Printer";
        //ManagementObjectSearcher MOS = new ManagementObjectSearcher(objScope, selectQuery);
        //ManagementObjectCollection MOC = MOS.Get();
        //foreach (ManagementObject mo in MOC)
        //{
        //    lstPrinterList.Items.Add(mo["Name"].ToString());
        //    //lstPrinterList.Items.Add(new ListItem(mo["Name"].ToString()));

        //}

        lstPrinterList.Items.Add("\\\\10.32.65.6\\Parcel-Zebra-FDX ZM400");
        lstPrinterList.Items.Add("\\\\10.32.65.4\\Singles_Station_Z_Printer");
        lstPrinterList.Items.Add("\\\\10.32.65.12\\ZebraZ4M-Packaging");
        if (lstPrinterList.Items.Count > 3)
        {
        lstPrinterList.Items.RemoveAt(5);
        lstPrinterList.Items.RemoveAt(4);
        lstPrinterList.Items.RemoveAt(3);

        }

        //LocalPrintServer printServer = new LocalPrintServer();
        //string printer;
        //printer = LocalPrintServer.DefaultPrintQueue;
        //System.Management.ObjectQuery oquery =
        //        new System.Management.ObjectQuery("SELECT * FROM Win32_Printer");

        //    System.Management.ManagementObjectSearcher mosearcher =
        //        new System.Management.ManagementObjectSearcher(oquery);

        //    System.Management.ManagementObjectCollection moc = mosearcher.Get();

        //    foreach (ManagementObject mo in moc)
        //    {
        //        System.Management.PropertyDataCollection pdc = mo.Properties;
        //        foreach (System.Management.PropertyData pd in pdc)
        //        {
        //           // if ((bool)mo["Network"])
        //           // {
        //                lstPrinterList.Items.Add(mo["Name"].ToString());
        //           // }
        //        }
        //    }

        //}
        //        using (var printServer = new PrintServer(string.Format(@"\\{0}", PrinterServerName)))
        //{
        //    foreach (var queue in printServer.GetPrintQueues())
        //    {
        //        if (!queue.IsShared)
        //        {
        //            continue;
        //        }
        //        Debug.WriteLine(queue.Name);
        //     }
        // }
        //foreach (string printer in System.Drawing.Printing.PrinterSettings.InstalledPrinters)
        //{
        //MessageBox.Show(printer);
        //System.Web.UI.WebControls.ListBox lstPrinterList = new System.Web.UI.WebControls.ListBox();
        //System.Web.UI.WebControls.ListBox lstPrinterList = (System.Web.UI.WebControls.ListBox)Page.FindControl("lstPrinterList");
        //lstPrinterList.Text = "Zebra 110PAX4 (203 ;dpi)";

        //lstPrinterList.Items.Add(printer.ToString());
        //lstPrinterList.Items.Add(new ListItem(printer));
        //lstPrinterList.Items.Add(printer);
        //System.Web.UI.WebControls.ListBox lstPrinterList = (System.Web.UI.WebControls.ListBox)Page.FindControl("ListBox1");
        //Zebra 110PAX4 (203 dpi)
        //lstPrinterList.Items.Insert(printer);
        //}
    }


    //private void lstPrinterList_OnClick(object sender, System.EventArgs e)
    //{
    //    // Get the currently selected item in the ListBox.
    //    string curItem = lstPrinterList.SelectedItem.ToString();

    //    // Find the string in ListBox2.
    //    int index = lstPrinterList.DataTextField(curItem);
    //    //int index = lstPrinterList.FindString(curItem);
    //    //lstPrinterList.DataTextField(curItem);
    //    // If the item was not found in ListBox 2 display a message box, otherwise select it in ListBox2.
    //    if (index == -1)
    //        MessageBox.Show("Item is not available in ListBox2");
    //    else
    //        lstPrinterList.SetSelected(index, true);
    //}

    //private void button1_Click(object sender, System.EventArgs e)
    //{

    //    string str = File.ReadAllText("lpn.prn");
    //    str = str.Replace("BOX_TYPE", "boom");
    //    str = str.Replace("11111111", textBox1.Text);
    //    File.WriteAllText("lpn.prn", str);
    //            // Print the file to the printer.
    // RawPrinterHelper.SendFileToPrinter("\\\\Zebra-FDX ZM400 200 dpi (ZPL)", "C:\\Users\\Administrator\\Documents\\Visual Studio 2015\\Projects\\WindowsFormsApplication4\\Prn Print\\bin\\Debug\\lpn.prn");  
    //}

    public void button1_Click(object sender, System.EventArgs e)
    {
        String prnFile = "lpn2.prn";
        string s = File.ReadAllText(prnFile);
        string printer;
        String Printer = lstPrinterList.SelectedItem.ToString();
        s = s.Replace("*description*", "snuffles");
        s = s.Replace("*barcode*", textBox1.Text);
        //File.WriteAllText("PPlpn.prn", s);
        //s = "^XA^LH30,30\n^FO20,10^ADN,90,50^AD^FDHello World^FS\n^XZ";
        printer = lstPrinterList.SelectedItem.Value;
        PrintDialog pd = new PrintDialog();
        pd.PrinterSettings = new PrinterSettings();
        RawPrinterHelper.SendStringToPrinter(printer, s); 
        //RawPrinterHelper.SendStringToPrinter(Printer, s);
        //Response.Redirect(Request.RawUrl.Replace(Request.Url.Query, "?__VIEWSTATE=%2%3D&ctl00%24MainContent%24textBox1=bp300&ctl00%24MainContent%24lstPrinterList=Shipping+Printer"));




    }
    protected void textBox1_TextChanged(object sender, EventArgs e)
    {

    }
}




public class RawPrinterHelper
{
    // Structure and API declarions:
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public class DOCINFOA
    {
        [MarshalAs(UnmanagedType.LPStr)]
        public string pDocName;
        [MarshalAs(UnmanagedType.LPStr)]
        public string pOutputFile;
        [MarshalAs(UnmanagedType.LPStr)]
        public string pDataType;
    }
    [DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string szPrinter, out IntPtr hPrinter, IntPtr pd);

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

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

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

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

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

    [DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, out Int32 dwWritten);

    // SendBytesToPrinter()
    // When the function is given a printer name and an unmanaged array
    // of bytes, the function sends those bytes to the print queue.
    // Returns true on success, false on failure.
    public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)
    {
        Int32 dwError = 0, dwWritten = 0;
        IntPtr hPrinter = new IntPtr(0);
        DOCINFOA di = new DOCINFOA();
        bool bSuccess = false; // Assume failure unless you specifically succeed.
        di.pDocName = "My C#.NET RAW Document";
        di.pDataType = "RAW";

        // Open the printer.
        if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
        {
            // Start a document.
            if (StartDocPrinter(hPrinter, 1, di))
            {
                // Start a page.
                if (StartPagePrinter(hPrinter))
                {
                    // Write your bytes.
                    bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                    EndPagePrinter(hPrinter);
                }
                EndDocPrinter(hPrinter);
            }
            ClosePrinter(hPrinter);
        }
        // If you did not succeed, GetLastError may give more information
        // about why not.
        if (bSuccess == false)
        {
            dwError = Marshal.GetLastWin32Error();
        }
        return bSuccess;
    }

    public static bool SendFileToPrinter(string szPrinterName, string szFileName)
    {
        // Open the file.
        FileStream fs = new FileStream(szFileName, 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(szPrinterName, pUnmanagedBytes, nLength);
        // Free the unmanaged memory that you allocated earlier.
        Marshal.FreeCoTaskMem(pUnmanagedBytes);
        return bSuccess;
    }

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

Dies ist, was ich in C # erstellt habe und es hat super geklappt. Dies ist eine Web-App.

0
Tommy Graffam