Imprimer sur une imprimante d'étiquettes à partir d'un site web / de l'application web?

Wow. Je sais que cela a été demandé il y a plus de 4 ans, mais ayant brûlé la majeure partie de la semaine à la recherche d'une méthode robuste d'impression des étiquettes à partir d'une application web, j'ai dû m'exprimer ici.

Voici ce que j'ai trouvé:

• DYMO semble le candidat le plus probable pour l'excellence. Mais non, il s'avère qu'il n'imprime que depuis (a) sa propre application, ou (B) quelque chose utilisant son SDK. Le SDK DYMO utilise un modèle de dessin XML qui est à la fois excessivement complexe et limité dans la style. La documentation est dispersée et incompréhensible (par exemple, qu'est-ce que le <Bounds> valeurs pour les tailles d'étiquette communes? Il n'y a aucune description des paramètres de l'étiquette nulle part!) Donc frustrant, donc décevant.

• Il y a qz (a jzebra), qui permet l'impression par navigateur pour les appareils qui parlent EPL, ZPL, FGL, ESC/POS, EPCL et CPCL ... qui inclut la série Zebra. Il nécessite une charge d'intégration (exécution d'un serveur web sur l'imprimante d'étiquette est attachée à), mais il fonctionne.

• Il y a bien conçue 3ème partie application par Péninsule, qui fonctionne pour DYMO (entre autres), mais nécessite une étape intermédiaire de l'impression du navigateur au PDF. Ils supposent aussi que vous ne réduirez jamais la taille de ce que vous voulez imprimer de moins de 70%, ce qui est incorrect.

L'OP dit "je pense que, éventuellement, il devrait y avoir une solution que nous passons à un monde plus centré sur le navigateur."Quatre ans plus tard, j'irais un peu plus loin et je suggérerais que toute imprimante d'étiquettes qui ne peut pas imprimer un navigateur (ou qui se comporte simplement comme une imprimante ordinaire avec un petit papier) est loin de son potentiel. Layout en HTML+CSS est un snap. Les navigateurs l'analysent parfaitement, et le rendent à n'importe quelle résolution à n'importe quel périphérique de sortie. Cela semble tellement évident.

si quelqu'un connaît une imprimante d'étiquettes thermiques qui imprime à partir du navigateur au lieu de vous emprisonner dans l'archaïque l'intégration des méthodologies, j'aimerais bien que savoir!

les imprimantes Dymo ont un plugin de navigateur qui vous permet d'imprimer à partir de javascript. Très facile à utiliser.

revisiter cette question quelques années plus tard.

les imprimantes Zebra en réseau sont faciles à imprimer. Dans un projet, j'ai fait ouvrir une socket à l'imprimante par la webapplication et j'ai transmis les instructions dans ZPL.

Vous pouvez aussi essayer la recherche PrintNode qui fournissent une solution d'impression en nuage et vous permettent d'imprimer directement à n'importe quelle imprimante sur internet.

un script de page Web compatible avec un navigateur ou une plate-forme n'a pas l'accès de bas niveau nécessaire pour transmettre la commande de langue d'impression (comme Zebra Printer Language [ZPL]) à l'imprimante. Pour ce faire, un contrôle ActiveX/plugin de navigateur/applet/bit similaire de code exécutable est nécessaire. Cette limitation n'est pas spécifique à l'imprimante, elle provient du navigateur et non du fabricant de l'imprimante.

cependant, de nombreuses imprimantes d'étiquettes vous permettent de les imprimer comme si elles étaient des imprimantes normales--juste celles qui impriment sur de très petits morceaux de papier. Vous pouvez mettre en page votre étiquette en utilisant HTML/CSS. Lorsque vous affichez les résultats, demandez à l'utilisateur d'aller dans "Fichier > Imprimer" et de sélectionner son imprimante d'étiquettes avant de cliquer sur Imprimer.

j'Espère que cette aide,

Ben

Zebra a maintenant un outil appelé 'BrowserPrint' qui fonctionne comme PrintNode spécifiquement pour les imprimantes Zebra. (contrairement à Printnode, il est libre d'utiliser avec des imprimantes Zebra)

certaines imprimantes ont également des fichiers ppd disponibles et / ou peuvent être configurés dans cups sur une plate-forme linux ou autrement connectés et parlés aussi via linux. (ce qui signifie Alors qu'il n'est pas impossible d'utiliser quelque chose de shell scripting, php, perl ou d'autres méthodes pour imprimer en construisant un simple démon de serveur ou configurer quelque chose comme apache ou lighttpd sur une machine linux ou même un raspberry pi connecté à l'imprimante)

vous pouvez imprimer à partir D'un applet Java signé, ou à partir d'un Java Web Start application:

http://java.sun.com/javase/technologies/desktop/printing/

cela devrait fonctionner, si vous formatez votre sortie d'impression afin qu'il s'adapte sur les étiquettes.

notez que la plupart des navigateurs modernes restreignent la prise en charge des applets Java, de sorte que vous pouvez rencontrer des problèmes avec un applet, selon les navigateurs utilisés. En particulier, Google Chrome sera arrêter de soutenir des applets Java en septembre 2015. Ces restrictions ont pour effet:--13--> appliquer à Java Web Start, qui devrait continuer à travailler.

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;
    }
}

C'est ce que j'ai créé en C# et ça a bien marché. Ce est une application web.