Função iniciar a confeçção de uma nova etiqueta
procedure Abrir_Etiqueta_DPL;

Função para finalizar a confecção de uma nova etiqueta
Function Fechar_Etiqueta_DPL(Imprime: Boolean;
Num_Copias: integer = -1): TStrings;

Funções da Impressora
Function Comando_SOH_Sustenido: String;
Function Comando_SOH_Asterisco: String;
Function Comando_SOH_A: String;
Function Comando_SOH_B: String;
Function Comando_SOH_C: String;
Function Comando_SOH_D: String;
Function Comando_SOH_E: String;
Function Comando_SOH_F: String;
Function Comando_SOH_U: String;
Function Comando_STX_A(dia_semana, mes, dia: byte; ano: integer; hora,
minuto: byte; julian_date: integer): String; overload;
Function Comando_STX_a: String; overload;
Function Comando_STX_B: String;
Function Comando_STX_c(tamanho: byte): String;
Function Comando_d: String; overload;
Function Comando_STX_E(qnt_etiquetas: integer): String; overload;
Function Comando_STX_e: String; overload;
Function Comando_STX_F: String; overload;
Function Comando_STX_f(distancia: integer): String; overload;
Function Comando_STX_G: String;
Function Comando_STX_J: String;
Function Comando_STX_k: String; overload;
Function Comando_STX_L: String;
Function Comando_STX_M(comprimento: integer): String; overload;
Function Comando_STX_m: String; overload;
Function Comando_STX_n: String;
Function Comando_STX_O(distancia: integer): String; overload;
Function Comando_STX_o: String; overload;
Function Comando_STX_P: String;
Function Comando_STX_p_min: String;
Function Comando_STX_Q: String; overload;
Function Comando_STX_q(modulo_mem: char): String; overload;
Function Comando_STX_R(ativo: boolean): String; overload;
Function Comando_STX_r: String; overload;
Function Comando_STX_S(velocidade: char): String; overload;
Function Comando_STX_s: String; overload;
Function Comando_STX_T: String;
Function Comando_STX_t_min: String;
Function Comando_STX_U(id_campo: byte; dados: shortstring): String;
Function Comando_STX_V(opcoes: char): String; overload;
Function Comando_STX_v: String; overload;
Function Comando_STX_W(tipo_dado: char): String;
Function Comando_STX_w_min(modulo_mem: char): String;
Function Comando_STX_X(modulo_mem: char): String; overload;
Function Comando_STX_x(modulo_mem, tipo_arquivo: char;
nome_arquivo: shortstring): String; overload;
Function Comando_STX_Y: String; overload;
Function Comando_STX_y(tamanho_byte: char;
selecao_simbolo: shortstring): String; overload;
Function Comando_STX_Z: String; overload;
Function Comando_STX_z(modulo_mem: char): String; overload;
Function Comando_STX_K(i,j,k: char; x, y, z: integer): String; overload;
Function Comando_STX_Kb(segundos: integer): String;
Function Comando_STX_KC: String;
Function Comando_STX_KD(w, x, y, z: byte): String; overload;
Function Comando_STX_Kd(nome_arquivo: shortstring): String; overload;
Function Comando_STX_KE(ativo: boolean; delimitador: char): String;
Function Comando_STX_KM(valor:integer): String;
Function Comando_STX_KS(valor:integer): String;
Function Comando_STX_KW(valor:integer): String;
Function Comando_STX_KF: String; overload;
Function Comando_STX_Kf(distancia: integer): String; overload;
Function Comando_STX_Kp(modulo_mem: char; protecao: boolean): String;
Function Comando_STX_KQ: String;
Function Comando_STX_Kq_min: String;
Function Comando_STX_KR: String;
Function Comando_STX_Kr_min: String;
Function Comando_STX_KV(verifier: boolean): String; overload;
Function Comando_STX_Kv(modulo_mem: char; nome_arquivo: shortstring): String; overload;
Function Comando_Dois_Pontos(qnt_etiqueta: integer): String;
Function Comando_A(formatacao: byte): String;
Function Comando_B(ampliacao: byte): String;
Function Comando_C(margem: byte): String;
Function Comando_c_min(qnt_etiqueta: byte): String;
Function Comando_D(largura, altura: byte): String; overload;
Function Comando_E: String; overload;
Function Comando_e(nome_arquivo: shortstring): String; overload;
Function Comando_f(velocidade: byte): String;
Function Comando_G: String;
Function Comando_H(temperatura: byte): String;
Function Comando_J(alinhamento: char): String;
Function Comando_M: String;
Function Comando_m_min: String;
Function Comando_n: String;
Function Comando_P(velocidade: byte): String;
Function Comando_p_min(velocidade: byte): String;
Function Comando_Q(qnt_etiquetas: byte): String;
Function Comando_R(margem_vertical: integer): String; overload;
Function Comando_r(nome_arquivo: shortstring): String; overload;
Function Comando_S(velocidade: byte): String;
Function Comando_r(modulo_mem: char; nome_arquivo: shortstring): String; overload;
Function Comando_T(terminador: byte): String;
Function Comando_U: String;
Function Comando_X: String; overload;
Function Comando_y(tamanho_byte: char; selecao_simbolo: shortstring): String;
Function Comando_z: String; overload;
function cxxxD (xxx: integer): string;
function sxxxW (xxx: Byte; ddd : string): string;
function cxxxE(xxx: integer): string;

Função para Impressão de Texto
Function Texto_DPL ( rotacao: byte; font_ID: integer ;Largura, altura: byte;
Fonte, Eixo_Y,Eixo_X : integer; texto:string): String;

Função para Impressão de Sombra de Fonte
Function Smooth_Font_DPL ( rotacao: byte; font_ID: integer ;Largura, altura: byte;
Fonte, Eixo_Y,Eixo_X : integer; texto: string): String;

Função de Escala de Fonte
Function Scalable_Font_DPL ( rotacao: byte; font_ID: integer ;Largura, altura: byte;
Fonte, Eixo_Y,Eixo_X : integer; texto:string): String;

Função para Impressão de Código de Barras
Function CodBarras_DPL ( rotacao: byte; font_ID: integer ;Largura, altura: byte;
Fonte, Eixo_Y,Eixo_X : integer; texto:string): String;

Função para Impressão de Imagem
Function Imagem_DPL ( rotacao: byte; font_ID: char ;Largura, altura: byte;
Fonte, Eixo_Y,Eixo_X : integer; texto:string): String;

Função para Impressão de Linhas
Function LInha_Caixa_Texto_DPL (rotacao: byte; font_ID: char ;Largura, altura: byte;
Fonte, Eixo_Y,Eixo_X : integer; texto:string): String;

Função para Impressão de Poligono
Function Poligono_DPL (rotacao: byte; font_ID: char ;Largura, altura: byte;
Teste_Padrao, Eixo_Y_1,Eixo_X_1,Eixo_Y_2,
Eixo_X_2,Eixo_Y_3,Eixo_X_3: integer; Poligon:string): String;

Função para Impressão de Círculo
Function Circulo_Texto_DPL(rotacao: byte; font_ID: char ;Largura, altura: byte;
Teste_Padrao, Largura_Ponto_Central,altura_Ponto_Central,
radianos: integer; Circulo:string): String;

  Para recompilar o programa demo antes de adquirir o fonte da unit, é necessário copiar o arquivo DPL_Unit.dcu para o diretório Lib de instalação do Delphi, no caso do Delphi 6 pro exemplo:
C:\Arquivos de programas\Borland\Delphi6\Lib

  Caso já tenha adquirido a DPL_Unit registrada, você pode adiciona-la ao seu projeto, clicando em Menu> Project> Add to Project.

  Antes de efetuar os testes com o demo de comunicação, sugerimos aos nossos usuário que instalem o software de geração de etiquetas da própria Datamax e verifiquem se a impressão é efetuada sem problemas.

  Caso a impressão de etiquetas ocorra normalmente no software da Datamax e o demo não esteja funcionando, verifique se a está utilizando o demo da linguagem correta para a sua impressora.

  O demo disponível no site é totalmente funcional, sua única limitação é que a cada chamada das funções de impressão ele gera uma mensagem de "Não Registrado".

  Para identificar o problema pelo qual não está imprimindo, favor verificar alguns pontos:

  1- A impressora deve estar corretamente instalada através do CD de drivers que acompanha a mesma e deve também está configurada como impressora padrão na porta LPT1.

  2- Verifique as configurações da etiqueta no software, como tamanho, espaço entre etiquetas e posicionamento do textos e códigos de barras.

  3- Verifique se a impressora está ok e pronta para imprimir e se a mesma está recebendo os comandos enviados pelo software (geralmente o led da impressora pisca ao receber os comandos)

  4- Para efetuar a impressão, adicione um produto na listagem e clique no botão "Gerar Fonte DPL", surgiram as mensagens de "Não Registrado" e o código fonte DPL será mostrado abaixo, clique então em "Enviar para Impressora".

  5- Caso a impressão de etiquetas ocorra normalmente no software da Datamax e o demo não esteja funcionando, verifique se a está utilizando o demo da linguagem correta para a sua impressora. Pois se uma impressora que trabalha com linguagem DPL recebe parâmetros da linguagem ZPL por exemplo, a impressão não é efetuada e não haverá nenhuma indicação de erro.

  O código da DPL_Unit.pas foi desenvolvido em Delphi 6 e é totalmente composto por código nativo do Delphi, podendo portanto ser compilado em qualquer versão do Delphi sem maiores complicações, devido a garantias de interoperabilidade entre versões fornecidas pela própria Borland.

  O objetivo maior da Unit é gerar o script da linguagem DPL, no entanto o demo de uso da Unit já vem acompanhado da implementação de envio direto para a porta paralela LPT1, utilizada por nossos clientes.

  A implementação do envio para a porta serial COM pode ser feita utilizando qualquer componente de comunicação serial disponivel na internet, simplesmente, enviando a string gerada pela a unit para a porta.

  Aqui na empresa costumamos utilizar o componente TCommPort (freeware) para comunicação serial diversas, mas a comunicação pode ser feita com qualquer componente de sua escolha.

  No momento o código para geração de script DPL só está implementada em Delphi, e não há previsão para implementação em outras linguagens.

  Porém, como comercializamos os fontes do produto, o processo de adaptação do mesmo para a linguagem desejada é simples, pois toda a lógica já está implementada e é necessária apenas a tradução. Sendo assim, sugerimos que adquira os fontes em Delphi e faça a adaptação para VB pois será muito mais rápido do que caso deseje fazer a implementação do zero.

  Isso depende do tamanho da etiqueta e do espaço entre etiquetas que vc está utilizando ai.

  Mas todos estes parametros de tamanho e posicao da etiqueta são configuráveis também pela unit, e a adaptação do demo depende apenas da obeservação das dimensões da etiqueta e posições de onde deseja imprimir os textos.

  Este processo inicial é um pouco empírico mesmo... você tem que estimar mais ou menos onde deseja que o texto seja impresso e manda imprimir para ver onde ficou... depois vai fazendo o ajuste fino.

  Em nosso sistema, que utiliza a unit, disponibilizamos uma tela para o usuário final onde ele pode fazer este ajuste fino ele mesmo, caso deseje por exemplo alterar um campo de lugar na etiqueta.