Imprimer des codes à barres d'une page Web vers une imprimante Zebra
Nous essayons d’imprimer des codes à barres d’une page Web sur notre imprimante Zebra.
Je me demande s’il est possible de les imprimer à l’aide de la police de l’imprimante, en utilisant des polices Web ou si je connaissais le nom de la police utilisée?
J'ai essayé d'utiliser des générateurs de codes à barres php, qui génèrent essentiellement des images contenant le code à barres. En fait, cela fait déjà quelques jours que j'essaie cette approche, sans succès.
Le problème, c'est que lorsque je les imprime, les scanners ne les lisent pas. J'ai essayé de modifier la résolution de l'image pour qu'elle corresponde à celle de l'imprimante (203 ppp), mais j'ai également essayé de lire la taille et les formats de l'image, mais les codes à barres après l'impression ne peuvent toujours pas être numérisés.
Alors, est-ce que quelqu'un a de l'expérience avec ça?
Imprimante: Zebra TLP 2844
Codes à barres requis par page:
- 01 Code39 horizontal (numérisable uniquement si imprimé avec une taille et un navigateur très spécifiques)
- 01 Code128 vertical (cela ne fonctionne toujours pas, les impressions sont toujours très floues et ne sont pas numérisées)
===========
J'ai un peu progressé. J'ai découvert que cette imprimante prend en charge le langage EPL2. J'essaie donc de l'utiliser pour imprimer les codes à barres.
Avant tout, je devais activer le mode de passage, je l’ai fait dans Options d’impression> Configuration avancée> Divers.
Maintenant, je peux imprimer des codes à barres de manière impeccable en utilisant la police intégrée de l'imprimante: D en utilisant cette commande:
ZPL: B10,10,0,1,2,2,60, N, "TEXT-GOES-HERE" : ZPL
Mais je ne peux l’imprimer que depuis le Bloc-notes, mais je ne parviens toujours pas à l’afficher à partir d’un navigateur. C’est probablement un problème de remplacement de LF par CR + LF ...
Comment surmonter ce problème??
===========
L'étiquette que j'essaie d'imprimer comporte en fait un peu de texte avant le code à barres, avec quelques tableaux html le formatant bien. Il faut donc que je l’imprime d’abord, puis que je place au milieu une étiquette Nice, puis que j’ajoute du texte.
Donc, je ne peux pas utiliser EPL2 pur pour imprimer le tout, je me demande si je peux utiliser certains des deux html + EPL2 + html pour atteindre mon objectif ou est-ce que cela n'est pas autorisé? = /
Vous rencontrez quelques obstacles:
1) Lorsque vous imprimez via le pilote d’imprimante installé dans le système d’exploitation, le pilote d’imprimante tente de récupérer les données qui lui sont envoyées et de les (re) rasteriser ou de les redimensionner pour le périphérique de sortie (l’imprimante Zebra). Étant donné que l’imprimante a une résolution relativement basse à 203 dpi, il ne faut pas trop pour que la mise à l’échelle du pilote d’impression doive le faire pour perdre de l’intégrité dans la qualité du code à barres. C'est pourquoi les codes à barres générés à l'aide des commandes directes ZPL sont beaucoup plus fiables.
2) En raison de la sécurité que les navigateurs Web fournissent à bon escient en ne permettant pas l'accès à l'ordinateur client, vous ne pouvez pas communiquer directement avec l'imprimante connectée au client. Ce sandboxing aide à protéger les utilisateurs contre les logiciels malveillants afin que les sites Web néfastes ne puissent pas écrire des fichiers sur la machine cliente ni envoyer la sortie directement à des périphériques tels que des imprimantes. Par conséquent, vous ne pouvez pas envoyer directement les commandes ZPL par l’intermédiaire du navigateur à l’imprimante connectée au client.
Cependant, il existe un moyen de faire ce que vous décrivez. Les étapes nécessaires ne seront généralement utiles que si vous avez un certain degré de contrôle sur l'ordinateur client accédant au site qui tente d'imprimer sur les imprimantes Zebra. Par exemple, il ne sera utilisé que par des machines du réseau de votre entreprise ou par des clients souhaitant installer une petite application que vous devez écrire. Pour ce faire, vous devrez suivre les étapes suivantes:
A) Vous devez créer votre propre type MIME personnalisé. Il s’agit essentiellement de tout nom que vous souhaitez utiliser et qui ne se heurtera pas aux types MIME enregistrés .
B) Vous allez ensuite définir une extension de nom de fichier qui mappera votre type MIME personnalisé. Pour ce faire, vous devrez généralement configurer votre serveur Web (la procédure à suivre dépend du serveur Web que vous utilisez) pour autoriser le nouveau type MIME que vous souhaitez définir et quelle extension de fichier est utilisée pour ces types de fichiers.
C) Ensuite, sur votre application Web, lorsque vous souhaitez générer les données ZPL, vous les écrivez dans un fichier utilisant une extension de nom de fichier mappée sur votre nouveau type MIME. Ensuite, une fois le fichier généré, vous pouvez lui fournir un lien HTML ou rediriger le navigateur client vers le fichier. Vous pouvez vérifier si votre fichier fonctionne correctement à ce stade en le copiant manuellement sur le port d’imprimante brut.
D) Ensuite, vous devez écrire une petite application qui peut être installée sur le client. Lorsque l'application est installée, vous devez la faire enregistrer en tant qu'application consommatrice valide pour votre type MIME personnalisé. Si un navigateur détecte qu’une application est installée pour un fichier du type MIME spécifié, il écrit simplement le fichier dans un répertoire temporaire sur la machine cliente, puis tente de lancer l’application du même type MIME enregistré avec le fichier temporaire en tant que un paramètre à l'application. Ainsi, votre application ne lit plus que le fichier que le navigateur lui a transmis et tente ensuite de le transférer directement sur l’imprimante.
Ceci est un aperçu de ce que vous devez faire pour accomplir ce que vous décrivez. Certaines étapes spécifiques dépendront du type de serveur Web que vous utilisez et du système d'exploitation de vos ordinateurs clients. Mais c’est l’aperçu de haut niveau qui vous permettra d’accomplir ce que vous tentez.
Si vous envisagez de charger une applet Java, qz-print (anciennement jzebra) peut faire exactement ce que vous décrivez et fonctionne parfaitement avec le LP2844 mentionné dans les commentaires.
Ce que nous avons fait pour notre application Web:
1) Téléchargez l’application printfile gratuite http://www.lerup.com/printfile/
"PrintFile est un utilitaire gratuit MS Windows qui vous permettra d’imprimer facilement et rapidement des fichiers. Le programme reconnaît les formats texte, PostScript, Encapsulated PostScript (EPS) et binaires. Ce programme vous permet d’économiser beaucoup de papier économiser les ressources naturelles précieuses ".
Lorsque vous exécutez PrintFile pour la première fois, accédez aux options avancées et activez «Envoyer directement à l’imprimante».
2) Configurez l’imprimante ZEBRA dans Windows en tant qu’imprimante de texte générique.
2) Générez un fichier file.prt dans l’application Web, qui est simplement un fichier EPL en texte brut.
3) Double-cliquez sur le fichier téléchargé pour imprimer instantanément le code à barres. Fonctionne comme un charme. Vous pouvez même configurer PrintFile pour que vous ne voyiez même pas une interface graphique.
Je développe quelque chose de similaire ici .. Je dois imprimer dans un LP2844 à partir de mon application Web. Le problème est que mon application Web se trouve sur un serveur distant dans le cloud (Amazon EC2) et que l'imprimante va se trouver sur un bureau d'entrepôt.
Ma solution: La webapp génère le code EPL2 pour l’étiquette avec les codes à barres, puis publie un message PubNub . J'ai écrit un petit programme C # qui s'exécute sur l'ordinateur auquel l'imprimante est connectée. Le programme reçoit le message, puis envoie le code à l'imprimante.
Vous pouvez également envoyer les commandes ZPL dans un fichier texte (vous pouvez regrouper plusieurs étiquettes dans un seul fichier) et demander à l'utilisateur d'ouvrir et d'imprimer le fichier via le bloc-notes Windows. Le seul inconvénient est qu'ils doivent supprimer l'en-tête et le pied de page par défaut (Fichier -> Mise en page).
C'est un peu de formation utilisateur, mais peut être acceptable si vous n'avez pas le contrôle sur les ordinateurs clients.
J'ai suivi l'idée proposée par "Tres Finocchiaro" dans ma candidature, basée sur:
- ASP.NET 4.0
- IIS
- Chrome, IExplorer, Firefox
- Zebra TLP 2844
- Protocole EPL
Malheureusement, le jzebra nécessite quelques améliorations pour fonctionner correctement en raison des problèmes de sécurité du navigateur actuel.
Installation de jzebra
Téléchargez le répertoire et le répertoire dist que je copie dans votre répertoire (par exemple, mydir):
- web
- mondir
- js
- ..
- deployJava.js
- lib
- ..
- qz-print.jar
- qz-print_jnlp.jnlp
- js
- mondir
Créez votre print.html
<html>
<script type="text/javascript" src="js/deployJava.js"></script>
<script type="text/javascript">
/**
* Optionally used to deploy multiple versions of the applet for mixed
* environments. Oracle uses document.write(), which puts the applet at the
* top of the page, bumping all HTML content down.
*/
deployQZ();
/** NEW FUNCTION **/
function initPrinter() {
findPrinters();
useDefaultPrinter();
}
/** NEW FUNCTION **/
function myalert(txt) {
alert(txt);
}
/**
* Deploys different versions of the applet depending on Java version.
* Useful for removing warning dialogs for Java 6. This function is optional
* however, if used, should replace the <applet> method. Needed to address
* MANIFEST.MF TrustedLibrary=true discrepency between JRE6 and JRE7.
*/
function deployQZ() {
var attributes = {id: "qz", code:'qz.PrintApplet.class',
archive:'qz-print.jar', width:1, height:1};
var parameters = {jnlp_href: 'qz-print_jnlp.jnlp',
cache_option:'plugin', disable_logging:'false',
initial_focus:'false'};
if (deployJava.versionCheck("1.7+") == true) {}
else if (deployJava.versionCheck("1.6+") == true) {
delete parameters['jnlp_href'];
}
deployJava.runApplet(attributes, parameters, '1.5');
}
/**
* Automatically gets called when applet has loaded.
*/
function qzReady() {
// Setup our global qz object
window["qz"] = document.getElementById('qz');
var title = document.getElementById("title");
if (qz) {
try {
title.innerHTML = title.innerHTML + " " + qz.getVersion();
document.getElementById("content").style.background = "#F0F0F0";
} catch(err) { // LiveConnect error, display a detailed meesage
document.getElementById("content").style.background = "#F5A9A9";
alert("ERROR: \nThe applet did not load correctly. Communication to the " +
"applet has failed, likely caused by Java Security Settings. \n\n" +
"CAUSE: \nJava 7 update 25 and higher block LiveConnect calls " +
"once Oracle has marked that version as outdated, which " +
"is likely the cause. \n\nSOLUTION: \n 1. Update Java to the latest " +
"Java version \n (or)\n 2. Lower the security " +
"settings from the Java Control Panel.");
}
}
}
/**
* Returns whether or not the applet is not ready to print.
* Displays an alert if not ready.
*/
function notReady() {
// If applet is not loaded, display an error
if (!isLoaded()) {
return true;
}
// If a printer hasn't been selected, display a message.
else if (!qz.getPrinter()) {
/** CALL TO NEW FUNCTION **/
initPrinter();
return false;
}
return false;
}
/**
* Returns is the applet is not loaded properly
*/
function isLoaded() {
if (!qz) {
alert('Error:\n\n\tPrint plugin is NOT loaded!');
return false;
} else {
try {
if (!qz.isActive()) {
alert('Error:\n\n\tPrint plugin is loaded but NOT active!');
return false;
}
} catch (err) {
alert('Error:\n\n\tPrint plugin is NOT loaded properly!');
return false;
}
}
return true;
}
/**
* Automatically gets called when "qz.print()" is finished.
*/
function qzDonePrinting() {
// Alert error, if any
if (qz.getException()) {
alert('Error printing:\n\n\t' + qz.getException().getLocalizedMessage());
qz.clearException();
return;
}
// Alert success message
alert('Successfully sent print data to "' + qz.getPrinter() + '" queue.');
}
/***************************************************************************
* Prototype function for finding the "default printer" on the system
* Usage:
* qz.findPrinter();
* window['qzDoneFinding'] = function() { alert(qz.getPrinter()); };
***************************************************************************/
function useDefaultPrinter() {
if (isLoaded()) {
// Searches for default printer
qz.findPrinter();
// Automatically gets called when "qz.findPrinter()" is finished.
window['qzDoneFinding'] = function() {
// Alert the printer name to user
var printer = qz.getPrinter();
myalert(printer !== null ? 'Default printer found: "' + printer + '"':
'Default printer ' + 'not found');
// Remove reference to this function
window['qzDoneFinding'] = null;
};
}
}
/***************************************************************************
* Prototype function for finding the closest match to a printer name.
* Usage:
* qz.findPrinter('zebra');
* window['qzDoneFinding'] = function() { alert(qz.getPrinter()); };
***************************************************************************/
function findPrinter(name) {
// Get printer name from input box
var p = document.getElementById('printer');
if (name) {
p.value = name;
}
if (isLoaded()) {
// Searches for locally installed printer with specified name
qz.findPrinter(p.value);
// Automatically gets called when "qz.findPrinter()" is finished.
window['qzDoneFinding'] = function() {
var p = document.getElementById('printer');
var printer = qz.getPrinter();
// Alert the printer name to user
alert(printer !== null ? 'Printer found: "' + printer +
'" after searching for "' + p.value + '"' : 'Printer "' +
p.value + '" not found.');
// Remove reference to this function
window['qzDoneFinding'] = null;
};
}
}
/***************************************************************************
* Prototype function for listing all printers attached to the system
* Usage:
* qz.findPrinter('\\{dummy_text\\}');
* window['qzDoneFinding'] = function() { alert(qz.getPrinters()); };
***************************************************************************/
function findPrinters() {
if (isLoaded()) {
// Searches for a locally installed printer with a bogus name
qz.findPrinter('\\{bogus_printer\\}');
// Automatically gets called when "qz.findPrinter()" is finished.
window['qzDoneFinding'] = function() {
// Get the CSV listing of attached printers
var printers = qz.getPrinters().split(',');
for (i in printers) {
myalert(printers[i] ? printers[i] : 'Unknown');
}
// Remove reference to this function
window['qzDoneFinding'] = null;
};
}
}
/***************************************************************************
* Prototype function for printing raw EPL commands
* Usage:
* qz.append('\nN\nA50,50,0,5,1,1,N,"Hello World!"\n');
* qz.print();
***************************************************************************/
function print() {
if (notReady()) { return; }
// Send characters/raw commands to qz using "append"
// This example is for EPL. Please adapt to your printer language
// Hint: Carriage Return = \r, New Line = \n, Escape Double Quotes= \"
qz.append('\nN\n');
qz.append('q609\n');
qz.append('Q203,26\n');
qz.append('B5,26,0,1A,3,7,152,B,"1234"\n');
qz.append('A310,26,0,3,1,1,N,"SKU 00000 MFG 0000"\n');
qz.append('A310,56,0,3,1,1,N,"QZ PRINT APPLET"\n');
qz.append('A310,86,0,3,1,1,N,"TEST PRINT SUCCESSFUL"\n');
qz.append('A310,116,0,3,1,1,N,"FROM SAMPLE.HTML"\n');
qz.append('A310,146,0,3,1,1,N,"QZINDUSTRIES.COM"');
// Append the rest of our commands
qz.append('\nP1,1\n');
// Tell the applet to print.
qz.print();
}
/***************************************************************************
* Prototype function for logging a PostScript printer's capabilites to the
* Java console to expose potentially new applet features/enhancements.
* Warning, this has been known to trigger some PC firewalls
* when it scans ports for certain printer capabilities.
* Usage: (identical to appendImage(), but uses html2canvas for png rendering)
* qz.setLogPostScriptFeatures(true);
* qz.appendHTML("<h1>Hello world!</h1>");
* qz.printPS();
***************************************************************************/
function logFeatures() {
if (isLoaded()) {
var logging = qz.getLogPostScriptFeatures();
qz.setLogPostScriptFeatures(!logging);
alert('Logging of PostScript printer capabilities to console set to "' + !logging + '"');
}
}
/***************************************************************************
****************************************************************************
* * HELPER FUNCTIONS **
****************************************************************************
***************************************************************************/
function getPath() {
var path = window.location.href;
return path.substring(0, path.lastIndexOf("/")) + "/";
}
/**
* Fixes some html formatting for printing. Only use on text, not on tags!
* Very important!
* 1. HTML ignores white spaces, this fixes that
* 2. The right quotation mark breaks PostScript print formatting
* 3. The hyphen/dash autoflows and breaks formatting
*/
function fixHTML(html) {
return html.replace(/ /g, " ").replace(/’/g, "'").replace(/-/g,"‑");
}
/**
* Equivelant of VisualBasic CHR() function
*/
function chr(i) {
return String.fromCharCode(i);
}
/***************************************************************************
* Prototype function for allowing the applet to run multiple instances.
* IE and Firefox may benefit from this setting if using heavy AJAX to
* rewrite the page. Use with care;
* Usage:
* qz.allowMultipleInstances(true);
***************************************************************************/
function allowMultiple() {
if (isLoaded()) {
var multiple = qz.getAllowMultipleInstances();
qz.allowMultipleInstances(!multiple);
alert('Allowing of multiple applet instances set to "' + !multiple + '"');
}
}
</script>
<input type="button" onClick="print()" />
</body>
</html>
le code fourni est basé sur "jzebra_installation/dist/sample.html".
J'utilise QZ Tray pour imprimer des étiquettes depuis une page Web vers une imprimante thermique Zebra.
Dans le dossier demo/js de QZ Tray, trois fichiers JavaScript sont nécessaires pour communiquer avec l'application QZ Tray: dependencies/rsvp-3.1.0.min.js, dependencies/sha-256.min.js et qz-tray.js.
Incluez ces fichiers JavaScript dans votre projet comme suit:
<script type="text/javascript" src="/lib/qz-tray/rsvp-3.1.0.min.js"></script>
<script type="text/javascript" src="/lib/qz-tray/sha-256.min.js"></script>
<script type="text/javascript" src="/lib/qz-tray/qz-tray.js"></script>
Le moyen le plus simple d'imprimer une étiquette sur une imprimante thermique Zebra est présenté ci-dessous.
<script type="text/javascript">
qz.websocket.connect().then(function() {
// Pass the printer name into the next Promise
return qz.printers.find("zebra");
}).then(function(printer) {
// Create a default config for the found printer
var config = qz.configs.create(printer);
// Raw ZPL
var data = ['^XA^FO50,50^ADN,36,20^FDRAW ZPL EXAMPLE^FS^XZ'];
return qz.print(config, data);
}).catch(function(e) { console.error(e); });
</script>
Voir Comment imprimer des étiquettes d'une page Web sur une imprimante thermique Zebra pour plus d'informations.
essayez de créer un WebSocket qui contrôle l’impression côté client et envoie les données avec ajax de la page à localhost.
/// websocket
using System;
using System.Net;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
namespace Server
{
class Program
{
public static WebsocketServer ws;
static void Main(string[] args)
{
ws = new Server.WebsocketServer();
ws.LogMessage += Ws_LogMessage;
ws.Start("http://localhost:2645/service/");
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
private static void Ws_LogMessage(object sender, WebsocketServer.LogMessageEventArgs e)
{
Console.WriteLine(e.Message);
}
}
public class WebsocketServer
{
public event OnLogMessage LogMessage;
public delegate void OnLogMessage(Object sender, LogMessageEventArgs e);
public class LogMessageEventArgs : EventArgs
{
public string Message { get; set; }
public LogMessageEventArgs(string Message)
{
this.Message = Message;
}
}
public bool started = false;
public async void Start(string httpListenerPrefix)
{
HttpListener httpListener = new HttpListener();
httpListener.Prefixes.Add(httpListenerPrefix);
httpListener.Start();
LogMessage(this, new LogMessageEventArgs("Listening..."));
started = true;
while (started)
{
HttpListenerContext httpListenerContext = await httpListener.GetContextAsync();
if (httpListenerContext.Request.IsWebSocketRequest)
{
ProcessRequest(httpListenerContext);
}
else
{
httpListenerContext.Response.StatusCode = 400;
httpListenerContext.Response.Close();
LogMessage(this, new LogMessageEventArgs("Closed..."));
}
}
}
public void Stop()
{
started = false;
}
private async void ProcessRequest(HttpListenerContext httpListenerContext)
{
WebSocketContext webSocketContext = null;
try
{
webSocketContext = await httpListenerContext.AcceptWebSocketAsync(subProtocol: null);
LogMessage(this, new LogMessageEventArgs("Connected"));
}
catch (Exception e)
{
httpListenerContext.Response.StatusCode = 500;
httpListenerContext.Response.Close();
LogMessage(this, new LogMessageEventArgs(String.Format("Exception: {0}", e)));
return;
}
WebSocket webSocket = webSocketContext.WebSocket;
try
{
while (webSocket.State == WebSocketState.Open)
{
ArraySegment<Byte> buffer = new ArraySegment<byte>(new Byte[8192]);
WebSocketReceiveResult result = null;
using (var ms = new System.IO.MemoryStream())
{
do
{
result = await webSocket.ReceiveAsync(buffer, CancellationToken.None);
ms.Write(buffer.Array, buffer.Offset, result.Count);
}
while (!result.EndOfMessage);
ms.Seek(0, System.IO.SeekOrigin.Begin);
if (result.MessageType == WebSocketMessageType.Text)
{
using (var reader = new System.IO.StreamReader(ms, Encoding.UTF8))
{
var r = System.Text.Encoding.UTF8.GetString(ms.ToArray());
var t = Newtonsoft.Json.JsonConvert.DeserializeObject<Datos>(r);
bool valid = true;
byte[] toBytes = Encoding.UTF8.GetBytes(""); ;
if (t != null)
{
if (t.printer.Trim() == string.Empty)
{
var printers = "";
foreach (var imp in System.Drawing.Printing.PrinterSettings.InstalledPrinters)
{
printers += imp + "\n";
}
toBytes = Encoding.UTF8.GetBytes("No se Indicó la Impresora\nLas Impresoras disponibles son: " + printers);
valid = false;
}
if (t.name.Trim() == string.Empty)
{
toBytes = Encoding.UTF8.GetBytes("No se Indicó el nombre del Documento");
valid = false;
}
if (t.code == null)
{
toBytes = Encoding.UTF8.GetBytes("No hay datos para enviar a la Impresora");
valid = false;
}
if (valid)
{
print.RawPrinter.SendStringToPrinter(t.printer, t.code, t.name);
toBytes = Encoding.UTF8.GetBytes("Correcto...");
}
await webSocket.SendAsync(new ArraySegment<byte>(toBytes, 0, int.Parse(toBytes.Length.ToString())), WebSocketMessageType.Binary, result.EndOfMessage, CancellationToken.None);
}
else
{
toBytes = Encoding.UTF8.GetBytes("Error...");
await webSocket.SendAsync(new ArraySegment<byte>(toBytes, 0, int.Parse(toBytes.Length.ToString())), WebSocketMessageType.Binary, result.EndOfMessage, CancellationToken.None);
}
}
}
}
}
}
catch (Exception e)
{
LogMessage(this, new LogMessageEventArgs(String.Format("Exception: {0} \nLinea:{1}", e, e.StackTrace)));
}
finally
{
if (webSocket != null)
webSocket.Dispose();
}
}
}
public class Datos
{
public string name { get; set; }
public string code { get; set; }
public string printer { get; set; } = "";
}
}
impression brute:
using Microsoft.VisualBasic;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.IO;
namespace print
{
public class RawPrinter
{
// 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, ref IntPtr hPriknter, 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, ref 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, string DocName = "")
{
Int32 dwError = 0;
Int32 dwWritten = 0;
IntPtr hPrinter = new IntPtr(0);
DOCINFOA di = new DOCINFOA();
bool bSuccess = false;
// Assume failure unless you specifically succeed.
di.pDocName = string.IsNullOrEmpty(DocName) ? "My C#.NET RAW Document" : DocName;
di.pDataType = "RAW";
// Open the printer.
if (OpenPrinter(szPrinterName.Normalize(), ref 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, ref 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 = 0;
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, string DocName = "")
{
IntPtr pBytes = default(IntPtr);
Int32 dwCount = default(Int32);
// 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, DocName);
Marshal.FreeCoTaskMem(pBytes);
return true;
}
}
}
page html:
<!DOCTYPE html>
<html>
<head>
</head>
<body ng-app="myapp">
<div ng-controller="try as ctl">
<input ng-model="ctl.ticket.nombre">
<textarea ng-model="ctl.ticket.code"></textarea>
<button ng-click="ctl.send()">Enviar</button>
</div>
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.5.6/angular.min.js"></script>
<script>
var ws = new WebSocket("ws://localhost:2645/service");
ws.binaryType = "arraybuffer";
ws.onopen = function () {
console.log('connection is opened!!!');
};
ws.onmessage = function (evt) {
console.log(arrayBufferToString(evt.data))
};
ws.onclose = function () {
console.log("Connection is Closed...")
};
function arrayBufferToString(buffer) {
var arr = new Uint8Array(buffer);
var str = String.fromCharCode.apply(String, arr);
return decodeURIComponent(escape(str));
}
var app = angular.module('myapp', []);
app.controller('try', function () {
this.ticket= {nombre:'', estado:''}
this.send = () => {
var toSend= JSON.stringify(this.ticket);
ws.send(toSend);
}
});
</script>
</body>
</html>
puis envoyez un code ZPL à partir de HTML (écrivez ceci sur du code textarea);
^XA
^FO200,50^BY2^B3N,N,80,Y,N^FD0123456789^FS
^PQ1^XZ