Von einer Website / Webanwendung auf einen Etikettendrucker drucken?

Wow. Ich weiß, das war fragte vor 4 Jahren, aber verbrannte den größten Teil der Woche auf der Suche nach einer robusten Methode zum drucken von Etiketten aus einer web-app, musste ich Stimme hier.

Hier ist, was ich gefunden habe:

• DYMO scheint der wahrscheinlichste Kandidat für excellence. Aber Nein, stellt sich heraus, es druckt nur von (einer) seiner eigenen app, oder (b) etwas mit dem SDK. Das DYMO-SDK verwendet eine XML-Zeichnung-Modell, das sowohl zu Komplex und zu begrenzt in layout und styling. Die Dokumentation ist verstreut und unverständlich (z.B. was sind die <Bounds> Werte für das gemeinsame label Größen? Es gibt keine Beschreibung der tag-Parameter überall!) So frustrierend, so enttäuschend.

• Gibt es qz (wurde jzebra)die es ermöglicht, browser drucken für Geräte, die sprechen, EPL, ZPL, FGL, ESC/POS, EPCL und CPCL ... die gehören der Zebra-Serie. Es benötigt eine Last von integration (ein web-server läuft auf dem Gerät das Etikett Drucker angeschlossen ist), aber es funktioniert.

• Gibt es eine gut gestaltete 3rd-party-app von HalbinselWerke, die für DYMO (unter anderem), erfordert aber eine Mitte-Schritt des Druckens von browser zu PDF. Sie gehen auch davon werden Sie nicht skaliert werden, was Sie wollen gedruckt auf weniger als 70%, was falsch ist.

Der OP sagt "ich würde denken, dass, schließlich, es müsste eine Lösung sein, wie wir uns bewegen, mehr in die browser-zentrische Welt." Vier Jahre später, würde ich einen Schritt weiter gehen und vorschlagen, label-Drucker, der nicht drucken aus einem browser (oder einfach nur Verhalten wie ein normaler Drucker mit kleinen Papier) fällt weit hinter seinem potential zurück. Layout in HTML+CSS ist ein Kinderspiel. Browser analysieren es perfekt, und machen es bei jeder Auflösung auf jedem Gerät ausgegeben werden. Es scheint so offensichtlich.

Wenn jemand weiß, einen Thermodrucker, der Ausdrucke aus dem browser anstatt zu inhaftieren Sie in archaischen integration Methoden, ich würde sehr gerne wissen!

InformationsquelleAutor der Antwort neokio

Könnten Sie auch versuchen, auf der Suche PrintNodedie eine cloud-printing-Lösung und bedeutet, dass Sie drucken können direkt auf jedem Drucker über das internet.

InformationsquelleAutor der Antwort user1912424

Zebra hat jetzt ein tool namens 'BrowserPrint', das funktioniert wie PrintNode, die speziell für Zebra-Drucker. (im Gegensatz zu Printnode, es ist kostenlos für die Verwendung mit Zebra-Druckern)

Einige Drucker haben auch ppd-Dateien verfügbar sind und/oder konfiguriert werden können, in den Tassen, die auf einer linux-Plattform-system oder sonstwie gesprochen und auch über linux. (was dann bedeutet, es ist nicht unmöglich mit etwas shell-scripting, php, perl oder anderen Methoden zu drucken, um es durch den Bau eines einfachen server-Dämon oder der Einrichtung so etwas wie apache oder lighttpd auf einem linux-Rechner oder auch ein raspberry pi mit dem Drucker verbunden)

InformationsquelleAutor der Antwort Scott

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 erstellt in C# und es Super geklappt. Dies ist eine web-app.

InformationsquelleAutor der Antwort Tommy Graffam