Using DLL function with Harbour

[Leonardo]

Hello,
I need to print on the back of the check using the DLL chron32.dll I
saw that has the function PLUS_EnviaBloco () that I believe can be
used for printing on the back of checks, but I am not able to use only
this function of the DLL, follow below as I am using in Fivewin and
more in the example. C that came with the DLL, if someone could give
me any tips on how to use this function with Fivewin or Harbour, thank
you.

Below example that I use Fivewin:
DLL FUNCTION PL_Abre ( idPorta AS 7 ) AS LONG PASCAL FROM "PLUS_Abre"
LIB xChron32
DLL FUNCTION PL_UltimoErro ( idPorta AS 7 ) AS LONG PASCAL FROM
"PLUS_UltimoErro" LIB xChron32
DLL FUNCTION PL_Fecha ( idPorta AS 7 ) AS LONG PASCAL FROM
"PLUS_Fecha" LIB xChron32
DLL FUNCTION PL_Cheque ( idPorta AS 7 ,;
nCampo AS 7 ,;
sCampo AS LPSTR ) AS LONG PASCAL FROM
"PLUS_CampoCheque" LIB xChron32
DLL FUNCTION PL_Status ( idPorta AS 7 ,;
nCampo AS 7 ) AS LONG PASCAL FROM "PLUS_Status" LIB
xChron32

DLL FUNCTION PL_Print ( idPorta AS 7 ) AS LONG PASCAL FROM
"PLUS_ImprimeCheque" LIB xChron32
DLL FUNCTION PL_Ejeta ( idPorta AS 7 ) AS LONG PASCAL FROM
"PLUS_Ejeta" LIB xChron32


DLL FUNCTION PL_EnviaByte ( idPorta AS 7,;
cCampo AS 7 ) AS LONG PASCAL FROM
"PLUS_EnviaByte" LIB xChron32


And in the example below. C that comes with the DLL:

/
**************************************************************************
\
*
* 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&#058;
#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;
}

[vszakats]

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

>            case IDM_ABOUT:

[Leonardo Machado]

Hi Viktor

I do not really know what to use instead of (LPBYTE) Line

DEFINE What should I use to be able to have something compatible LPBYTE?

Leonardo Machado



> Date: Sun, 27 Jun 2010 01:02:36 -0700
> Subject: [harbour-users] Re: Using DLL function with Harbour
> From: harbo...@syenar.hu
> To: harbou...@googlegroups.com

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

> On Jun 27, 1:07áam, Leonardo <leonardodemach...@hotmail.com> wrote:
> > Hello,
> > I need to print on the back of the check using the DLL chron32.dll I
> > saw that has the function PLUS_EnviaBloco () that I believe can be
> > used for printing on the back of checks, but I am not able to use only
> > this function of the DLL, follow below as I am using in Fivewin and
> > more in the example. C that came with the DLL, if someone could give
> > me any tips on how to use this function with Fivewin or Harbour, thank
> > you.
> >
> > Below example that I use Fivewin:
> > DLL FUNCTION PL_Abre ( idPorta AS 7 ) AS LONG PASCAL FROM "PLUS_Abre"
> > LIB xChron32
> > DLL FUNCTION PL_UltimoErro ( idPorta AS 7 ) AS LONG PASCAL FROM
> > "PLUS_UltimoErro" LIB xChron32
> > DLL FUNCTION PL_Fecha ( idPorta AS 7 ) AS LONG PASCAL FROM
> > "PLUS_Fecha" LIB xChron32
> > DLL FUNCTION PL_Cheque ( idPorta AS 7 ,;

> > á á á á á á á ánCampo AS 7 ,;
> > á á á á á á á ásCampo AS LPSTR ) AS LONG PASCAL FROM

> > "PLUS_CampoCheque" LIB xChron32
> > DLL FUNCTION PL_Status ( idPorta AS 7 ,;

> > á á á á á á á ánCampo AS 7 ) AS LONG PASCAL FROM "PLUS_Status" LIB

> > xChron32
> >
> > DLL FUNCTION PL_Print ( idPorta AS 7 ) AS LONG PASCAL FROM
> > "PLUS_ImprimeCheque" LIB xChron32
> > DLL FUNCTION PL_Ejeta ( idPorta AS 7 ) AS LONG PASCAL FROM
> > "PLUS_Ejeta" LIB xChron32
> >
> > DLL FUNCTION PL_EnviaByte ( idPorta AS 7,;

> > á á á á á á á á á á á á á á ácCampo AS 7 ) AS LONG PASCAL FROM

> > "PLUS_EnviaByte" LIB xChron32
> >
> > And in the example below. C that comes with the DLL:
> >
> > /
> > **************************************************************************
> > \

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

---

VEJA TODOS OS SEUS EMAILS DE VÁRIAS CONTAS COM UM SÓ LOGIN. CLIQUE AQUI E VEJA COMO.

[Mauricio Faria]

Hi.
I need to call some DLLs and I am a bit confused.
At first, I need to say that I do not know C, and I am sure that this
is my problem in understanding how to call 3rd party DLLs.
I tried to understand DLLs calling some time ago but I simple copied
someone else code gave up.
I tried to read the examples but am still confused.
Could you explain this in a "dumb" way ?

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

This is Ok.

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

Here, what is the meaning of <nFuncFlags> ?
The number of parameters passed ?
And <nArgFlagsn> are the parameters ?
Why the name "flags" ?

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

What are HB_DYN_CTYPE_*, HB_DYN_ENC_*, HB_DYN_CALLCONV_* ?
What are the values this "things" can assume ?

If all of this are hard to explain here, could you point a link that
can help, preferable in a very "dumb" language ?

Thanks in advance.

Maurício Faria