// ************************************************************************ //
// AVERTISSEMENT                                                                 
// -------                                                                    
// Les types déclarés dans ce fichier ont été générés à partir de données lues 
// depuis la bibliothèque de types. Si cette dernière (via une autre bibliothèque de types 
// s'y référant) est explicitement ou indirectement ré-importée, ou la commande "Rafraîchir"  
// de l'éditeur de bibliothèque de types est activée lors de la modification de la bibliothèque 
// de types, le contenu de ce fichier sera régénéré et toutes les modifications      
// manuellement apportées seront perdues.                                     
// ************************************************************************ //

// C++ TLBWRTR : $Revision:   1.134.1.41  $
// Fichier généré le 18.01.2004 10:54:41 depuis la bibliothèque de types ci-dessous.

// ************************************************************************ //
// Bibl.Types     : C:\DLPOrt\Cbuilder5\OCX\PortOCXControl\DLPortIOCX.tlb (1)
// IID\LCID       : {2FB8B2BF-D936-41D9-8270-C43A9C755D74}\0
// Fichier d'aide : 
// DepndLst       : 
//   (1) v2.0 stdole, (C:\WINDOWS\SYSTEM\stdole2.tlb)
//   (2) v4.0 StdVCL, (C:\WINDOWS\SYSTEM\STDVCL40.DLL)
// ************************************************************************ //
#ifndef   __DLPortIOCX_TLB_h__
#define   __DLPortIOCX_TLB_h__

#pragma option push -b -w-inl

#include <utilcls.h>
#if !defined(__UTILCLS_H_VERSION) || (__UTILCLS_H_VERSION < 0x0500)
//
// Le code généré par l'utilitaire TLIBIMP ou par les fonctionnalités Import|TypeLibrary 
// et Import|ActiveX de C++Builder dépendent des versions spécifiques du fichier 
// en-tête UTILCLS.H trouvé dans le répertoire INCLUDE\VCL. Si une version plus 
// ancienne du fichier est détectée, vous avez probablement besoin d'une mise à jour.
//
#error "Ce fichier a besoin d'une version plus récente du fichier en-tête UTILCLS.H" \
       "Vous devez appliquer une mise à jour à votre copie de 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


// *********************************************************************//
// Référence Forward à certains types VCL (pour éviter d'inclure STDVCL.HPP)    
// *********************************************************************//
namespace Stdvcl {class IStrings; class IStringsDisp;}
using namespace Stdvcl;
typedef TComInterface<IStrings> IStringsPtr;
typedef TComInterface<IStringsDisp> IStringsDispPtr;

namespace Dlportiocx_tlb
{

// *********************************************************************//
// Chaîne d'aide : DLPortIOCXControl1 (bibliothèque)
// Version :    1.0
// *********************************************************************//


// *********************************************************************//
// GUIDS déclarés dans la bibliothèque de types. Préfixes utilisés :    
//   Bibliothèques de types : LIBID_xxxx                                      
//   CoClasses              : CLSID_xxxx                                      
//   DISPInterfaces         : DIID_xxxx                                       
//   Non-DISP interfaces    : IID_xxxx                                        
// *********************************************************************//
extern __declspec (package) const GUID LIBID_DLPortIOCX;
extern __declspec (package) const GUID IID_IDLPortIOCX;
extern __declspec (package) const GUID DIID_IDLPortIOCXEvents;
extern __declspec (package) const GUID CLSID_DLPortIOCX;

// *********************************************************************//
// Déclaration Forward des types définis dans la bibliothèque de types    
// *********************************************************************//
interface DECLSPEC_UUID("{14B807FE-32D5-462E-B593-2816DAABB947}") IDLPortIOCX;
typedef TComInterface<IDLPortIOCX, &IID_IDLPortIOCX> IDLPortIOCXPtr;
interface DECLSPEC_UUID("{D54AC1B5-B32A-4683-A1F7-23B5C66ECA23}") IDLPortIOCXEvents;
typedef TComInterface<IDLPortIOCXEvents, &DIID_IDLPortIOCXEvents> IDLPortIOCXEventsPtr;

// *********************************************************************//
// Déclaration des CoClasses définies dans la bibliothèque de types    
// (REMARQUE : On affecte chaque CoClass à son Interface par défaut)              
//                                                                        
// Les macros LIBID_OF_ affectent un LIBID_OF_CoClassName au GUID de 
// cette Bibliothèque de types. Cela simplifie la mise à jour des macros lorsque le nom 
// de CoClass change.                                                           
// *********************************************************************//
typedef IDLPortIOCX DLPortIOCX;
typedef IDLPortIOCXPtr DLPortIOCXPtr;

#define LIBID_OF_DLPortIOCX (&LIBID_DLPortIOCX)
// *********************************************************************//
// Interface   : IDLPortIOCX
// Indicateurs : (4416) Dual OleAutomation Dispatchable
// GUID        : {14B807FE-32D5-462E-B593-2816DAABB947}
// *********************************************************************//
interface IDLPortIOCX  : public IDispatch
{
public:
  virtual HRESULT STDMETHODCALLTYPE OpenDriver(void) = 0; // [1]
  virtual HRESULT STDMETHODCALLTYPE CloseDriver(void) = 0; // [2]
  virtual HRESULT STDMETHODCALLTYPE ReadPortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, 
                                                 long Buffer/*[in]*/) = 0; // [5]
  virtual HRESULT STDMETHODCALLTYPE WritePortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, 
                                                  long Buffer/*[in]*/) = 0; // [6]
  virtual HRESULT STDMETHODCALLTYPE ReadPort(long Address/*[in]*/, short* Value/*[out,retval]*/) = 0; // [7]
  virtual HRESULT STDMETHODCALLTYPE WritePort(long Address/*[in]*/, short Data/*[in]*/) = 0; // [8]
  virtual HRESULT STDMETHODCALLTYPE GetLPTBasePort(short PortNr/*[in]*/, long* Value/*[out,retval]*/) = 0; // [9]
  virtual HRESULT STDMETHODCALLTYPE get_DriverPath(BSTR* Value/*[out,retval]*/) = 0; // [10]
  virtual HRESULT STDMETHODCALLTYPE set_DriverPath(BSTR Value/*[in]*/) = 0; // [10]
  virtual HRESULT STDMETHODCALLTYPE get_DLLPath(BSTR* Value/*[out,retval]*/) = 0; // [11]
  virtual HRESULT STDMETHODCALLTYPE set_DLLPath(BSTR Value/*[in]*/) = 0; // [11]
  virtual HRESULT STDMETHODCALLTYPE get_ActiveHW(TOLEBOOL* Value/*[out,retval]*/) = 0; // [12]
  virtual HRESULT STDMETHODCALLTYPE get_HardAccess(TOLEBOOL* Value/*[out,retval]*/) = 0; // [13]
  virtual HRESULT STDMETHODCALLTYPE set_HardAccess(TOLEBOOL Value/*[in]*/) = 0; // [13]
  virtual HRESULT STDMETHODCALLTYPE get_LastError(BSTR* Value/*[out,retval]*/) = 0; // [14]
  virtual HRESULT STDMETHODCALLTYPE get_LPTNumPorts(unsigned_char* Value/*[out,retval]*/) = 0; // [15]
  virtual HRESULT STDMETHODCALLTYPE get_DoubleBuffered(TOLEBOOL* Value/*[out,retval]*/) = 0; // [16]
  virtual HRESULT STDMETHODCALLTYPE set_DoubleBuffered(TOLEBOOL Value/*[in]*/) = 0; // [16]
  virtual HRESULT STDMETHODCALLTYPE get_VisibleDockClientCount(long* Value/*[out,retval]*/) = 0; // [17]
  virtual HRESULT STDMETHODCALLTYPE DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/) = 0; // [19]
  virtual HRESULT STDMETHODCALLTYPE get_Enabled(TOLEBOOL* Value/*[out,retval]*/) = 0; // [-514]
  virtual HRESULT STDMETHODCALLTYPE set_Enabled(TOLEBOOL Value/*[in]*/) = 0; // [-514]
  virtual HRESULT STDMETHODCALLTYPE InitiateAction(void) = 0; // [20]
  virtual HRESULT STDMETHODCALLTYPE IsRightToLeft(TOLEBOOL* Value/*[out,retval]*/) = 0; // [21]
  virtual HRESULT STDMETHODCALLTYPE UseRightToLeftReading(TOLEBOOL* Value/*[out,retval]*/) = 0; // [24]
  virtual HRESULT STDMETHODCALLTYPE UseRightToLeftScrollBar(TOLEBOOL* Value/*[out,retval]*/) = 0; // [25]
  virtual HRESULT STDMETHODCALLTYPE get_Visible(TOLEBOOL* Value/*[out,retval]*/) = 0; // [26]
  virtual HRESULT STDMETHODCALLTYPE set_Visible(TOLEBOOL Value/*[in]*/) = 0; // [26]
  virtual HRESULT STDMETHODCALLTYPE get_Cursor(short* Value/*[out,retval]*/) = 0; // [27]
  virtual HRESULT STDMETHODCALLTYPE set_Cursor(short Value/*[in]*/) = 0; // [27]
  virtual HRESULT STDMETHODCALLTYPE AboutBox(void) = 0; // [-552]

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

  short __fastcall ReadPort(long Address/*[in]*/)
  {
    short Value;
    OLECHECK(this->ReadPort(Address, (short*)&Value));
    return Value;
  }

  long __fastcall GetLPTBasePort(short PortNr/*[in]*/)
  {
    long Value;
    OLECHECK(this->GetLPTBasePort(PortNr, (long*)&Value));
    return Value;
  }

  BSTR __fastcall get_DriverPath(void)
  {
    BSTR Value = 0;
    OLECHECK(this->get_DriverPath((BSTR*)&Value));
    return Value;
  }

  BSTR __fastcall get_DLLPath(void)
  {
    BSTR Value = 0;
    OLECHECK(this->get_DLLPath((BSTR*)&Value));
    return Value;
  }

  TOLEBOOL __fastcall get_ActiveHW(void)
  {
    TOLEBOOL Value;
    OLECHECK(this->get_ActiveHW((TOLEBOOL*)&Value));
    return Value;
  }

  TOLEBOOL __fastcall get_HardAccess(void)
  {
    TOLEBOOL Value;
    OLECHECK(this->get_HardAccess((TOLEBOOL*)&Value));
    return Value;
  }

  BSTR __fastcall get_LastError(void)
  {
    BSTR Value = 0;
    OLECHECK(this->get_LastError((BSTR*)&Value));
    return Value;
  }

  unsigned_char __fastcall get_LPTNumPorts(void)
  {
    unsigned_char Value;
    OLECHECK(this->get_LPTNumPorts((unsigned_char*)&Value));
    return Value;
  }

  TOLEBOOL __fastcall get_DoubleBuffered(void)
  {
    TOLEBOOL Value;
    OLECHECK(this->get_DoubleBuffered((TOLEBOOL*)&Value));
    return Value;
  }

  long __fastcall get_VisibleDockClientCount(void)
  {
    long Value;
    OLECHECK(this->get_VisibleDockClientCount((long*)&Value));
    return Value;
  }

  long __fastcall DrawTextBiDiModeFlagsReadingOnly(void)
  {
    long Value;
    OLECHECK(this->DrawTextBiDiModeFlagsReadingOnly((long*)&Value));
    return Value;
  }

  TOLEBOOL __fastcall get_Enabled(void)
  {
    TOLEBOOL Value;
    OLECHECK(this->get_Enabled((TOLEBOOL*)&Value));
    return Value;
  }

  TOLEBOOL __fastcall IsRightToLeft(void)
  {
    TOLEBOOL Value;
    OLECHECK(this->IsRightToLeft((TOLEBOOL*)&Value));
    return Value;
  }

  TOLEBOOL __fastcall UseRightToLeftReading(void)
  {
    TOLEBOOL Value;
    OLECHECK(this->UseRightToLeftReading((TOLEBOOL*)&Value));
    return Value;
  }

  TOLEBOOL __fastcall UseRightToLeftScrollBar(void)
  {
    TOLEBOOL Value;
    OLECHECK(this->UseRightToLeftScrollBar((TOLEBOOL*)&Value));
    return Value;
  }

  TOLEBOOL __fastcall get_Visible(void)
  {
    TOLEBOOL Value;
    OLECHECK(this->get_Visible((TOLEBOOL*)&Value));
    return Value;
  }

  short __fastcall get_Cursor(void)
  {
    short Value;
    OLECHECK(this->get_Cursor((short*)&Value));
    return Value;
  }


  __property   BSTR            DriverPath = {read = get_DriverPath, write = set_DriverPath};
  __property   BSTR            DLLPath = {read = get_DLLPath, write = set_DLLPath};
  __property   TOLEBOOL        ActiveHW = {read = get_ActiveHW};
  __property   TOLEBOOL        HardAccess = {read = get_HardAccess, write = set_HardAccess};
  __property   BSTR            LastError = {read = get_LastError};
  __property   unsigned_char   LPTNumPorts = {read = get_LPTNumPorts};
  __property   TOLEBOOL        DoubleBuffered = {read = get_DoubleBuffered, write = set_DoubleBuffered};
  __property   long            VisibleDockClientCount = {read = get_VisibleDockClientCount};
  __property   TOLEBOOL        Enabled = {read = get_Enabled, write = set_Enabled};
  __property   TOLEBOOL        Visible = {read = get_Visible, write = set_Visible};
  __property   short           Cursor = {read = get_Cursor, write = set_Cursor};

#endif //   __TLB_NO_INTERFACE_WRAPPERS

};

// *********************************************************************//
// Interface   : IDLPortIOCXEvents
// Indicateurs : (0)
// GUID        : {D54AC1B5-B32A-4683-A1F7-23B5C66ECA23}
// *********************************************************************//
interface IDLPortIOCXEvents : public TDispWrapper<IDispatch>
{

};
#if !defined(__TLB_NO_INTERFACE_WRAPPERS)
// *********************************************************************//
// SmartIntf: TCOMIDLPortIOCX
// Interface: IDLPortIOCX
// *********************************************************************//
template <class T /* IDLPortIOCX */ >
class TCOMIDLPortIOCXT : public TComInterface<IDLPortIOCX>, public TComInterfaceBase<IUnknown>
{
public:
  TCOMIDLPortIOCXT() {}
  TCOMIDLPortIOCXT(IDLPortIOCX *intf, bool addRef = false) : TComInterface<IDLPortIOCX>(intf, addRef) {}
  TCOMIDLPortIOCXT(const TCOMIDLPortIOCXT& src) : TComInterface<IDLPortIOCX>(src) {}
  TCOMIDLPortIOCXT& operator=(const TCOMIDLPortIOCXT& src) { Bind(src, true); return *this;}

  HRESULT         __fastcall OpenDriver(void);
  HRESULT         __fastcall CloseDriver(void);
  HRESULT         __fastcall ReadPortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, 
                                          long Buffer/*[in]*/);
  HRESULT         __fastcall WritePortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, 
                                           long Buffer/*[in]*/);
  HRESULT         __fastcall ReadPort(long Address/*[in]*/, short* Value/*[out,retval]*/);
  short           __fastcall ReadPort(long Address/*[in]*/);
  HRESULT         __fastcall WritePort(long Address/*[in]*/, short Data/*[in]*/);
  HRESULT         __fastcall GetLPTBasePort(short PortNr/*[in]*/, long* Value/*[out,retval]*/);
  long            __fastcall GetLPTBasePort(short PortNr/*[in]*/);
  HRESULT         __fastcall get_DriverPath(BSTR* Value/*[out,retval]*/);
  BSTR            __fastcall get_DriverPath(void);
  HRESULT         __fastcall set_DriverPath(BSTR Value/*[in]*/);
  HRESULT         __fastcall get_DLLPath(BSTR* Value/*[out,retval]*/);
  BSTR            __fastcall get_DLLPath(void);
  HRESULT         __fastcall set_DLLPath(BSTR Value/*[in]*/);
  HRESULT         __fastcall get_ActiveHW(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_ActiveHW(void);
  HRESULT         __fastcall get_HardAccess(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_HardAccess(void);
  HRESULT         __fastcall set_HardAccess(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_LastError(BSTR* Value/*[out,retval]*/);
  BSTR            __fastcall get_LastError(void);
  HRESULT         __fastcall get_LPTNumPorts(unsigned_char* Value/*[out,retval]*/);
  unsigned_char   __fastcall get_LPTNumPorts(void);
  HRESULT         __fastcall get_DoubleBuffered(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_DoubleBuffered(void);
  HRESULT         __fastcall set_DoubleBuffered(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_VisibleDockClientCount(long* Value/*[out,retval]*/);
  long            __fastcall get_VisibleDockClientCount(void);
  HRESULT         __fastcall DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/);
  long            __fastcall DrawTextBiDiModeFlagsReadingOnly(void);
  HRESULT         __fastcall get_Enabled(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Enabled(void);
  HRESULT         __fastcall set_Enabled(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall InitiateAction(void);
  HRESULT         __fastcall IsRightToLeft(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall IsRightToLeft(void);
  HRESULT         __fastcall UseRightToLeftReading(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall UseRightToLeftReading(void);
  HRESULT         __fastcall UseRightToLeftScrollBar(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall UseRightToLeftScrollBar(void);
  HRESULT         __fastcall get_Visible(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Visible(void);
  HRESULT         __fastcall set_Visible(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_Cursor(short* Value/*[out,retval]*/);
  short           __fastcall get_Cursor(void);
  HRESULT         __fastcall set_Cursor(short Value/*[in]*/);
  HRESULT         __fastcall AboutBox(void);

  __property   BSTR            DriverPath = {read = get_DriverPath, write = set_DriverPath};
  __property   BSTR            DLLPath = {read = get_DLLPath, write = set_DLLPath};
  __property   TOLEBOOL        ActiveHW = {read = get_ActiveHW};
  __property   TOLEBOOL        HardAccess = {read = get_HardAccess, write = set_HardAccess};
  __property   BSTR            LastError = {read = get_LastError};
  __property   unsigned_char   LPTNumPorts = {read = get_LPTNumPorts};
  __property   TOLEBOOL        DoubleBuffered = {read = get_DoubleBuffered, write = set_DoubleBuffered};
  __property   long            VisibleDockClientCount = {read = get_VisibleDockClientCount};
  __property   TOLEBOOL        Enabled = {read = get_Enabled, write = set_Enabled};
  __property   TOLEBOOL        Visible = {read = get_Visible, write = set_Visible};
  __property   short           Cursor = {read = get_Cursor, write = set_Cursor};
};
typedef TCOMIDLPortIOCXT<IDLPortIOCX> TCOMIDLPortIOCX;

// *********************************************************************//
// DispIntf:  IDLPortIOCX
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {14B807FE-32D5-462E-B593-2816DAABB947}
// *********************************************************************//
template<class T>
class IDLPortIOCXDispT : public TAutoDriver<IDLPortIOCX>
{
public:
  IDLPortIOCXDispT(){}

  IDLPortIOCXDispT(IDLPortIOCX *pintf)
  {
    TAutoDriver<IDLPortIOCX>::Bind(pintf, false);
  }

  IDLPortIOCXDispT(IDLPortIOCXPtr pintf)
  {
    TAutoDriver<IDLPortIOCX>::Bind(pintf, true);
  }

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

  IDLPortIOCXDispT& operator=(IDLPortIOCXPtr pintf)
  {
    TAutoDriver<IDLPortIOCX>::Bind(pintf, true);
    return *this;
  }

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

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

  HRESULT         __fastcall OpenDriver();
  HRESULT         __fastcall CloseDriver();
  HRESULT         __fastcall ReadPortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, 
                                          long Buffer/*[in]*/);
  HRESULT         __fastcall WritePortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, 
                                           long Buffer/*[in]*/);
  HRESULT         __fastcall ReadPort(long Address/*[in]*/, short* Value/*[out,retval]*/);
  short           __fastcall ReadPort(long Address/*[in]*/);
  HRESULT         __fastcall WritePort(long Address/*[in]*/, short Data/*[in]*/);
  HRESULT         __fastcall GetLPTBasePort(short PortNr/*[in]*/, long* Value/*[out,retval]*/);
  long            __fastcall GetLPTBasePort(short PortNr/*[in]*/);
  HRESULT         __fastcall get_DriverPath(BSTR* Value/*[out,retval]*/);
  BSTR            __fastcall get_DriverPath(void);
  HRESULT         __fastcall set_DriverPath(BSTR Value/*[in]*/);
  HRESULT         __fastcall get_DLLPath(BSTR* Value/*[out,retval]*/);
  BSTR            __fastcall get_DLLPath(void);
  HRESULT         __fastcall set_DLLPath(BSTR Value/*[in]*/);
  HRESULT         __fastcall get_ActiveHW(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_ActiveHW(void);
  HRESULT         __fastcall get_HardAccess(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_HardAccess(void);
  HRESULT         __fastcall set_HardAccess(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_LastError(BSTR* Value/*[out,retval]*/);
  BSTR            __fastcall get_LastError(void);
  HRESULT         __fastcall get_LPTNumPorts(unsigned_char* Value/*[out,retval]*/);
  unsigned_char   __fastcall get_LPTNumPorts(void);
  HRESULT         __fastcall get_DoubleBuffered(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_DoubleBuffered(void);
  HRESULT         __fastcall set_DoubleBuffered(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_VisibleDockClientCount(long* Value/*[out,retval]*/);
  long            __fastcall get_VisibleDockClientCount(void);
  HRESULT         __fastcall DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/);
  long            __fastcall DrawTextBiDiModeFlagsReadingOnly(void);
  HRESULT         __fastcall get_Enabled(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Enabled(void);
  HRESULT         __fastcall set_Enabled(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall InitiateAction();
  HRESULT         __fastcall IsRightToLeft(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall IsRightToLeft(void);
  HRESULT         __fastcall UseRightToLeftReading(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall UseRightToLeftReading(void);
  HRESULT         __fastcall UseRightToLeftScrollBar(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall UseRightToLeftScrollBar(void);
  HRESULT         __fastcall get_Visible(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Visible(void);
  HRESULT         __fastcall set_Visible(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_Cursor(short* Value/*[out,retval]*/);
  short           __fastcall get_Cursor(void);
  HRESULT         __fastcall set_Cursor(short Value/*[in]*/);
  HRESULT         __fastcall AboutBox();

  __property   BSTR            DriverPath = {read = get_DriverPath, write = set_DriverPath};
  __property   BSTR            DLLPath = {read = get_DLLPath, write = set_DLLPath};
  __property   TOLEBOOL        ActiveHW = {read = get_ActiveHW};
  __property   TOLEBOOL        HardAccess = {read = get_HardAccess, write = set_HardAccess};
  __property   BSTR            LastError = {read = get_LastError};
  __property   unsigned_char   LPTNumPorts = {read = get_LPTNumPorts};
  __property   TOLEBOOL        DoubleBuffered = {read = get_DoubleBuffered, write = set_DoubleBuffered};
  __property   long            VisibleDockClientCount = {read = get_VisibleDockClientCount};
  __property   TOLEBOOL        Enabled = {read = get_Enabled, write = set_Enabled};
  __property   TOLEBOOL        Visible = {read = get_Visible, write = set_Visible};
  __property   short           Cursor = {read = get_Cursor, write = set_Cursor};
};
typedef IDLPortIOCXDispT<IDLPortIOCX> IDLPortIOCXDisp;

// *********************************************************************//
// DispIntf:  IDLPortIOCXEvents
// Flags:     (0)
// GUID:      {D54AC1B5-B32A-4683-A1F7-23B5C66ECA23}
// *********************************************************************//
template <class T>
class IDLPortIOCXEventsDispT : public TAutoDriver<IDLPortIOCXEvents>
{
public:
  IDLPortIOCXEventsDispT(){}

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


};
typedef IDLPortIOCXEventsDispT<IDLPortIOCXEvents> IDLPortIOCXEventsDisp;

// *********************************************************************//
// SmartIntf: TCOMIDLPortIOCX
// Interface: IDLPortIOCX
// *********************************************************************//
template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::OpenDriver(void)
{
  return (*this)->OpenDriver();
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::CloseDriver(void)
{
  return (*this)->CloseDriver();
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::ReadPortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, long Buffer/*[in]*/)
{
  return (*this)->ReadPortFIFO(PortAddr, NumPorts, Buffer);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::WritePortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, long Buffer/*[in]*/)
{
  return (*this)->WritePortFIFO(PortAddr, NumPorts, Buffer);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::ReadPort(long Address/*[in]*/, short* Value/*[out,retval]*/)
{
  return (*this)->ReadPort(Address, Value);
}

template <class T> short __fastcall
TCOMIDLPortIOCXT<T>::ReadPort(long Address/*[in]*/)
{
  short Value;
  OLECHECK(this->ReadPort(Address, (short*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::WritePort(long Address/*[in]*/, short Data/*[in]*/)
{
  return (*this)->WritePort(Address, Data);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::GetLPTBasePort(short PortNr/*[in]*/, long* Value/*[out,retval]*/)
{
  return (*this)->GetLPTBasePort(PortNr, Value);
}

template <class T> long __fastcall
TCOMIDLPortIOCXT<T>::GetLPTBasePort(short PortNr/*[in]*/)
{
  long Value;
  OLECHECK(this->GetLPTBasePort(PortNr, (long*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_DriverPath(BSTR* Value/*[out,retval]*/)
{
  return (*this)->get_DriverPath(Value);
}

template <class T> BSTR __fastcall
TCOMIDLPortIOCXT<T>::get_DriverPath(void)
{
  BSTR Value = 0;
  OLECHECK(this->get_DriverPath((BSTR*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::set_DriverPath(BSTR Value/*[in]*/)
{
  return (*this)->set_DriverPath(Value);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_DLLPath(BSTR* Value/*[out,retval]*/)
{
  return (*this)->get_DLLPath(Value);
}

template <class T> BSTR __fastcall
TCOMIDLPortIOCXT<T>::get_DLLPath(void)
{
  BSTR Value = 0;
  OLECHECK(this->get_DLLPath((BSTR*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::set_DLLPath(BSTR Value/*[in]*/)
{
  return (*this)->set_DLLPath(Value);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_ActiveHW(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->get_ActiveHW(Value);
}

template <class T> TOLEBOOL __fastcall
TCOMIDLPortIOCXT<T>::get_ActiveHW(void)
{
  TOLEBOOL Value;
  OLECHECK(this->get_ActiveHW((TOLEBOOL*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_HardAccess(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->get_HardAccess(Value);
}

template <class T> TOLEBOOL __fastcall
TCOMIDLPortIOCXT<T>::get_HardAccess(void)
{
  TOLEBOOL Value;
  OLECHECK(this->get_HardAccess((TOLEBOOL*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::set_HardAccess(TOLEBOOL Value/*[in]*/)
{
  return (*this)->set_HardAccess(Value);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_LastError(BSTR* Value/*[out,retval]*/)
{
  return (*this)->get_LastError(Value);
}

template <class T> BSTR __fastcall
TCOMIDLPortIOCXT<T>::get_LastError(void)
{
  BSTR Value = 0;
  OLECHECK(this->get_LastError((BSTR*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_LPTNumPorts(unsigned_char* Value/*[out,retval]*/)
{
  return (*this)->get_LPTNumPorts(Value);
}

template <class T> unsigned_char __fastcall
TCOMIDLPortIOCXT<T>::get_LPTNumPorts(void)
{
  unsigned_char Value;
  OLECHECK(this->get_LPTNumPorts((unsigned_char*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_DoubleBuffered(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->get_DoubleBuffered(Value);
}

template <class T> TOLEBOOL __fastcall
TCOMIDLPortIOCXT<T>::get_DoubleBuffered(void)
{
  TOLEBOOL Value;
  OLECHECK(this->get_DoubleBuffered((TOLEBOOL*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::set_DoubleBuffered(TOLEBOOL Value/*[in]*/)
{
  return (*this)->set_DoubleBuffered(Value);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_VisibleDockClientCount(long* Value/*[out,retval]*/)
{
  return (*this)->get_VisibleDockClientCount(Value);
}

template <class T> long __fastcall
TCOMIDLPortIOCXT<T>::get_VisibleDockClientCount(void)
{
  long Value;
  OLECHECK(this->get_VisibleDockClientCount((long*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/)
{
  return (*this)->DrawTextBiDiModeFlagsReadingOnly(Value);
}

template <class T> long __fastcall
TCOMIDLPortIOCXT<T>::DrawTextBiDiModeFlagsReadingOnly(void)
{
  long Value;
  OLECHECK(this->DrawTextBiDiModeFlagsReadingOnly((long*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_Enabled(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->get_Enabled(Value);
}

template <class T> TOLEBOOL __fastcall
TCOMIDLPortIOCXT<T>::get_Enabled(void)
{
  TOLEBOOL Value;
  OLECHECK(this->get_Enabled((TOLEBOOL*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::set_Enabled(TOLEBOOL Value/*[in]*/)
{
  return (*this)->set_Enabled(Value);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::InitiateAction(void)
{
  return (*this)->InitiateAction();
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::IsRightToLeft(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->IsRightToLeft(Value);
}

template <class T> TOLEBOOL __fastcall
TCOMIDLPortIOCXT<T>::IsRightToLeft(void)
{
  TOLEBOOL Value;
  OLECHECK(this->IsRightToLeft((TOLEBOOL*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::UseRightToLeftReading(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->UseRightToLeftReading(Value);
}

template <class T> TOLEBOOL __fastcall
TCOMIDLPortIOCXT<T>::UseRightToLeftReading(void)
{
  TOLEBOOL Value;
  OLECHECK(this->UseRightToLeftReading((TOLEBOOL*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::UseRightToLeftScrollBar(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->UseRightToLeftScrollBar(Value);
}

template <class T> TOLEBOOL __fastcall
TCOMIDLPortIOCXT<T>::UseRightToLeftScrollBar(void)
{
  TOLEBOOL Value;
  OLECHECK(this->UseRightToLeftScrollBar((TOLEBOOL*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_Visible(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->get_Visible(Value);
}

template <class T> TOLEBOOL __fastcall
TCOMIDLPortIOCXT<T>::get_Visible(void)
{
  TOLEBOOL Value;
  OLECHECK(this->get_Visible((TOLEBOOL*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::set_Visible(TOLEBOOL Value/*[in]*/)
{
  return (*this)->set_Visible(Value);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::get_Cursor(short* Value/*[out,retval]*/)
{
  return (*this)->get_Cursor(Value);
}

template <class T> short __fastcall
TCOMIDLPortIOCXT<T>::get_Cursor(void)
{
  short Value;
  OLECHECK(this->get_Cursor((short*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::set_Cursor(short Value/*[in]*/)
{
  return (*this)->set_Cursor(Value);
}

template <class T> HRESULT __fastcall
TCOMIDLPortIOCXT<T>::AboutBox(void)
{
  return (*this)->AboutBox();
}

// *********************************************************************//
// DispIntf:  IDLPortIOCX
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {14B807FE-32D5-462E-B593-2816DAABB947}
// *********************************************************************//
template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::OpenDriver()
{
  _TDispID _dispid(*this, OLETEXT("OpenDriver"), DISPID(1));
  return OleFunction(_dispid);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::CloseDriver()
{
  _TDispID _dispid(*this, OLETEXT("CloseDriver"), DISPID(2));
  return OleFunction(_dispid);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::ReadPortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, long Buffer/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("ReadPortFIFO"), DISPID(5));
  TAutoArgs<3> _args;
  _args[1] = PortAddr /*[VT_I4:0]*/;
  _args[2] = NumPorts /*[VT_I4:0]*/;
  _args[3] = Buffer /*[VT_I4:0]*/;
  return OleFunction(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::WritePortFIFO(long PortAddr/*[in]*/, long NumPorts/*[in]*/, long Buffer/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("WritePortFIFO"), DISPID(6));
  TAutoArgs<3> _args;
  _args[1] = PortAddr /*[VT_I4:0]*/;
  _args[2] = NumPorts /*[VT_I4:0]*/;
  _args[3] = Buffer /*[VT_I4:0]*/;
  return OleFunction(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::ReadPort(long Address/*[in]*/, short* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("ReadPort"), DISPID(7));
  TAutoArgs<1> _args;
  _args[1] = Address /*[VT_I4:0]*/;
  return OutRetValSetterPtr(Value /*[VT_I2:1]*/, _args, OleFunction(_dispid, _args));
}

template <class T> short __fastcall
IDLPortIOCXDispT<T>::ReadPort(long Address/*[in]*/)
{
  short Value;
  this->ReadPort(Address, (short*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::WritePort(long Address/*[in]*/, short Data/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("WritePort"), DISPID(8));
  TAutoArgs<2> _args;
  _args[1] = Address /*[VT_I4:0]*/;
  _args[2] = Data /*[VT_I2:0]*/;
  return OleFunction(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::GetLPTBasePort(short PortNr/*[in]*/, long* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("GetLPTBasePort"), DISPID(9));
  TAutoArgs<1> _args;
  _args[1] = PortNr /*[VT_I2:0]*/;
  return OutRetValSetterPtr(Value /*[VT_I4:1]*/, _args, OleFunction(_dispid, _args));
}

template <class T> long __fastcall
IDLPortIOCXDispT<T>::GetLPTBasePort(short PortNr/*[in]*/)
{
  long Value;
  this->GetLPTBasePort(PortNr, (long*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_DriverPath(BSTR* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("DriverPath"), DISPID(10));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BSTR:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> BSTR __fastcall
IDLPortIOCXDispT<T>::get_DriverPath(void)
{
  BSTR Value;
  this->get_DriverPath((BSTR*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::set_DriverPath(BSTR Value/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("DriverPath"), DISPID(10));
  TAutoArgs<1> _args;
  _args[1] = Value /*[VT_BSTR:0]*/;
  return OlePropertyPut(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_DLLPath(BSTR* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("DLLPath"), DISPID(11));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BSTR:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> BSTR __fastcall
IDLPortIOCXDispT<T>::get_DLLPath(void)
{
  BSTR Value;
  this->get_DLLPath((BSTR*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::set_DLLPath(BSTR Value/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("DLLPath"), DISPID(11));
  TAutoArgs<1> _args;
  _args[1] = Value /*[VT_BSTR:0]*/;
  return OlePropertyPut(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_ActiveHW(TOLEBOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("ActiveHW"), DISPID(12));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> TOLEBOOL __fastcall
IDLPortIOCXDispT<T>::get_ActiveHW(void)
{
  TOLEBOOL Value;
  this->get_ActiveHW((TOLEBOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_HardAccess(TOLEBOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("HardAccess"), DISPID(13));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> TOLEBOOL __fastcall
IDLPortIOCXDispT<T>::get_HardAccess(void)
{
  TOLEBOOL Value;
  this->get_HardAccess((TOLEBOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::set_HardAccess(TOLEBOOL Value/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("HardAccess"), DISPID(13));
  TAutoArgs<1> _args;
  _args[1] = Value /*[VT_BOOL:0]*/;
  return OlePropertyPut(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_LastError(BSTR* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("LastError"), DISPID(14));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BSTR:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> BSTR __fastcall
IDLPortIOCXDispT<T>::get_LastError(void)
{
  BSTR Value;
  this->get_LastError((BSTR*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_LPTNumPorts(unsigned_char* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("LPTNumPorts"), DISPID(15));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_UI1:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> unsigned_char __fastcall
IDLPortIOCXDispT<T>::get_LPTNumPorts(void)
{
  unsigned_char Value;
  this->get_LPTNumPorts((unsigned_char*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_DoubleBuffered(TOLEBOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("DoubleBuffered"), DISPID(16));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> TOLEBOOL __fastcall
IDLPortIOCXDispT<T>::get_DoubleBuffered(void)
{
  TOLEBOOL Value;
  this->get_DoubleBuffered((TOLEBOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::set_DoubleBuffered(TOLEBOOL Value/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("DoubleBuffered"), DISPID(16));
  TAutoArgs<1> _args;
  _args[1] = Value /*[VT_BOOL:0]*/;
  return OlePropertyPut(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_VisibleDockClientCount(long* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("VisibleDockClientCount"), DISPID(17));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_I4:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> long __fastcall
IDLPortIOCXDispT<T>::get_VisibleDockClientCount(void)
{
  long Value;
  this->get_VisibleDockClientCount((long*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("DrawTextBiDiModeFlagsReadingOnly"), DISPID(19));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_I4:1]*/, _args, OleFunction(_dispid, _args));
}

template <class T> long __fastcall
IDLPortIOCXDispT<T>::DrawTextBiDiModeFlagsReadingOnly(void)
{
  long Value;
  this->DrawTextBiDiModeFlagsReadingOnly((long*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_Enabled(TOLEBOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("Enabled"), DISPID(-514));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> TOLEBOOL __fastcall
IDLPortIOCXDispT<T>::get_Enabled(void)
{
  TOLEBOOL Value;
  this->get_Enabled((TOLEBOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::set_Enabled(TOLEBOOL Value/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("Enabled"), DISPID(-514));
  TAutoArgs<1> _args;
  _args[1] = Value /*[VT_BOOL:0]*/;
  return OlePropertyPut(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::InitiateAction()
{
  _TDispID _dispid(*this, OLETEXT("InitiateAction"), DISPID(20));
  return OleFunction(_dispid);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::IsRightToLeft(TOLEBOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("IsRightToLeft"), DISPID(21));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OleFunction(_dispid, _args));
}

template <class T> TOLEBOOL __fastcall
IDLPortIOCXDispT<T>::IsRightToLeft(void)
{
  TOLEBOOL Value;
  this->IsRightToLeft((TOLEBOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::UseRightToLeftReading(TOLEBOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("UseRightToLeftReading"), DISPID(24));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OleFunction(_dispid, _args));
}

template <class T> TOLEBOOL __fastcall
IDLPortIOCXDispT<T>::UseRightToLeftReading(void)
{
  TOLEBOOL Value;
  this->UseRightToLeftReading((TOLEBOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::UseRightToLeftScrollBar(TOLEBOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("UseRightToLeftScrollBar"), DISPID(25));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OleFunction(_dispid, _args));
}

template <class T> TOLEBOOL __fastcall
IDLPortIOCXDispT<T>::UseRightToLeftScrollBar(void)
{
  TOLEBOOL Value;
  this->UseRightToLeftScrollBar((TOLEBOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_Visible(TOLEBOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("Visible"), DISPID(26));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> TOLEBOOL __fastcall
IDLPortIOCXDispT<T>::get_Visible(void)
{
  TOLEBOOL Value;
  this->get_Visible((TOLEBOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::set_Visible(TOLEBOOL Value/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("Visible"), DISPID(26));
  TAutoArgs<1> _args;
  _args[1] = Value /*[VT_BOOL:0]*/;
  return OlePropertyPut(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::get_Cursor(short* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("Cursor"), DISPID(27));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_I2:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> short __fastcall
IDLPortIOCXDispT<T>::get_Cursor(void)
{
  short Value;
  this->get_Cursor((short*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::set_Cursor(short Value/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("Cursor"), DISPID(27));
  TAutoArgs<1> _args;
  _args[1] = Value /*[VT_I2:0]*/;
  return OlePropertyPut(_dispid, _args);
}

template <class T> HRESULT __fastcall
IDLPortIOCXDispT<T>::AboutBox()
{
  _TDispID _dispid(*this, OLETEXT("AboutBox"), DISPID(-552));
  return OleFunction(_dispid);
}

// *********************************************************************//
// DispIntf:  IDLPortIOCXEvents
// Flags:     (0)
// GUID:      {D54AC1B5-B32A-4683-A1F7-23B5C66ECA23}
// *********************************************************************//
#endif  //   __TLB_NO_INTERFACE_WRAPPERS


#if !defined(__TLB_NO_EVENT_WRAPPERS) && defined(USING_ATLVCL)
// *********************************************************************//
// CONNECTIONPOINT/EVENT PROXY
// CoClass         : DLPortIOCX
// Event Interface : IDLPortIOCXEvents
// *********************************************************************//
template <class T>
class TEvents_DLPortIOCX : public IConnectionPointImpl<T,
                                                 &DIID_IDLPortIOCXEvents,
                                                 CComUnkArray<CONNECTIONPOINT_ARRAY_SIZE> >
{
public:
protected:
  IDLPortIOCXEventsDisp m_EventIntfObj;
};

#endif  //   __TLB_NO_EVENT_WRAPPERS

};     // namespace Dlportiocx_tlb

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

#pragma option pop

#endif // __DLPortIOCX_TLB_h__
