unspusbctl.cpp

ActiveX sample

// UnSPUsbCtl.cpp : Implementation of the CUnSPUsbCtrl ActiveX Control class.

#include "stdafx.h"
#include "unSPUsb.h"
#include "UnSPUsbCtl.h"
#include "UnSPUsbPpg.h"

#include <direct.h>

////////////////////////////////////////////
#include "Rwbulk.h"
#include "stdio.h"     //for fread()
////////////////////////////////////////////


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


IMPLEMENT_DYNCREATE(CUnSPUsbCtrl, COleControl)


/////////////////////////////////////////////////////////////////////////////
// Message map

BEGIN_MESSAGE_MAP(CUnSPUsbCtrl, COleControl)
	//{{AFX_MSG_MAP(CUnSPUsbCtrl)
	// NOTE - ClassWizard will add and remove message map entries
	//    DO NOT EDIT what you see in these blocks of generated code !
	//}}AFX_MSG_MAP
	ON_OLEVERB(AFX_IDS_VERB_PROPERTIES, OnProperties)
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// Dispatch map

BEGIN_DISPATCH_MAP(CUnSPUsbCtrl, COleControl)
	//{{AFX_DISPATCH_MAP(CUnSPUsbCtrl)
	DISP_FUNCTION(CUnSPUsbCtrl, "UsbConnect", UsbConnect, VT_BOOL, VTS_NONE)
	DISP_FUNCTION(CUnSPUsbCtrl, "UsbDisconnect", UsbDisconnect, VT_BOOL, VTS_NONE)
	DISP_FUNCTION(CUnSPUsbCtrl, "UsbWrite", UsbWrite, VT_BOOL, VTS_BSTR)
	//}}AFX_DISPATCH_MAP
	DISP_FUNCTION_ID(CUnSPUsbCtrl, "AboutBox", DISPID_ABOUTBOX, AboutBox, VT_EMPTY, VTS_NONE)
END_DISPATCH_MAP()


/////////////////////////////////////////////////////////////////////////////
// Event map

BEGIN_EVENT_MAP(CUnSPUsbCtrl, COleControl)
	//{{AFX_EVENT_MAP(CUnSPUsbCtrl)
	// NOTE - ClassWizard will add and remove event map entries
	//    DO NOT EDIT what you see in these blocks of generated code !
	//}}AFX_EVENT_MAP
END_EVENT_MAP()


/////////////////////////////////////////////////////////////////////////////
// Property pages

// TODO: Add more property pages as needed.  Remember to increase the count!
BEGIN_PROPPAGEIDS(CUnSPUsbCtrl, 1)
	PROPPAGEID(CUnSPUsbPropPage::guid)
END_PROPPAGEIDS(CUnSPUsbCtrl)


/////////////////////////////////////////////////////////////////////////////
// Initialize class factory and guid

IMPLEMENT_OLECREATE_EX(CUnSPUsbCtrl, "UNSPUSB.UnSPUsbCtrl.1",
	0x72653ede, 0x9b42, 0x41ce, 0x9c, 0x26, 0xf0, 0x33, 0x7e, 0xa5, 0x3c, 0x88)


/////////////////////////////////////////////////////////////////////////////
// Type library ID and version

IMPLEMENT_OLETYPELIB(CUnSPUsbCtrl, _tlid, _wVerMajor, _wVerMinor)


/////////////////////////////////////////////////////////////////////////////
// Interface IDs

const IID BASED_CODE IID_DUnSPUsb =
		{ 0x74b8d031, 0xdb2e, 0x49a1, { 0x84, 0xb1, 0x31, 0x86, 0xfc, 0xb5, 0xd3, 0x9f } };
const IID BASED_CODE IID_DUnSPUsbEvents =
		{ 0xbdbdbf29, 0x3bc2, 0x4891, { 0x92, 0xb1, 0x69, 0x21, 0x1b, 0x5b, 0x7a, 0xba } };


/////////////////////////////////////////////////////////////////////////////
// Control type information

static const DWORD BASED_CODE _dwUnSPUsbOleMisc =
	OLEMISC_ACTIVATEWHENVISIBLE |
	OLEMISC_SETCLIENTSITEFIRST |
	OLEMISC_INSIDEOUT |
	OLEMISC_CANTLINKINSIDE |
	OLEMISC_RECOMPOSEONRESIZE;

IMPLEMENT_OLECTLTYPE(CUnSPUsbCtrl, IDS_UNSPUSB, _dwUnSPUsbOleMisc)


/////////////////////////////////////////////////////////////////////////////
// CUnSPUsbCtrl::CUnSPUsbCtrlFactory::UpdateRegistry -
// Adds or removes system registry entries for CUnSPUsbCtrl

BOOL CUnSPUsbCtrl::CUnSPUsbCtrlFactory::UpdateRegistry(BOOL bRegister)
{
	// TODO: Verify that your control follows apartment-model threading rules.
	// Refer to MFC TechNote 64 for more information.
	// If your control does not conform to the apartment-model rules, then
	// you must modify the code below, changing the 6th parameter from
	// afxRegApartmentThreading to 0.

	if (bRegister)
		return AfxOleRegisterControlClass(
			AfxGetInstanceHandle(),
			m_clsid,
			m_lpszProgID,
			IDS_UNSPUSB,
			IDB_UNSPUSB,
			afxRegApartmentThreading,
			_dwUnSPUsbOleMisc,
			_tlid,
			_wVerMajor,
			_wVerMinor);
	else
		return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
}


/////////////////////////////////////////////////////////////////////////////
// CUnSPUsbCtrl::CUnSPUsbCtrl - Constructor

CUnSPUsbCtrl::CUnSPUsbCtrl()
{
	InitializeIIDs(&IID_DUnSPUsb, &IID_DUnSPUsbEvents);

	// TODO: Initialize your control's instance data here.
}


/////////////////////////////////////////////////////////////////////////////
// CUnSPUsbCtrl::~CUnSPUsbCtrl - Destructor

CUnSPUsbCtrl::~CUnSPUsbCtrl()
{
	// TODO: Cleanup your control's instance data here.
}


/////////////////////////////////////////////////////////////////////////////
// CUnSPUsbCtrl::OnDraw - Drawing function

void CUnSPUsbCtrl::OnDraw(
			CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
{
	// TODO: Replace the following code with your own drawing code.
	pdc->FillRect(rcBounds, CBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH)));
	pdc->Ellipse(rcBounds);
}


/////////////////////////////////////////////////////////////////////////////
// CUnSPUsbCtrl::DoPropExchange - Persistence support

void CUnSPUsbCtrl::DoPropExchange(CPropExchange* pPX)
{
	ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
	COleControl::DoPropExchange(pPX);

	// TODO: Call PX_ functions for each persistent custom property.

}


/////////////////////////////////////////////////////////////////////////////
// CUnSPUsbCtrl::OnResetState - Reset control to default state

void CUnSPUsbCtrl::OnResetState()
{
	COleControl::OnResetState();  // Resets defaults found in DoPropExchange

	// TODO: Reset any other control state here.
}


/////////////////////////////////////////////////////////////////////////////
// CUnSPUsbCtrl::AboutBox - Display an "About" box to the user

void CUnSPUsbCtrl::AboutBox()
{
	CDialog dlgAbout(IDD_ABOUTBOX_UNSPUSB);
	dlgAbout.DoModal();
}


/////////////////////////////////////////////////////////////////////////////
// CUnSPUsbCtrl message handlers

BOOL CUnSPUsbCtrl::UsbConnect() 
{
	// Open Device
	char *filename1 = "PIPE02";
	char *filename2 = "PIPE03";

	UsbDisconnect();
	hDevice1 = open_file(filename1);  // open endpoint2 in
	hDevice2 = open_file(filename2);  // open endpoint2 out
	if (hDevice1 == INVALID_HANDLE_VALUE||hDevice2 == INVALID_HANDLE_VALUE)
	{
		return FALSE;
	}
	return TRUE;
}


/////////////////////////////////////////////////////////////////////////////
BOOL CUnSPUsbCtrl::UsbDisconnect() 
{
	if (hDevice1 != INVALID_HANDLE_VALUE)
	{
        CloseHandle(hDevice1);
        hDevice1 = INVALID_HANDLE_VALUE;
	}
	if (hDevice2 != INVALID_HANDLE_VALUE)
	{
	    CloseHandle(hDevice2);
	    hDevice2 = INVALID_HANDLE_VALUE;
	}
	return TRUE;
}



/////////////////////////////////////////////////////////////////////////////
//WINBASEAPI
//BOOL
//WINAPI
//WriteFile(
//    HANDLE hFile,
//    LPCVOID lpBuffer,
//    DWORD nNumberOfBytesToWrite,
//    LPDWORD lpNumberOfBytesWritten,
//    LPOVERLAPPED lpOverlapped
//    );
/////////////////////////////////////////////////////////////////////////////
//BOOL CUnSPUsbCtrl::UsbWrite(char *lpBuffer) 
//{
//    char WriteBuffer[64];
//	ULONG nWrite = 0;
//	CString sBuffer;
//	long lnBuffer;
//
//
//	if (hDevice1 == INVALID_HANDLE_VALUE||hDevice2 == INVALID_HANDLE_VALUE)
//	{
//		return FALSE;
//	}
//	sBuffer = lpBuffer;
//
//    lnBuffer = sBuffer.GetLength();
// 
//    WriteFile(hDevice2,WriteBuffer,64,&nWrite,NULL);
//
//	return TRUE;
//}

//BOOL CUnSPUsbCtrl::UsbWrite( int lpBuffer) 
//{
//	return TRUE;
//}

/////////////////////////////////////////////////////////////////////////////
//WINBASEAPI
//BOOL
//WINAPI
//ReadFile(
//    HANDLE hFile,
//    LPVOID lpBuffer,
//    DWORD nNumberOfBytesToRead,
//    LPDWORD lpNumberOfBytesRead,
//    LPOVERLAPPED lpOverlapped
//    );
/////////////////////////////////////////////////////////////////////////////
//BOOL CUnSPUsbCtrl::UsbRead() 
//{
//	if (hDevice1 == INVALID_HANDLE_VALUE||hDevice2 == INVALID_HANDLE_VALUE)
//	{
//		return FALSE;
//	}
//}

BOOL CUnSPUsbCtrl::UsbWrite(LPCTSTR lpBuffer) 
{
	int i = 0;
	int ln = 0;
	ULONG nWrite = 0;
//	char cBuffer[64];
    CString sBuffer = "";

//	AfxMessageBox(lpBuffer);

	sBuffer = lpBuffer;
    ln = sBuffer.GetLength();

	if(ln<1)
	{
		return FALSE;
	}
	if(ln>64)
	{
		ln = 64;
	}
	LPTSTR cBuffer = new TCHAR[ln];
	_tcscpy(cBuffer, sBuffer);

	for(i=0;i<64;i++)
	{
	    cBuffer[i] = (char)0xff; // Fill "FF" into all items.
	}
    strncpy(cBuffer,sBuffer,ln);
//	if(!UsbConnect())
//	{
//		return FALSE;
//	}
	if (hDevice1 == INVALID_HANDLE_VALUE||hDevice2 == INVALID_HANDLE_VALUE)
	{
		return FALSE;
	}
    WriteFile(hDevice2,cBuffer,64,&nWrite,NULL);

//	AfxMessageBox(cBuffer);

	return TRUE;
}