Como usar a DLL chron32.dll em xHarbour ?

Mensagem por **sygecom** » 26 Jun 2010 18:03

Olá Pessoal,
Estou precisando imprimir no verso do cheque usando a DLL chron32.dll, eu vi que tem a função PLUS_EnviaBloco() que acredito que possa ser usado para a impressão no verso de cheques, porem não estou conseguindo usar somente essa função da DLL, abaixo segue o exemplo em .C que acompanha junto com o manual que está em anexo, se alguem poder me dar alguma dica de como usar essa função com xHarbour agradeço.

Nota.: o manual acompanha junto em exemplo em CLIPPER, porem se usa o exemplo em Clipper para imprimir no verso depois usando a DLL para imprimir outro cheque não funciona mais, somente reiniciando a maquina.

Abaixo o código das Funções em C.

Código: Selecionar todos

/**************************************************************************\
 *
 * Project     : Programa de Teste da DLL da Chronos
 *
 * Component   : TESTE.EXE
 *
 * Module Name : TESTE.C
 *
 * Description : Programa de Teste
 *
 * O.S.        : Windows 32 Bits (Win32s, Windows NT and Windows 95)
 * Language    : C (ANSI)
 * Compiler    : Borland C++ for Dos/Windows Version 4.52
 *
 * Comments    : 
 *
 * Vendor      : Analisa Consultoria em Informatica Ltda
 *
 * History Log :
 *
 *    Version Date      Author          Description
 *    ------- --------- --------------- -----------------------------------
 *    1.00    28/09/99  Carlos Yallouz  Created
 *    ---------------------------------------------------------------------
\**************************************************************************/
#include <windows.h>
#include <windowsx.h>
#include <ctl3d.h>
#include <stdio.h>
#include <stdarg.h>
#include <io.h>
#include <string.h>
#include <fcntl.h>
#include <sys\stat.h>
#include <stdlib.h>
#include "teste.rh"
#include "chronos.h"

#ifdef __WIN32__
  char szMainClass[] = "TESTE_CHRONOS32";
  HANDLE    hLog = NULL;
#else
  char szMainClass[] = "TESTE_CHRONOS16";
  int       hLog = 0;
#endif

HINSTANCE hInstance;    // First Instance
HWND      hMain;        // Main Window
HWND      hClient;      // Client Window (Modeless Dialog)
char      szPathExec[256]; // Execution Path
HFONT     hfontClient;

#define MAX_EDITBUFF 32000

static int IdPorta = 1;

/**************************************************************************
  buff_AddLine
 **************************************************************************/
static void buff_AddLine (LPCSTR lpszLine)
{
  UINT uBuffSize;
  UINT uLineSize;

  uLineSize = lstrlen (lpszLine);
  uBuffSize = Edit_GetTextLength(hClient);

  while ((uLineSize+uBuffSize) > MAX_EDITBUFF)
  {
    Edit_SetSel(hClient, 0, Edit_LineIndex(hClient, 1));
    Edit_ReplaceSel(hClient, "");
    uBuffSize = Edit_GetTextLength(hClient);
  }

  //
  // Append to the end of the buffer.
  //

  Edit_SetSel(hClient, 0x7FFF, 0x7FFF);
  Edit_ReplaceSel(hClient, lpszLine);
  Edit_SetSel(hClient, 0x7FFF, 0x7FFF);

  if (hLog)
  {
    DWORD dwSize = uLineSize;

#ifdef __WIN32__
    WriteFile (hLog, lpszLine, dwSize, &dwSize, NULL);
#else
    write (hLog,lpszLine,(unsigned)dwSize);
#endif
  }
}

/****************************************/

void Printf (LPSTR szFormato,...)
{
  va_list argumentos;
  char szBuff[512];

  va_start(argumentos,szFormato);
  vsprintf (szBuff,szFormato,argumentos);
  va_end(argumentos);
  strcat (szBuff,"\r\n");
  buff_AddLine (szBuff);
}

/**************************************************************************
  TurnLogOnOff
 **************************************************************************/
static void TurnLogOnOff (void)
{
  HMENU hMenu = GetMenu (hMain);
  BOOL  Checked;
  char  szLogFile[256];

  if (hMenu)
  {
    Checked = (GetMenuState (hMenu,IDM_LOGFILE, MF_BYCOMMAND) & MF_CHECKED) != 0;
    if (!Checked)
    {
      sprintf (szLogFile,"%sCHRONOS.LOG",szPathExec);
#ifdef __WIN32__
      hLog = CreateFile (szLogFile,
                         GENERIC_WRITE,
                         FILE_SHARE_WRITE | FILE_SHARE_READ,
                         NULL,
                         CREATE_ALWAYS,
                         FILE_ATTRIBUTE_NORMAL,
                         NULL);
      if (hLog == INVALID_HANDLE_VALUE)
      {
        hLog = NULL;
        MessageBeep(0);
        return;
      }
#else
      hLog = open (szLogFile, O_CREAT | O_APPEND | O_BINARY | O_WRONLY,
                              S_IREAD | S_IWRITE);
      if (hLog == -1)
      {
        hLog = NULL;
        MessageBeep(0);
        return;
      }
#endif

      CheckMenuItem (hMenu,IDM_LOGFILE,MF_CHECKED | MF_BYCOMMAND);
    }
    else
    {
      if (hLog)
      {
#ifdef __WIN32__
        CloseHandle(hLog);
#else
        close (hLog);
#endif
        hLog = NULL;
      }
      CheckMenuItem (hMenu,IDM_LOGFILE,MF_UNCHECKED | MF_BYCOMMAND);
    }
  }
}

/**************************************************************************
  ClearLog
 **************************************************************************/
static void ClearLog (void)
{
  BOOL opened = FALSE;
  char szLogFile[256];

  if (hLog)
  {
    TurnLogOnOff();
    opened = TRUE;
  }

  sprintf (szLogFile,"%sCHRONOS.LOG",szPathExec);
#ifdef __WIN32__
  hLog = CreateFile (szLogFile,
                     GENERIC_WRITE,
                     FILE_SHARE_WRITE | FILE_SHARE_READ,
                     NULL,
                     CREATE_ALWAYS,
                     FILE_ATTRIBUTE_NORMAL,
                     NULL);

  if (hLog != INVALID_HANDLE_VALUE)
    CloseHandle(hLog);
#else
  hLog = open (szLogFile, O_CREAT | O_TRUNC | O_BINARY | O_WRONLY,
                          S_IREAD | S_IWRITE);

  if (hLog == -1)
    hLog = 0;
#endif

  hLog = NULL;

  if (opened)
    TurnLogOnOff();
}

/**************************************************************************
  Implementacao das Funcoes de Acesso para Teste
 **************************************************************************/

typedef struct tagPARAMETROS {
  int NParam;      // Numero de Parametros
  LPSTR Prototipo; // Prototipacao da Funcao
  LPSTR Titulo[5]; // Titulo do Parametro
  LPSTR Param [5]; // Ponteiro para os parametros
  int   TamMax[5]; // Tamanho Maximo do Parametro
} PARAMETROS,
  FAR *LPPARAMETROS;

static PARAMETROS Param;

/////////////////////////////////////////////////////////////////////////////

#pragma argsused
BOOL CALLBACK _export CallBackParam (HWND hwnd,
                                    UINT uMsg,
                                    WPARAM wParam,
                                    LPARAM lParam)
{
   switch (uMsg)
   {
     case WM_INITDIALOG:
          {
            int i;

            SetDlgItemText (hwnd,ID_FUNCAO,Param.Prototipo);
            SetDlgItemInt (hwnd,ID_PORTA,IdPorta,FALSE);

            for (i=0; i < Param.NParam; i++)
            {
              SetDlgItemText (hwnd,ID_TXTPARAM1+i, Param.Titulo[i]);
              SetDlgItemText (hwnd,ID_PARAM1+i, "");
              Edit_LimitText (GetDlgItem (hwnd, ID_PARAM1+i),Param.TamMax[i]);

              ShowWindow (GetDlgItem (hwnd,ID_TXTPARAM1+i), SW_SHOW);
              ShowWindow (GetDlgItem (hwnd,ID_PARAM1+i), SW_SHOW);
            }
          }
          return TRUE;

     case WM_COMMAND:
          switch (GET_WM_COMMAND_ID (wParam,lParam))
          {
            case IDOK:
                 {
                   int i;

                   for (i=0; i < Param.NParam; i++)
                     GetDlgItemText (hwnd,ID_PARAM1+i,
                                     Param.Param[i],
                                     Param.TamMax[i]);
                 }
                 EndDialog (hwnd,TRUE);
                 break;

            case IDCANCEL:
                 EndDialog (hwnd,FALSE);
                 break;
          }
          break;
   }

   return FALSE;
}


//////////////////////////////

static void set_porta (int porta)
{
  HMENU hMenu = GetSubMenu (hMain,0);
  char szLinha[128];
  int i;

  if (!porta)
    porta = 1;

  for (i = 1; i <= 9; i++)
    if (i == porta)
      CheckMenuItem (hMenu, i, MF_BYCOMMAND | MF_CHECKED);
    else
      CheckMenuItem (hMenu, i, MF_BYCOMMAND | MF_UNCHECKED);

  sprintf (szLinha,"Teste Chronos: COM%d",porta);
  SetWindowText (hMain,szLinha);

  IdPorta = porta;
}

///////////////////////

static BOOL pede_parametros (void)
{
  return DialogBox (hInstance,
                    MAKEINTRESOURCE(D_PARAMETROS),
                    hMain,
                    (DLGPROC)CallBackParam);
}

///////////////////////

static void mostra_resultado (int Resultado)
{
  Printf ("Retorno = %d",Resultado);
}

///////////////////////

static void exec_abre (void)
{
  Printf ("PLUS_Abre (%d)",IdPorta);
  mostra_resultado (PLUS_Abre (IdPorta));
}


///////////////////////

static void exec_abre_ex (void)
{
  char  Velocidade[10];
  char  Paridade  [2];
  char  DataBits  [2];
  char  StopBits  [2];

  memset (&Param,0,sizeof(Param));
  Param.Prototipo = "PLUS_AbreEx (int IdPorta, long Velocidade, int Paridade, "
                                  "int DataBits, int StopBits)";
  Param.NParam = 4;
  Param.Titulo[0] = "&Velocidade";
  Param.Param[0] = Velocidade;
  Param.TamMax[0] = 9;

  Param.Titulo[1] = "&Paridade (0=N, 1=O, 2=E)";
  Param.Param[1] = Paridade;
  Param.TamMax[1] = 2;

  Param.Titulo[2] = "&DataBits (7 ou 8)";
  Param.Param[2] = DataBits;
  Param.TamMax[2] = 2;

  Param.Titulo[3] = "&StopBits (1 ou 2)";
  Param.Param[3] = StopBits;
  Param.TamMax[3] = 2;

  if (pede_parametros())
  {
    DWORD dwBaud;
    int   iParidade;
    int   iDataBits;
    int   iStopBits;

    dwBaud = atol (Velocidade);
    iParidade = atoi (Paridade);
    iDataBits = atoi (DataBits);
    iStopBits = atoi (StopBits);

    Printf ("PLUS_AbreEx (%d, %lu, %d, %d, %d)",IdPorta,dwBaud,iParidade,iDataBits, iStopBits);
    mostra_resultado (PLUS_AbreEx (IdPorta, dwBaud, iParidade, iDataBits, iStopBits));
  }
}

////////////////////////

static void exec_fecha (void)
{
  Printf ("PLUS_Fecha (%d)",IdPorta);
  mostra_resultado (PLUS_Fecha (IdPorta));
}

/////////////////////////

static void exec_enviabyte (void)
{
  char Linha[10];
  BYTE valor;

  memset (&Param,0,sizeof(Param));

  Param.Prototipo = "PLUS_EnviaByte (int IdPorta, int Byte)";
  Param.NParam = 1;
  Param.Titulo[0] = "&Byte";
  Param.Param[0] = Linha;
  Param.TamMax[0] = 2;

  if (pede_parametros ())
  {
    if (strlen (Linha) >= 2) // Dois Bytes ?
      valor = (BYTE)atoi (Linha);
    else
		valor = (BYTE)Linha[0];

    Printf ("PLUS_EnviaByte (%d, %u)",IdPorta, valor);
    mostra_resultado (PLUS_EnviaByte (IdPorta, valor));
  }
}

/////////////////////////

static void exec_enviabloco (void)
{
  char Linha[256];
  char Tamanho[10];
  int  cbSize;

  memset (Linha,0,sizeof(Linha));
  Tamanho[0] = 0;
  memset (&Param,0,sizeof(Param));

  Param.Prototipo = "PLUS_EnviaByte (int IdPorta, LPBYTE lpBuffer, int cbSize)";
  Param.NParam = 2;
  Param.Titulo[0] = "&lpBuffer";
  Param.Param[0] = Linha;
  Param.TamMax[0] = sizeof (Linha)-1;

  Param.Titulo[1] = "&cbSize";
  Param.Param[1] = Tamanho;
  Param.TamMax[1] = 4;

  if (pede_parametros ())
  {
    cbSize = atoi (Tamanho);
    if (cbSize > 255)
      cbSize = 255;

    Printf ("PLUS_EnviaBloco (%d, %s, %u)",IdPorta, Linha, cbSize);
    mostra_resultado (PLUS_EnviaBloco (IdPorta, (LPBYTE)Linha, cbSize));
  }
}

/////////////////////////

static void exec_habyte (void)
{
  Printf ("PLUS_HaByte (%d)",IdPorta);
  mostra_resultado (PLUS_HaByte (IdPorta));
}

/////////////////////////

static void exec_recebebyte (void)
{
  int result;
  Printf ("PLUS_RecebeByte (%d)",IdPorta);
  result = PLUS_RecebeByte (IdPorta);
  if ((result <= ' ') || (result >= 127))
    mostra_resultado (result);
  else
    Printf ("Retorno: Caractere %c",result);
}

/////////////////////////

static void exec_ultimoerro (void)
{
  Printf ("PLUS_UltimoErro (%d)",IdPorta);
  mostra_resultado (PLUS_UltimoErro (IdPorta));
}

/////////////////////////

static void exec_status (void)
{
  char Linha[10];
  int valor;

  memset (&Param,0,sizeof(Param));

  Param.Prototipo = "PLUS_Status (int IdPorta, int IdStatus)";
  Param.NParam = 1;
  Param.Titulo[0] = "&IdStatus";
  Param.Param[0] = Linha;
  Param.TamMax[0] = 2;

  if (pede_parametros ())
  {
    valor = atoi (Linha);

    Printf ("PLUS_Status (%d, %u)",IdPorta, valor);
    mostra_resultado (PLUS_Status (IdPorta, valor));
  }
}

/////////////////////////

static void exec_ejeta (void)
{
  Printf ("PLUS_Ejeta (%d)",IdPorta);
  mostra_resultado (PLUS_Ejeta (IdPorta));
}

////////////////////////

static void exec_programabancos (void)
{
  char Linha[256];
  char sBanco[10];
  int  Banco;

  memset (Linha,0,sizeof(Linha));
  sBanco[0] = 0;
  memset (&Param,0,sizeof(Param));

  Param.Prototipo = "PLUS_ProgramaBancos (int IdPorta, int Banco, LPSTR lpszPrograma)";
  Param.NParam = 2;
  Param.Titulo[0] = "&Banco";
  Param.Param[0] = sBanco;
  Param.TamMax[0] = 4;

  Param.Titulo[1] = "&lpszPrograma";
  Param.Param[1] = Linha;
  Param.TamMax[1] = sizeof(Linha)-1;

  if (pede_parametros ())
  {
    Banco = atoi (sBanco);
    Printf ("PLUS_ProgramaBancos (%d, %u, %s)",IdPorta, Banco, Linha);
    mostra_resultado (PLUS_ProgramaBancos (IdPorta, Banco, Linha));
  }
}

////////////////////////

static void exec_campocheque (void)
{
  char Linha[256];
  char sCampo[10];
  int  Campo;

  memset (Linha,0,sizeof(Linha));
  sCampo[0] = 0;
  memset (&Param,0,sizeof(Param));

  Param.Prototipo = "PLUS_CampoCheque (int IdPorta, int Campo, LPSTR lpszValorCampo)";
  Param.NParam = 2;
  Param.Titulo[0] = "&Campo";
  Param.Param [0] = sCampo;
  Param.TamMax[0] = 3;

  Param.Titulo[1] = "&lpszValorCampo";
  Param.Param[1] = Linha;
  Param.TamMax[1] = sizeof(Linha)-1;

  if (pede_parametros ())
  {
    Campo = atoi (sCampo);
	 Printf ("PLUS_CampoCheque (%d, %u, %s)",IdPorta, Campo, Linha);
    mostra_resultado (PLUS_CampoCheque (IdPorta, Campo, Linha));
  }
}

////////////////////////

static void exec_campochequepermanente (void)
{
  char Linha[256];
  char sCampo[10];
  int  Campo;

  memset (Linha,0,sizeof(Linha));
  sCampo[0] = 0;
  memset (&Param,0,sizeof(Param));

  Param.Prototipo = "PLUS_CampoChequePermanente (int IdPorta, int Campo, LPSTR lpszValorCampo)";
  Param.NParam = 2;
  Param.Titulo[0] = "&Campo";
  Param.Param [0] = sCampo;
  Param.TamMax[0] = 3;

  Param.Titulo[1] = "&lpszValorCampo";
  Param.Param[1] = Linha;
  Param.TamMax[1] = sizeof(Linha)-1;

  if (pede_parametros ())
  {
    Campo = atoi (sCampo);
    Printf ("PLUS_CampoChequePermanente (%d, %u, %s)",IdPorta, Campo, Linha);
    mostra_resultado (PLUS_CampoChequePermanente (IdPorta, Campo, Linha));
  }
}

////////////////////////

static void exec_imprimecheque (void)
{
  Printf ("PLUS_ImprimeCheque (%d)",IdPorta);
  mostra_resultado (PLUS_ImprimeCheque (IdPorta));
}

///////////////////////

static void exec_inicialeitura (void)
{
  Printf ("PLUS_IniciaLeitura (%d)",IdPorta);
  mostra_resultado (PLUS_IniciaLeitura (IdPorta));
}

//////////////////////

static void exec_cancelaleitura (void)
{
  Printf ("PLUS_FinalizaLeitura (%d)",IdPorta);
  mostra_resultado (PLUS_FinalizaLeitura (IdPorta));
}

//////////////////////

static void exec_leitura (void)
{
  char Linha[256];
  int  result;

  Printf ("PLUS_Leitura (%d, %p, 255)",IdPorta, Linha);

  result = PLUS_Leitura (IdPorta, Linha, 255);
  mostra_resultado (result);

  if (result == 1)
	 Printf ("Buffer Lido: %s",Linha);
}

static void exec_lecmc7(void)
{
	int result;

	Printf ("PLUS_LeCMC7 (%d)",IdPorta);
	result = PLUS_SolicitaLeitura(IdPorta);

	mostra_resultado (result);
}

/**************************************************************************

  CallBackMain - CallBack for Main Window

 **************************************************************************/
long CALLBACK _export CallBackMain (HWND   hwnd,
                                    UINT   msg,
                                    WPARAM wParam,
                                    LPARAM lParam)
{
   switch (msg) {
    case WM_CREATE:
			hMain = hwnd;
         set_porta (0);
         PostMessage (hwnd,WM_COMMAND,IDM_ABOUT,0l);
         return 0;

    case WM_SIZE:
         /* Make sure the edit control always occupies the entire
			 * client area.
          */
			if (hClient)
         {
            RECT rc;

            GetClientRect(hwnd, &rc);
            //
            // Outset border
				//
            InflateRect(&rc, 1, 1);
            MoveWindow(hClient, rc.top, rc.left, rc.right - rc.left, rc.bottom - rc.top, TRUE);
          }
          break;

    case WM_COMMAND:
         switch (GET_WM_COMMAND_ID(wParam,lParam))
         {

           case IDM_ABOUT:
                #ifdef __WIN32__
                  Printf ("<Programa de Teste da CHRON32.DLL>");
                #else
						Printf ("<Programa de Teste da CHRON16s.DLL>");
					 #endif

					 Printf ("\tCopyright © 1999 CHRONOS S.A\r\n"
                        "\tVersão 1.03 - Marco de 2000");
					 break;

           case IDM_EXIT:
                PostMessage (hwnd,WM_CLOSE,0,0l);
                break;

           case IDM_LOGFILE:
                TurnLogOnOff();
                break;

           case IDM_CLEARLOG:
                ClearLog();
                break;

           case IDM_SELALL:
                Edit_SetSel(hClient, 0, 32767);
                break;

           case IDM_DELETE:
                Edit_SetSel(hClient, 0, 32767);
                Edit_ReplaceSel(hClient, "");
                break;

           case IDM_COPY:
					 PostMessage(hClient, WM_COPY, 0, 0L);
                break;

                // Funcoes
           case IDM_ABRE:
                exec_abre();
                break;

           case IDM_ABREX:
                exec_abre_ex();
                break;

           case IDM_FECHA:
                exec_fecha();
                break;

           case IDM_ENVIABYTE:
                exec_enviabyte();
                break;

           case IDM_ENVIABLOCO:
                exec_enviabloco();
                break;

			  case IDM_HABYTE:
                exec_habyte();
					 break;

           case IDM_RECEBEBYTE:
                exec_recebebyte();
                break;

           case IDM_ULTIMOERRO:
                exec_ultimoerro();
                break;

           case IDM_STATUS:
                exec_status();
                break;

           case IDM_EJETA:
                exec_ejeta();
                break;

           case IDM_PROGRAMABANCOS:
                exec_programabancos();
                break;

           case IDM_CAMPOCHEQUE:
                exec_campocheque();
                break;

			  case IDM_CAMPOCHEQUEP:
                exec_campochequepermanente();
                break;

           case IDM_IMPRIMECHEQUE:
                exec_imprimecheque();
                break;

           case IDM_INICIALEITURA:
                exec_inicialeitura();
                break;

           case IDM_CANCELALEITURA:
                exec_cancelaleitura();
                break;

           case IDM_LEITURA:
                exec_leitura();
					 break;
			  case CM_PLUSLECMC:
					exec_lecmc7();
					break;
			  case IDM_COM1:
			  case IDM_COM2:
			  case IDM_COM3:
           case IDM_COM4:
           case IDM_COM5:
           case IDM_COM6:
           case IDM_COM7:
           case IDM_COM8:
           case IDM_COM9:
                set_porta (GET_WM_COMMAND_ID(wParam,lParam) - IDM_COM1 + 1);
                break;
         }
         break;

    case WM_CLOSE:
         DestroyWindow (hwnd);
         return 0;

    case WM_DESTROY:
         PostQuitMessage (0);
         return 0;
  }

  return DefWindowProc (hwnd, msg, wParam, lParam);
}

/**************************************************************************/

static BOOL AppInit(HINSTANCE hinst,
                    HINSTANCE hinstPrev,
                    int showCmd)
{
    WNDCLASS cls;
    LOGFONT  lf;
    int i;

    if (GetModuleFileName ((HMODULE)hInstance,szPathExec,sizeof(szPathExec)))
      for (i=strlen(szPathExec)-1; i; i--)
        if (szPathExec[i] == '\\')
        {
          szPathExec[i+1] = 0;
          break;
        }

    if (!hinstPrev)
    {
      hInstance = hinst;

      cls.hCursor        = LoadCursor(NULL, IDC_ARROW);
      cls.hIcon          = NULL; //LoadIcon(hInstance, MAKEINTRESOURCE(IDR_MAINICON));
      cls.lpszMenuName   = MAKEINTRESOURCE(M_MAIN);
      cls.lpszClassName  = szMainClass;
      cls.hbrBackground  = (HBRUSH)(COLOR_WINDOW + 1);
      cls.hInstance      = hInstance;
      cls.style          = CS_BYTEALIGNCLIENT;
      cls.lpfnWndProc    = CallBackMain;
      cls.cbWndExtra     = 0;
      cls.cbClsExtra     = 0;

      if (!RegisterClass(&cls))
      {
        return FALSE;
      }

      if (Ctl3dRegister(hInstance))
        Ctl3dAutoSubclass(hInstance);
    }
    else
      return FALSE;

    // Create the main window

    hMain = CreateWindow(szMainClass,               // Class name
                         "Teste Chronos",          // Caption
                          WS_OVERLAPPEDWINDOW,    // Style bits
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          (HWND)NULL,             // Parent window (no parent)
                          (HMENU)NULL,            // use class menu
                          (HINSTANCE)hInstance,   // handle to window instance
                          (LPSTR)NULL             // no params to pass on
                           );
    if (!hMain)
        return FALSE;

    hClient = CreateWindow("EDIT", NULL,
            WS_CHILD | WS_VISIBLE | WS_BORDER | WS_VSCROLL | WS_HSCROLL |
            ES_AUTOHSCROLL | ES_AUTOVSCROLL | ES_MULTILINE,
            0, 0, 0, 0,
            hMain, (HMENU)0, hInstance, NULL);

    if (!hClient)
        return FALSE;

    //
    // Use the small icon title font
    //

    SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, FALSE);
    hfontClient = CreateFontIndirect(&lf);
    if (hfontClient)
      FORWARD_WM_SETFONT(hClient, hfontClient, FALSE, SendMessage);

    ShowWindow(hClient, SW_SHOWNORMAL);

    ShowWindow (hMain,showCmd);
    UpdateWindow (hMain);

    return TRUE;
}
/**************************************************************************

  Program Entrypoint and main loop

 **************************************************************************/

#pragma argsused
int PASCAL WinMain (HINSTANCE hInst,
                    HINSTANCE hPrevInstance,
                    LPSTR  lpszArg,
                    int    nCmdShow)
{
  MSG       msg;

  if (!AppInit(hInst, hPrevInstance, nCmdShow))
    return FALSE;

  while (GetMessage (&msg, NULL, 0, 0))
  {
    TranslateMessage (&msg);
    DispatchMessage (&msg);
  }

  #ifdef __WIN32__
    if (hLog)
      CloseHandle (hLog);
  #else
    if (hLog)
      close (hLog);
  #endif

  if (hfontClient)
    DeleteObject(hfontClient);

  if (!hPrevInstance)
    Ctl3dUnregister(hInstance);

  return msg.wParam;
}

Mensagem por **Itamar M. Lins Jr.** » 27 Jun 2010 09:59

Transcrevendo a resposta do Viktor.
Já que pediu ajuda no grupo internacional dos usuários do Harbour.

Hi,

You can find examples here:
tests/testdyn.prg

Here's is function skeleton from ChangeLog:

HB_DYNCALL( <pFunction> | <aFunction>, ... ) -> <xResult>

where <aFunction> can be:
{ <cFunction>, <cLibrary> | <pLibrary> [, <nFuncFlags> [,
<nArgFlags1>, ..., <nArgFlagsn> ]] }

where
<nFuncFlags> can be:
hb_bitOr( HB_DYN_CTYPE_*, HB_DYN_ENC_*,
HB_DYN_CALLCONV_* )
<nArgFlags*> can be:
hb_bitOr( HB_DYN_CTYPE_*, HB_DYN_ENC_* )

Viktor

Saudações,
Itamar M. Lins Jr.

Mensagem por **rochinha** » 27 Jun 2010 14:37

Amiguinho,

Tente algo assim:

Código: Selecionar todos

#include "fivewin.ch"
#include "dll.ch"

#define Chron32DLL "chron32.dll"

function main()

   public hChron32DLL := LoadLibrary( Chron32DLL )

   if hChron32DLL > 0
      ...
      PLUS_EnviaBloco( ...
      ...
   endif

return .t.

DLL32 FUNCTION PLUS_EnviaBloco( IdPorta AS _INT, lpBuff AS BYTE, cbSize AS _INT ) AS BOOL PASCAL FROM "PLUS_EnviaBloco" LIB hChron32DLL

Mensagem por **sygecom** » 27 Jun 2010 18:01

Olá Rochinha,
Vou testar e assim que tiver o resultado volto aqui, de momento, obrigado.

Mensagem por **fladimir** » 23 Nov 2010 10:02

Leo como vc resolveu?

Sds

:)Pos

Mensagem por **sygecom** » 29 Nov 2010 23:23

Na Gambi,
Usando o exemplo do Clipper, mas se souber algum comando que use direto a DLL estou aceitando dicas !
Rocnhinha,
Valeu mas não deu certo sua dica amiguinho ! Abraços.

Mensagem por **rochinha** » 30 Nov 2010 12:45

Amiguinho,

Como voce resolveu com o exemplo para Clipper? voce compilou com Borland e linkou ao seu aplicativo?

No caso do exemplo que lhe passei voce conseguiu pelo menos utilizar uma vez, sendo que após voce teria de reinicializar a máquina?

Se sim, o que voce deve fazer é carregar a biblioteca no inicio do seu sistema para que ela fique ativa sempre e não somente no momento da impressão.

Então, public hChron32DLL := LoadLibrary( "chron32.dll" ) deve estar no .PRG principal e quando voce fizer uso da mesma, nunca descarregar a mesma via FreeeLibrary().

PC Toledo

Como usar a DLL chron32.dll em xHarbour ?

Como usar a DLL chron32.dll em xHarbour ?

Re: Como usar a DLL chron32.dll em xHarbour ?

Re: Como usar a DLL chron32.dll em xHarbour ?

Re: Como usar a DLL chron32.dll em xHarbour ?

Re: Como usar a DLL chron32.dll em xHarbour ?

Re: Como usar a DLL chron32.dll em xHarbour ?

Re: Como usar a DLL chron32.dll em xHarbour ?