4. VC Programm mit BCC starten

VC Programm mit BCC starten

  • J

    Da bin ich wieder,

    nachdem ich einigen infos aus dem MFC Forum habe, könnt ihr mir hoffentlich jetzt etwas weiter helfen. Damit ich nicht alles wieder holen muss, hier der Beitrag aus dem MFC Forum:

    http://www.c-plusplus.net/forum/viewtopic-var-p-is-1558798.html#1558798

    Also das ganze ist ein ActiveX element, aber damit kann ich recht wenig anfangen, kann mir hier jemand sagen wei ich das umgesetzt bekomme?

    0
  • A

    Mir ist, als hätte man dir dort schon gesagt, was du tun sollst: in C++Builder gibt es einen Menueintrag, der ein ActiveX-Steuerelement oder eine Typbibliothek importiert (gewöhnlich im 'Komponente'-Menu); dort solltest du die entsprechende Typbibliothek auswählen, importieren und dir Wrapperklassen generieren lassen können.

    0
  • J

    Und da kommen wir zu dem punkt wo ich nicht weiter komme 🙂

    Ich hab mir die verschiednenen sachen da an geguckt aber werd da einfach nicht schlau draus.

    Ich würd ja mal sagen das ich ganz normal ein VLC Form Anwendungsprojekt erstelle und dann in der Tool Palette einer der ActiveX Objekte auswählen muss. Da hab ich eine Automatisierungsobjekt, ein Com-Objekt, einmal ActiveX-Bibliothek und einmal Typbibliothek. Von Importieren hab ich aber niegendwo was gefunden. 😞

    0
  • B

    Du schaust im falschen Bereich nach. Das ist für neue Projekte.
    Was du suchst ist im Hauptmenü unter Komponenten / Komponente importieren.

    0
  • J

    Danke Leute, ihr seid echt spitze!!

    Braunstein hat den richtigen Tipp geliefert.

    Jetzt funktioniert es und ich kann die Hardware ansteuern.

    0
  • J

    Ich hab jetzt noch ein Problem, und zwar geht es sich darum einen wert von der Hardware aus zu lesen. In VC ist das so gelöst:

    void CUsbxContDlg::OnMeasureArrivedUsbxctrl1(const VARIANT FAR& Measurement, short DeviceHandle) 
{
	CString tmp;

	m_selHandle.GetLBText(m_selHandle.GetCurSel(), tmp);
	if(DeviceHandle == atoi(tmp))
	{
		m_csCSTM = Measurement.bstrVal;			//set edit box with measurment.
	}
	UpdateData(false);
}

    und hier der aufruf:

    BEGIN_EVENTSINK_MAP(CUsbxContDlg, CDialog)
    //{{AFX_EVENTSINK_MAP(CUsbxContDlg)
	ON_EVENT(CUsbxContDlg, IDC_USBXCTRL1, 1 /* MeasureArrived */, OnMeasureArrivedUsbxctrl1, VTS_VARIANT VTS_I2)
	//}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()

    In Borland habe ich jetzt eine Eigenschaft (??) die OnMeasureArrived heißt. Aber ich bekomm der keine funktion zugewiesen so wie es mit buttons oder ähnlichem möglich ist.

    Ich hab jetzt quasi folgendes gemacht:

    void TForm1::OnMeasureArrivedUsbxctrl1(farVARIANT &Measurement, short DeviceHandle)
{
// einfach mal leer um zu gucken ob es vom Kompiler angenommen wird
}

void __fastcall TForm1::Button1Click(TObject *Sender)
{
    Test =new TOphirUsbX(Form1->Parent);
[...] // inizialiserung etc.
    Test->OnMeasureArrived=OnMeasureArrivedUsbxctrl1;
}

    Da kommt aber jetzt der fehler:

    [BCC32 Fehler] Main.cpp(56): E2034 Konvertierung von 'void (* (_closure )(const tagVARIANT &,short))(const tagVARIANT &,short)' nach 'TOphirUsbXMeasureArrived' nicht möglich

    Hab ich was vergessen? Bzw. was ist falsch? Wie mach ich es richtig?

    Danke schomal an alle!!

    0
  • ?

    JBOpael schrieb:

    Da kommt aber jetzt der fehler:

    [BCC32 Fehler] Main.cpp(56): E2034 Konvertierung von 'void (* (_closure )(const tagVARIANT &,short))(const tagVARIANT &,short)' nach 'TOphirUsbXMeasureArrived' nicht möglich

    Hab ich was vergessen? Bzw. was ist falsch? Wie mach ich es richtig?

    Das ist primär davon abhängig, wie genau TOphirUsbXMeasureArrived definiert ist 😉

    0
  • J

    Hallo,

    Das einzige was ich dazu gefunde habe ist das hier

    [...] 
 // OCX properties
  //

  // OCX Events
  //
  __property TOphirUsbXMeasureArrived OnMeasureArrived={ read=FOnMeasureArrived, write=FOnMeasureArrived };
}
    0
  • B

    Irgendwo muß auch die Deklaration von TOphirUsbXMeasureArrived stehen. Die mußt du finden.

    0
  • A

    Ctrl+Click auf den Typen in deiner .cpp-Datei hilft 😉

    0
  • J

    Ok, ich denke mal ihr meint das hier.

    // *********************************************************************//
// Definition of closures to allow VCL handlers to catch OCX events.      
// *********************************************************************//
typedef void __fastcall (__closure * TOphirUsbXMeasureArrived)(System::TObject * Sender, 
                                                               VARIANT Measurement, 
                                                               short DeviceHandle);

    Wie muss denn jetzt die Methode aussehen dich ich brauche?

    0
  • A

    JBOpael schrieb:

    Wie muss denn jetzt die Methode aussehen dich ich brauche?

    Ganz genauso. Gleiche Parameterliste, gleiche Aufrufkonvention, gleicher Rückgabewert.
    Ist das nicht eigentlich offensichtlich?

    0
  • J

    eigendlich schon, hab ich auch probiert aber irgendwie werd ich nicht so ganz schlau aus dem aufbau.

    hab das einfach mal so gemacht:

    [..]
Test->OnMeasureArrived=OnMeasureArrivedUsbxctrl1;
[..]

void __fastcall OnMeasureArrivedUsbxctrl1(System::TObject * Sender, VARIANT Measurement, short DeviceHandle)
{
//
}

    aber das geht nicht so. 😞

    0
  • A

    Wenn du jetzt daraus noch eine Memberfunktion machst, sollte es klappen.

    0
  • J

    Naja, darauf hätte ich wohl selber kommen können. war wohl zu Warm gestern 🙂

    Nächstes Problem.

    Hab dem Event jetzt die Methode zugewiesen, aber ausgeführt wird die Trotzdem nicht.

    Also hab folgendes gemacht:

    TOphirUsbX *Test;
	long w,meldung;
	tagVARIANT	var;
	short device;

void __fastcall TForm1::Button1Click(TObject *Sender)
{
	Test =new TOphirUsbX(Form1->Parent);
	Test->OnMeasureArrived=Messwert;
	w=Test->OpenUSB(&meldung);

	Test->GetErrorFromCode(meldung,&var);
	Label1->Caption=var.bstrVal;

	Test->GetDeviceHandle(0,&device);

	Test->GetErrorFromCode(meldung,&var);
	Label1->Caption=var.bstrVal;

	Label5->Caption=device;

}

void __fastcall TForm1::Button2Click(TObject *Sender)
{
	Test->StartCS(device,&var);

	Test->GetErrorFromCode(meldung,&var);
	Label1->Caption = var. bstrVal;
}

void __fastcall TForm1::Messwert(TObject * Sender, tagVARIANT Measurement, short DeviceHandle)
{
   Label2->Caption=Measurement.bstrVal ;
}

    Durch StartCS soll OnMeasureArrived Activiert werden (so interpretiere ich das zumindestens aus dem VC code). Was ich auch sehe ist das ein Thread gestartet wird, wenn ich startcs ausführe. Aber im Ereignis tut sich nichts. 😕

    0
  • A

    Irgendwo in dem Typelibrary-Wrapper sollte ein Event-Handler in Form einer gewaltigen switch-Anweisung generiert worden sein. Setze doch da mal einen Breakpoint rein und sieh zu, was passiert.

    0
  • J

    Sowas kann ich nicht finden.

    beim importieren der typbiblothek wurden 4 dateien erzeugt, 2 cpp und 2 h dateien. die eine heißt OphirUsbXLib_TLB und die andere OphirUsbXLib_OCX.

    das hier steht in der OphirUsbXLib_TLB:

    cpp:

    #include <vcl.h>
#pragma hdrstop

#include "OphirUsbXLib_TLB.h"

#if !defined(__PRAGMA_PACKAGE_SMART_INIT)
#define      __PRAGMA_PACKAGE_SMART_INIT
#pragma package(smart_init)
#endif

namespace Ophirusbxlib_tlb
{

// *********************************************************************//
// GUIDS declared in the TypeLibrary                                      
// *********************************************************************//
const GUID LIBID_OphirUsbXLib = {0x28DC9B10, 0xF17F, 0x49C7,{ 0x9B, 0x95, 0x66,0xE8, 0x45, 0x8D,0x39, 0x28} };
const GUID DIID__DUsbX = {0x28DC9B11, 0xF17F, 0x49C7,{ 0x9B, 0x95, 0x66,0xE8, 0x45, 0x8D,0x39, 0x28} };
const GUID DIID__DUsbXEvents = {0x28DC9B12, 0xF17F, 0x49C7,{ 0x9B, 0x95, 0x66,0xE8, 0x45, 0x8D,0x39, 0x28} };
const GUID CLSID_OphirUsbX = {0x28DC9B13, 0xF17F, 0x49C7,{ 0x9B, 0x95, 0x66,0xE8, 0x45, 0x8D,0x39, 0x28} };

};     // namespace Ophirusbxlib_tlb

    Header:

    #ifndef   OphirUsbXLib_TLBH
#define   OphirUsbXLib_TLBH

#pragma option push -b -w-inl

#if !defined(__UTILCLS_H)
#include <utilcls.h>
#endif
#if !defined(__UTILCLS_H_VERSION) || (__UTILCLS_H_VERSION < 0x0700)
//
// The code generated by the TLIBIMP utility or the Import|TypeLibrary 
// and Import|ActiveX feature of C++Builder rely on specific versions of
// the header file UTILCLS.H found in the INCLUDE\VCL directory. If an 
// older version of the file is detected, you probably need an update/patch.
//
#error "This file requires a newer version of the header UTILCLS.H" \
       "You need to apply an update/patch to your copy of C++Builder"
#endif
#include <olectl.h>
#include <ocidl.h>
#if defined(USING_ATLVCL) || defined(USING_ATL)
#if !defined(__TLB_NO_EVENT_WRAPPERS)
#include <atl/atlmod.h>
#endif
#endif

// *********************************************************************//
// Forward reference of some VCL types (to avoid including STDVCL.HPP)    
// *********************************************************************//
namespace Stdvcl {class IStrings; class IStringsDisp;}
using namespace Stdvcl;
typedef TComInterface<IStrings> IStringsPtr;
typedef TComInterface<IStringsDisp> IStringsDispPtr;

namespace Ophirusbxlib_tlb
{

// *********************************************************************//
// HelpString: OphirUsbX ActiveX Control module
// Version:    2.1
// *********************************************************************//

// *********************************************************************//
// GUIDS declared in the TypeLibrary. Following prefixes are used:        
//   Type Libraries     : LIBID_xxxx                                      
//   CoClasses          : CLSID_xxxx                                      
//   DISPInterfaces     : DIID_xxxx                                       
//   Non-DISP interfaces: IID_xxxx                                        
// *********************************************************************//
extern __declspec (package) const GUID LIBID_OphirUsbXLib;
extern __declspec (package) const GUID DIID__DUsbX;
extern __declspec (package) const GUID DIID__DUsbXEvents;
extern __declspec (package) const GUID CLSID_OphirUsbX;

// *********************************************************************//
// Forward declaration of types defined in TypeLibrary                    
// *********************************************************************//
interface DECLSPEC_UUID("{28DC9B11-F17F-49C7-9B95-66E8458D3928}") _DUsbX;
typedef TComInterface<_DUsbX, &DIID__DUsbX> _DUsbXPtr;

interface DECLSPEC_UUID("{28DC9B12-F17F-49C7-9B95-66E8458D3928}") _DUsbXEvents;
typedef TComInterface<_DUsbXEvents, &DIID__DUsbXEvents> _DUsbXEventsPtr;

// *********************************************************************//
// Declaration of CoClasses defined in Type Library                       
// (NOTE: Here we map each CoClass to its Default Interface)              
//                                                                        
// The LIBID_OF_ macro(s) map a LIBID_OF_CoClassName to the GUID of this  
// TypeLibrary. It simplifies the updating of macros when CoClass name    
// change.                                                                
// *********************************************************************//
typedef _DUsbX OphirUsbX;
typedef _DUsbXPtr OphirUsbXPtr;

#define LIBID_OF_OphirUsbX (&LIBID_OphirUsbXLib)
// *********************************************************************//
// Interface: _DUsbX
// Flags:     (4112) Hidden Dispatchable
// GUID:      {28DC9B11-F17F-49C7-9B95-66E8458D3928}
// *********************************************************************//
interface _DUsbX : public TDispWrapper<IDispatch>
{
  long __fastcall OpenUSB(long* lWarning)
  {
    _TDispID _dispid(/* OpenUSB */ DISPID(1));
    TAutoArgs<1> _args;
    _args[1] = lWarning /*[VT_I4:1]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall CloseUSB()
  {
    _TDispID _dispid(/* CloseUSB */ DISPID(2));
    TAutoArgs<0> _args;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall GetNumberOfDevices(short* DeviceNumber)
  {
    _TDispID _dispid(/* GetNumberOfDevices */ DISPID(3));
    TAutoArgs<1> _args;
    _args[1] = DeviceNumber /*[VT_I2:1]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall GetDeviceHandle(short DeviceIndex, short* DeviceHandle)
  {
    _TDispID _dispid(/* GetDeviceHandle */ DISPID(4));
    TAutoArgs<2> _args;
    _args[1] = DeviceIndex /*[VT_I2:0]*/;
    _args[2] = DeviceHandle /*[VT_I2:1]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall Write(short DeviceHandle, VARIANT Data)
  {
    _TDispID _dispid(/* Write */ DISPID(5));
    TAutoArgs<2> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    _args[2] = Data /*[VT_VARIANT:0]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall Read(short DeviceHandle, VARIANT* Data)
  {
    _TDispID _dispid(/* Read */ DISPID(6));
    TAutoArgs<2> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    _args[2] = Data /*[VT_VARIANT:1]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall DetectDevices()
  {
    _TDispID _dispid(/* DetectDevices */ DISPID(7));
    TAutoArgs<0> _args;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall RefreshDevice(short DeviceHandle)
  {
    _TDispID _dispid(/* RefreshDevice */ DISPID(8));
    TAutoArgs<1> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall GetErrorFromCode(long lErrorCode, VARIANT* varErrorString)
  {
    _TDispID _dispid(/* GetErrorFromCode */ DISPID(9));
    TAutoArgs<2> _args;
    _args[1] = lErrorCode /*[VT_I4:0]*/;
    _args[2] = varErrorString /*[VT_VARIANT:1]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall GetDriverVersion(short* nDriverVersion)
  {
    _TDispID _dispid(/* GetDriverVersion */ DISPID(10));
    TAutoArgs<1> _args;
    _args[1] = nDriverVersion /*[VT_I2:1]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall StopCS(short DeviceHandle)
  {
    _TDispID _dispid(/* StopCS */ DISPID(11));
    TAutoArgs<1> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall SelectInterface(short DeviceHandle, short InterfaceIndex)
  {
    _TDispID _dispid(/* SelectInterface */ DISPID(12));
    TAutoArgs<2> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    _args[2] = InterfaceIndex /*[VT_I2:0]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall RefreshAllDevices()
  {
    _TDispID _dispid(/* RefreshAllDevices */ DISPID(13));
    TAutoArgs<0> _args;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall StopAllCS()
  {
    _TDispID _dispid(/* StopAllCS */ DISPID(14));
    TAutoArgs<0> _args;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall StartCS(short DeviceHandle, VARIANT* varDeviceResponse)
  {
    _TDispID _dispid(/* StartCS */ DISPID(15));
    TAutoArgs<2> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    _args[2] = varDeviceResponse /*[VT_VARIANT:1]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall StartTM(short DeviceHandle, short PulseFrequency, VARIANT* varDeviceResponse)
  {
    _TDispID _dispid(/* StartTM */ DISPID(16));
    TAutoArgs<3> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    _args[2] = PulseFrequency /*[VT_I2:0]*/;
    _args[3] = varDeviceResponse /*[VT_VARIANT:1]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall SuspendStream(short DeviceHandle)
  {
    _TDispID _dispid(/* SuspendStream */ DISPID(17));
    TAutoArgs<1> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall ResumeStream(short DeviceHandle)
  {
    _TDispID _dispid(/* ResumeStream */ DISPID(18));
    TAutoArgs<1> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

  long __fastcall StopTM(short DeviceHandle)
  {
    _TDispID _dispid(/* StopTM */ DISPID(19));
    TAutoArgs<1> _args;
    _args[1] = DeviceHandle /*[VT_I2:0]*/;
    OleFunction(_dispid, _args);
    return _args.GetRetVariant();
  }

};
// *********************************************************************//
// Interface: _DUsbXEvents
// Flags:     (4096) Dispatchable
// GUID:      {28DC9B12-F17F-49C7-9B95-66E8458D3928}
// *********************************************************************//
interface _DUsbXEvents : public TDispWrapper<IDispatch>
{
  void __fastcall MeasureArrived(VARIANT Measurement, short DeviceHandle)
  {
    _TDispID _dispid(/* MeasureArrived */ DISPID(1));
    TAutoArgs<2> _args;
    _args[1] = Measurement /*[VT_VARIANT:0]*/;
    _args[2] = DeviceHandle /*[VT_I2:0]*/;
    OleProcedure(_dispid, _args);
  }

};
#if !defined(__TLB_NO_INTERFACE_WRAPPERS)
// *********************************************************************//
// DispIntf:  _DUsbX
// Flags:     (4112) Hidden Dispatchable
// GUID:      {28DC9B11-F17F-49C7-9B95-66E8458D3928}
// *********************************************************************//
template<class T>
class _DUsbXDispT : public TAutoDriver<_DUsbX>
{
public:
  _DUsbXDispT(){}

  _DUsbXDispT(_DUsbX *pintf)
  {
    TAutoDriver<_DUsbX>::Bind(pintf, false);
  }

  _DUsbXDispT(_DUsbXPtr pintf)
  {
    TAutoDriver<_DUsbX>::Bind(pintf, true);
  }

  _DUsbXDispT& operator=(_DUsbX *pintf)
  {
    TAutoDriver<_DUsbX>::Bind(pintf, false);
    return *this;
  }

  _DUsbXDispT& operator=(_DUsbXPtr pintf)
  {
    TAutoDriver<_DUsbX>::Bind(pintf, true);
    return *this;
  }

  HRESULT BindDefault()
  {
    return OLECHECK(Bind(CLSID_OphirUsbX));
  }

  HRESULT BindRunning()
  {
    return BindToActive(CLSID_OphirUsbX);
  }

  long            __fastcall OpenUSB(long* lWarning);
  long            __fastcall CloseUSB();
  long            __fastcall GetNumberOfDevices(short* DeviceNumber);
  long            __fastcall GetDeviceHandle(short DeviceIndex, short* DeviceHandle);
  long            __fastcall Write(short DeviceHandle, VARIANT Data);
  long            __fastcall Read(short DeviceHandle, VARIANT* Data);
  long            __fastcall DetectDevices();
  long            __fastcall RefreshDevice(short DeviceHandle);
  long            __fastcall GetErrorFromCode(long lErrorCode, VARIANT* varErrorString);
  long            __fastcall GetDriverVersion(short* nDriverVersion);
  long            __fastcall StopCS(short DeviceHandle);
  long            __fastcall SelectInterface(short DeviceHandle, short InterfaceIndex);
  long            __fastcall RefreshAllDevices();
  long            __fastcall StopAllCS();
  long            __fastcall StartCS(short DeviceHandle, VARIANT* varDeviceResponse);
  long            __fastcall StartTM(short DeviceHandle, short PulseFrequency, 
                                     VARIANT* varDeviceResponse);
  long            __fastcall SuspendStream(short DeviceHandle);
  long            __fastcall ResumeStream(short DeviceHandle);
  long            __fastcall StopTM(short DeviceHandle);

};
typedef _DUsbXDispT<_DUsbX> _DUsbXDisp;

// *********************************************************************//
// DispIntf:  _DUsbXEvents
// Flags:     (4096) Dispatchable
// GUID:      {28DC9B12-F17F-49C7-9B95-66E8458D3928}
// *********************************************************************//
template <class T>
class _DUsbXEventsDispT : public TAutoDriver<_DUsbXEvents>
{
public:
  _DUsbXEventsDispT(){}

  void Attach(LPUNKNOWN punk)
  { m_Dispatch = static_cast<T*>(punk); }

  void            __fastcall MeasureArrived(VARIANT Measurement, short DeviceHandle);

};
typedef _DUsbXEventsDispT<_DUsbXEvents> _DUsbXEventsDisp;

// *********************************************************************//
// DispIntf:  _DUsbX
// Flags:     (4112) Hidden Dispatchable
// GUID:      {28DC9B11-F17F-49C7-9B95-66E8458D3928}
// *********************************************************************//
template <class T> long __fastcall
_DUsbXDispT<T>::OpenUSB(long* lWarning)
{
  _TDispID _dispid(*this, OLETEXT("OpenUSB"), DISPID(1));
  TAutoArgs<1> _args;
  _args[1] = lWarning /*[VT_I4:1]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::CloseUSB()
{
  _TDispID _dispid(*this, OLETEXT("CloseUSB"), DISPID(2));
  TAutoArgs<0> _args;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::GetNumberOfDevices(short* DeviceNumber)
{
  _TDispID _dispid(*this, OLETEXT("GetNumberOfDevices"), DISPID(3));
  TAutoArgs<1> _args;
  _args[1] = DeviceNumber /*[VT_I2:1]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::GetDeviceHandle(short DeviceIndex, short* DeviceHandle)
{
  _TDispID _dispid(*this, OLETEXT("GetDeviceHandle"), DISPID(4));
  TAutoArgs<2> _args;
  _args[1] = DeviceIndex /*[VT_I2:0]*/;
  _args[2] = DeviceHandle /*[VT_I2:1]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::Write(short DeviceHandle, VARIANT Data)
{
  _TDispID _dispid(*this, OLETEXT("Write"), DISPID(5));
  TAutoArgs<2> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  _args[2] = Data /*[VT_VARIANT:0]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::Read(short DeviceHandle, VARIANT* Data)
{
  _TDispID _dispid(*this, OLETEXT("Read"), DISPID(6));
  TAutoArgs<2> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  _args[2] = Data /*[VT_VARIANT:1]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::DetectDevices()
{
  _TDispID _dispid(*this, OLETEXT("DetectDevices"), DISPID(7));
  TAutoArgs<0> _args;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::RefreshDevice(short DeviceHandle)
{
  _TDispID _dispid(*this, OLETEXT("RefreshDevice"), DISPID(8));
  TAutoArgs<1> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::GetErrorFromCode(long lErrorCode, VARIANT* varErrorString)
{
  _TDispID _dispid(*this, OLETEXT("GetErrorFromCode"), DISPID(9));
  TAutoArgs<2> _args;
  _args[1] = lErrorCode /*[VT_I4:0]*/;
  _args[2] = varErrorString /*[VT_VARIANT:1]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::GetDriverVersion(short* nDriverVersion)
{
  _TDispID _dispid(*this, OLETEXT("GetDriverVersion"), DISPID(10));
  TAutoArgs<1> _args;
  _args[1] = nDriverVersion /*[VT_I2:1]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::StopCS(short DeviceHandle)
{
  _TDispID _dispid(*this, OLETEXT("StopCS"), DISPID(11));
  TAutoArgs<1> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::SelectInterface(short DeviceHandle, short InterfaceIndex)
{
  _TDispID _dispid(*this, OLETEXT("SelectInterface"), DISPID(12));
  TAutoArgs<2> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  _args[2] = InterfaceIndex /*[VT_I2:0]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::RefreshAllDevices()
{
  _TDispID _dispid(*this, OLETEXT("RefreshAllDevices"), DISPID(13));
  TAutoArgs<0> _args;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::StopAllCS()
{
  _TDispID _dispid(*this, OLETEXT("StopAllCS"), DISPID(14));
  TAutoArgs<0> _args;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::StartCS(short DeviceHandle, VARIANT* varDeviceResponse)
{
  _TDispID _dispid(*this, OLETEXT("StartCS"), DISPID(15));
  TAutoArgs<2> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  _args[2] = varDeviceResponse /*[VT_VARIANT:1]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::StartTM(short DeviceHandle, short PulseFrequency, VARIANT* varDeviceResponse)
{
  _TDispID _dispid(*this, OLETEXT("StartTM"), DISPID(16));
  TAutoArgs<3> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  _args[2] = PulseFrequency /*[VT_I2:0]*/;
  _args[3] = varDeviceResponse /*[VT_VARIANT:1]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::SuspendStream(short DeviceHandle)
{
  _TDispID _dispid(*this, OLETEXT("SuspendStream"), DISPID(17));
  TAutoArgs<1> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::ResumeStream(short DeviceHandle)
{
  _TDispID _dispid(*this, OLETEXT("ResumeStream"), DISPID(18));
  TAutoArgs<1> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

template <class T> long __fastcall
_DUsbXDispT<T>::StopTM(short DeviceHandle)
{
  _TDispID _dispid(*this, OLETEXT("StopTM"), DISPID(19));
  TAutoArgs<1> _args;
  _args[1] = DeviceHandle /*[VT_I2:0]*/;
  OleFunction(_dispid, _args);
  return _args.GetRetVariant();
}

// *********************************************************************//
// DispIntf:  _DUsbXEvents
// Flags:     (4096) Dispatchable
// GUID:      {28DC9B12-F17F-49C7-9B95-66E8458D3928}
// *********************************************************************//
template <class T> void __fastcall
_DUsbXEventsDispT<T>::MeasureArrived(VARIANT Measurement, short DeviceHandle)
{
  _TDispID _dispid(/* MeasureArrived */ DISPID(1));
  TAutoArgs<2> _args;
  _args[1] = Measurement /*[VT_VARIANT:0]*/;
  _args[2] = DeviceHandle /*[VT_I2:0]*/;
  OleProcedure(_dispid, _args);
}

#endif  //   __TLB_NO_INTERFACE_WRAPPERS

#if !defined(__TLB_NO_EVENT_WRAPPERS) && defined(USING_ATLVCL)
// *********************************************************************//
// CONNECTIONPOINT/EVENT PROXY
// CoClass         : OphirUsbX
// Event Interface : _DUsbXEvents
// *********************************************************************//
template <class T>
class TEvents_OphirUsbX : public IConnectionPointImpl<T,
                                                 &DIID__DUsbXEvents,
#if !defined(_TLB_DYNAMIC_CONNECTIONPOINT_ARRAY)
                                                 CComUnkArray<CONNECTIONPOINT_ARRAY_SIZE> >
#else
                                                 CComDynamicArray>
#endif
{
public:
  void            Fire_MeasureArrived(VARIANT Measurement, short DeviceHandle);
protected:
  _DUsbXEventsDisp m_EventIntfObj;
};

template <class T> void
TEvents_OphirUsbX<T>::Fire_MeasureArrived(VARIANT Measurement, short DeviceHandle)
{
  T * pT = (T*)this;
  pT->Lock();
  IUnknown ** pp = m_vec.begin();
  while (pp < m_vec.end())
  {
    if (*pp != NULL)
    {
      m_EventIntfObj.Attach(*pp);
      m_EventIntfObj.MeasureArrived(Measurement, DeviceHandle);
      m_EventIntfObj.Attach(0);
    }
    pp++;
  }
  pT->Unlock();
}

#endif  //   __TLB_NO_EVENT_WRAPPERS

};     // namespace Ophirusbxlib_tlb

#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using  namespace Ophirusbxlib_tlb;
#endif

#pragma option pop

#endif // OphirUsbXLib_TLBH

    steht da das drin was du meinst? oder sollich die andere auch noch posten?

    0
  • J

    Ich komm nicht weiter 😞

    Das event wird asu irgend einem grund nicht ausgeführt. aber wie kann ich das Kontrollieren? ich hab an verschiedenen stellen die aufgerufen werden müssten haltepunkte eingefügt, aber an keiner dieser stellen passiert etwas.

    bin echt ratlos 😕

    0
  • B

    Ich sehe hier keinen Eventhandler. Du hattest mal das hier gepostet.

    BEGIN_EVENTSINK_MAP(CUsbxContDlg, CDialog)
    //{{AFX_EVENTSINK_MAP(CUsbxContDlg)
    ON_EVENT(CUsbxContDlg, IDC_USBXCTRL1, 1 /* MeasureArrived */, OnMeasureArrivedUsbxctrl1, VTS_VARIANT VTS_I2)
    //}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()

    Dies ist wohl eine Eventhandler für MFC. Ob der so bei einem BCB-Projekt funktioniert, weiß ich nicht. Eigentlich mußt du ja nichts weiter machen, als die Dispatch-Funktion deiner Form zu überschreiben und dort den Event abzufangen. Wie das hier konkret geht weiß ich aber auch nicht. Das ist halt alles ganz schön mit MFC vermengt.

    0
  • J

    Das it ja das gleich wie das hier:

    Test->OnMeasureArrived=Messwert;

    würde ich mal behaupten.

    aber OnMeasureArrived wird nicht ausgeführt und nu bin ich auf der suche warum das nicht ausgeführt wird.

    0
Anmelden zum Antworten