// ************************************************************************ //
// 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.151.1.0.1.27  $
// Fichier généré le 18.01.2004 16:09:30 depuis la bibliothèque de types ci-dessous.

// ************************************************************************  //
// Bibl. types : C:\prg\CBuilder6\CBuilder6\OCX\DLIoPortOcx\DLPortOCXControl1.tlb (1)
// LIBID: {6462811D-5F5F-46CF-A534-1669A5C51D0D}
// LCID: 0
// Fichier d'aide : 
// Chaîne d'aide : DLPortOCXControl1 (bibliothèque)
// DepndLst: 
//   (1) v2.0 stdole, (D:\WINNT\System32\stdole2.tlb)
// ************************************************************************ //
#ifndef   DLPortOCXControl1_TLBH
#define   DLPortOCXControl1_TLBH

#pragma option push -b -w-inl

#include <utilcls.h>
#if !defined(__UTILCLS_H_VERSION) || (__UTILCLS_H_VERSION < 0x0600)
//
// Le code généré par l'utilitaire TLIBIMP ou la fonction d'importation de bibliothèque de types 
// ou d'ActiveX de C++Builder repose sur des versions spécifiques
// du fichier en-tête UTILCLS.H situé dans le répertoire INCLUDE\VCL. Si une 
// version antérieure du fichier est détectée, vous devrez appliquer une mise à jour ou un correctif.
//
#error "Ce fichier requiert une version plus récente du fichier en-tête UTILCLS.H" \
       "Vous devez appliquer une mise à jour/correctif à 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 Dlportocxcontrol1_tlb
{

// *********************************************************************//
// Chaîne d'aide : DLPortOCXControl1 (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 "C" const __declspec(selectany) GUID LIBID_DLPortOCXControl1 = {0x6462811D, 0x5F5F, 0x46CF,{ 0xA5, 0x34, 0x16,0x69, 0xA5, 0xC5,0x1D, 0x0D} };
extern "C" const __declspec(selectany) GUID IID_IDLPortOCX = {0xB4C3457A, 0xA17B, 0x4AEA,{ 0x93, 0x50, 0xF7,0x87, 0x9F, 0x0D,0x75, 0x4E} };
extern "C" const __declspec(selectany) GUID DIID_IDLPortOCXEvents = {0x0717F53D, 0xBC00, 0x4322,{ 0xA1, 0xA7, 0xFB,0x2B, 0x28, 0x3F,0x5F, 0x98} };
extern "C" const __declspec(selectany) GUID CLSID_DLPortOCX = {0x33F2A2D0, 0x68FA, 0x42AC,{ 0xA4, 0x37, 0x24,0x21, 0x6B, 0xE8,0x09, 0x7A} };

// *********************************************************************//
// Déclaration Forward des types définis dans la bibliothèque de types    
// *********************************************************************//
interface DECLSPEC_UUID("{B4C3457A-A17B-4AEA-9350-F7879F0D754E}") IDLPortOCX;
typedef TComInterface<IDLPortOCX, &IID_IDLPortOCX> IDLPortOCXPtr;

interface DECLSPEC_UUID("{0717F53D-BC00-4322-A1A7-FB2B283F5F98}") IDLPortOCXEvents;
typedef TComInterface<IDLPortOCXEvents, &DIID_IDLPortOCXEvents> IDLPortOCXEventsPtr;


// *********************************************************************//
// Déclaration des CoClasses définies dans la bibliothèque de types    
// (REMARQUE : On affecte chaque CoClasse à 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 CoClasse change.                                                           
// *********************************************************************//
typedef IDLPortOCX DLPortOCX;
typedef IDLPortOCXPtr DLPortOCXPtr;

#define LIBID_OF_DLPortOCX (&LIBID_DLPortOCXControl1)
// *********************************************************************//
// Interface   : IDLPortOCX
// Indicateurs : (4416) Dual OleAutomation Dispatchable
// GUID        : {B4C3457A-A17B-4AEA-9350-F7879F0D754E}
// *********************************************************************//
interface IDLPortOCX  : 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(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [12]
  virtual HRESULT STDMETHODCALLTYPE get_HardAccess(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [13]
  virtual HRESULT STDMETHODCALLTYPE set_HardAccess(VARIANT_BOOL 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(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [16]
  virtual HRESULT STDMETHODCALLTYPE set_DoubleBuffered(VARIANT_BOOL Value/*[in]*/) = 0; // [16]
  virtual HRESULT STDMETHODCALLTYPE get_AlignDisabled(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [17]
  virtual HRESULT STDMETHODCALLTYPE get_VisibleDockClientCount(long* Value/*[out,retval]*/) = 0; // [18]
  virtual HRESULT STDMETHODCALLTYPE DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/) = 0; // [20]
  virtual HRESULT STDMETHODCALLTYPE get_Enabled(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [-514]
  virtual HRESULT STDMETHODCALLTYPE set_Enabled(VARIANT_BOOL Value/*[in]*/) = 0; // [-514]
  virtual HRESULT STDMETHODCALLTYPE InitiateAction(void) = 0; // [21]
  virtual HRESULT STDMETHODCALLTYPE IsRightToLeft(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [22]
  virtual HRESULT STDMETHODCALLTYPE UseRightToLeftReading(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [25]
  virtual HRESULT STDMETHODCALLTYPE UseRightToLeftScrollBar(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [26]
  virtual HRESULT STDMETHODCALLTYPE get_Visible(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [27]
  virtual HRESULT STDMETHODCALLTYPE set_Visible(VARIANT_BOOL Value/*[in]*/) = 0; // [27]
  virtual HRESULT STDMETHODCALLTYPE SetSubComponent(VARIANT_BOOL IsSubComponent/*[in]*/) = 0; // [29]
  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;
  }

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

  VARIANT_BOOL __fastcall get_HardAccess(void)
  {
    VARIANT_BOOL Value;
    OLECHECK(this->get_HardAccess((VARIANT_BOOL*)&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;
  }

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

  VARIANT_BOOL __fastcall get_AlignDisabled(void)
  {
    VARIANT_BOOL Value;
    OLECHECK(this->get_AlignDisabled((VARIANT_BOOL*)&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;
  }

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

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

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

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

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


  __property   BSTR            DriverPath = {read = get_DriverPath};
  __property   BSTR            DLLPath = {read = get_DLLPath};
  __property   VARIANT_BOOL    ActiveHW = {read = get_ActiveHW};
  __property   VARIANT_BOOL    HardAccess = {read = get_HardAccess, write = set_HardAccess};
  __property   BSTR            LastError = {read = get_LastError};
  __property   unsigned_char   LPTNumPorts = {read = get_LPTNumPorts};
  __property   VARIANT_BOOL    DoubleBuffered = {read = get_DoubleBuffered, write = set_DoubleBuffered};
  __property   VARIANT_BOOL    AlignDisabled = {read = get_AlignDisabled};
  __property   long            VisibleDockClientCount = {read = get_VisibleDockClientCount};
  __property   VARIANT_BOOL    Enabled = {read = get_Enabled, write = set_Enabled};
  __property   VARIANT_BOOL    Visible = {read = get_Visible, write = set_Visible};

#endif //   __TLB_NO_INTERFACE_WRAPPERS

};

// *********************************************************************//
// Interface   : IDLPortOCXEvents
// Indicateurs : (4096) Dispatchable
// GUID        : {0717F53D-BC00-4322-A1A7-FB2B283F5F98}
// *********************************************************************//
interface IDLPortOCXEvents : public TDispWrapper<IDispatch>
{

};
#if !defined(__TLB_NO_INTERFACE_WRAPPERS)
// *********************************************************************//
// SmartIntf: TCOMIDLPortOCX
// Interface: IDLPortOCX
// *********************************************************************//
template <class T /* IDLPortOCX */ >
class TCOMIDLPortOCXT : public TComInterface<IDLPortOCX>, public TComInterfaceBase<IUnknown>
{
public:
  TCOMIDLPortOCXT() {}
  TCOMIDLPortOCXT(IDLPortOCX *intf, bool addRef = false) : TComInterface<IDLPortOCX>(intf, addRef) {}
  TCOMIDLPortOCXT(const TCOMIDLPortOCXT& src) : TComInterface<IDLPortOCX>(src) {}
  TCOMIDLPortOCXT& operator=(const TCOMIDLPortOCXT& 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(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_ActiveHW(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_ActiveHW(void);
  HRESULT         __fastcall get_HardAccess(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_HardAccess(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_HardAccess(void);
  HRESULT         __fastcall set_HardAccess(VARIANT_BOOL Value/*[in]*/);
  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(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_DoubleBuffered(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_DoubleBuffered(void);
  HRESULT         __fastcall set_DoubleBuffered(VARIANT_BOOL Value/*[in]*/);
  HRESULT         __fastcall set_DoubleBuffered(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_AlignDisabled(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_AlignDisabled(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_AlignDisabled(void);
  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(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_Enabled(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Enabled(void);
  HRESULT         __fastcall set_Enabled(VARIANT_BOOL Value/*[in]*/);
  HRESULT         __fastcall set_Enabled(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall InitiateAction(void);
  HRESULT         __fastcall IsRightToLeft(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall IsRightToLeft(void);
  HRESULT         __fastcall UseRightToLeftReading(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall UseRightToLeftReading(void);
  HRESULT         __fastcall UseRightToLeftScrollBar(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall UseRightToLeftScrollBar(void);
  HRESULT         __fastcall get_Visible(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_Visible(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Visible(void);
  HRESULT         __fastcall set_Visible(VARIANT_BOOL Value/*[in]*/);
  HRESULT         __fastcall set_Visible(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall SetSubComponent(VARIANT_BOOL IsSubComponent/*[in]*/);
  HRESULT         __fastcall AboutBox(void);

  __property   BSTR            DriverPath = {read = get_DriverPath};
  __property   BSTR            DLLPath = {read = get_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   TOLEBOOL        AlignDisabled = {read = get_AlignDisabled};
  __property   long            VisibleDockClientCount = {read = get_VisibleDockClientCount};
  __property   TOLEBOOL        Enabled = {read = get_Enabled, write = set_Enabled};
  __property   TOLEBOOL        Visible = {read = get_Visible, write = set_Visible};
};
typedef TCOMIDLPortOCXT<IDLPortOCX> TCOMIDLPortOCX;

// *********************************************************************//
// DispIntf :  IDLPortOCX
// Flags :     (4416) Dual OleAutomation Dispatchable
// GUID :      {B4C3457A-A17B-4AEA-9350-F7879F0D754E}
// *********************************************************************//
template<class T>
class IDLPortOCXDispT : public TAutoDriver<IDLPortOCX>
{
public:
  IDLPortOCXDispT(){}

  IDLPortOCXDispT(IDLPortOCX *pintf)
  {
    TAutoDriver<IDLPortOCX>::Bind(pintf, false);
  }

  IDLPortOCXDispT(IDLPortOCXPtr pintf)
  {
    TAutoDriver<IDLPortOCX>::Bind(pintf, true);
  }

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

  IDLPortOCXDispT& operator=(IDLPortOCXPtr pintf)
  {
    TAutoDriver<IDLPortOCX>::Bind(pintf, true);
    return *this;
  }

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

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

  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(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_ActiveHW(void);
  HRESULT         __fastcall get_HardAccess(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_HardAccess(void);
  HRESULT         __fastcall set_HardAccess(VARIANT_BOOL 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(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_DoubleBuffered(void);
  HRESULT         __fastcall set_DoubleBuffered(VARIANT_BOOL Value/*[in]*/);
  HRESULT         __fastcall get_AlignDisabled(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_AlignDisabled(void);
  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(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_Enabled(void);
  HRESULT         __fastcall set_Enabled(VARIANT_BOOL Value/*[in]*/);
  HRESULT         __fastcall InitiateAction();
  HRESULT         __fastcall IsRightToLeft(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall IsRightToLeft(void);
  HRESULT         __fastcall UseRightToLeftReading(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall UseRightToLeftReading(void);
  HRESULT         __fastcall UseRightToLeftScrollBar(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall UseRightToLeftScrollBar(void);
  HRESULT         __fastcall get_Visible(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_Visible(void);
  HRESULT         __fastcall set_Visible(VARIANT_BOOL Value/*[in]*/);
  HRESULT         __fastcall SetSubComponent(VARIANT_BOOL IsSubComponent/*[in]*/);
  HRESULT         __fastcall AboutBox();

  __property   BSTR            DriverPath = {read = get_DriverPath};
  __property   BSTR            DLLPath = {read = get_DLLPath};
  __property   VARIANT_BOOL    ActiveHW = {read = get_ActiveHW};
  __property   VARIANT_BOOL    HardAccess = {read = get_HardAccess, write = set_HardAccess};
  __property   BSTR            LastError = {read = get_LastError};
  __property   unsigned_char   LPTNumPorts = {read = get_LPTNumPorts};
  __property   VARIANT_BOOL    DoubleBuffered = {read = get_DoubleBuffered, write = set_DoubleBuffered};
  __property   VARIANT_BOOL    AlignDisabled = {read = get_AlignDisabled};
  __property   long            VisibleDockClientCount = {read = get_VisibleDockClientCount};
  __property   VARIANT_BOOL    Enabled = {read = get_Enabled, write = set_Enabled};
  __property   VARIANT_BOOL    Visible = {read = get_Visible, write = set_Visible};
};
typedef IDLPortOCXDispT<IDLPortOCX> IDLPortOCXDisp;

// *********************************************************************//
// DispIntf :  IDLPortOCXEvents
// Flags :     (4096) Dispatchable
// GUID :      {0717F53D-BC00-4322-A1A7-FB2B283F5F98}
// *********************************************************************//
template <class T>
class IDLPortOCXEventsDispT : public TAutoDriver<IDLPortOCXEvents>
{
public:
  IDLPortOCXEventsDispT(){}

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


};
typedef IDLPortOCXEventsDispT<IDLPortOCXEvents> IDLPortOCXEventsDisp;

// *********************************************************************//
// SmartIntf: TCOMIDLPortOCX
// Interface: IDLPortOCX
// *********************************************************************//
template <class T> HRESULT __fastcall
TCOMIDLPortOCXT<T>::OpenDriver(void)
{
  return (*this)->OpenDriver();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <class T> HRESULT __fastcall
TCOMIDLPortOCXT<T>::SetSubComponent(VARIANT_BOOL IsSubComponent/*[in]*/)
{
  return (*this)->SetSubComponent(IsSubComponent);
}

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

// *********************************************************************//
// DispIntf :  IDLPortOCX
// Flags :     (4416) Dual OleAutomation Dispatchable
// GUID :      {B4C3457A-A17B-4AEA-9350-F7879F0D754E}
// *********************************************************************//
template <class T> HRESULT __fastcall
IDLPortOCXDispT<T>::OpenDriver()
{
  _TDispID _dispid(*this, OLETEXT("OpenDriver"), DISPID(1));
  return OleFunction(_dispid);
}

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

template <class T> HRESULT __fastcall
IDLPortOCXDispT<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
IDLPortOCXDispT<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
IDLPortOCXDispT<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
IDLPortOCXDispT<T>::ReadPort(long Address/*[in]*/)
{
  short Value;
  this->ReadPort(Address, (short*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<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
IDLPortOCXDispT<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
IDLPortOCXDispT<T>::GetLPTBasePort(short PortNr/*[in]*/)
{
  long Value;
  this->GetLPTBasePort(PortNr, (long*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<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
IDLPortOCXDispT<T>::get_DriverPath(void)
{
  BSTR Value;
  this->get_DriverPath((BSTR*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<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
IDLPortOCXDispT<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
IDLPortOCXDispT<T>::get_DLLPath(void)
{
  BSTR Value;
  this->get_DLLPath((BSTR*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<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
IDLPortOCXDispT<T>::get_ActiveHW(VARIANT_BOOL* 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> VARIANT_BOOL __fastcall
IDLPortOCXDispT<T>::get_ActiveHW(void)
{
  VARIANT_BOOL Value;
  this->get_ActiveHW((VARIANT_BOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<T>::get_HardAccess(VARIANT_BOOL* 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> VARIANT_BOOL __fastcall
IDLPortOCXDispT<T>::get_HardAccess(void)
{
  VARIANT_BOOL Value;
  this->get_HardAccess((VARIANT_BOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<T>::set_HardAccess(VARIANT_BOOL 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
IDLPortOCXDispT<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
IDLPortOCXDispT<T>::get_LastError(void)
{
  BSTR Value;
  this->get_LastError((BSTR*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<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
IDLPortOCXDispT<T>::get_LPTNumPorts(void)
{
  unsigned_char Value;
  this->get_LPTNumPorts((unsigned_char*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<T>::get_DoubleBuffered(VARIANT_BOOL* 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> VARIANT_BOOL __fastcall
IDLPortOCXDispT<T>::get_DoubleBuffered(void)
{
  VARIANT_BOOL Value;
  this->get_DoubleBuffered((VARIANT_BOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<T>::set_DoubleBuffered(VARIANT_BOOL 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
IDLPortOCXDispT<T>::get_AlignDisabled(VARIANT_BOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("AlignDisabled"), DISPID(17));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OlePropertyGet(_dispid, _args));
}

template <class T> VARIANT_BOOL __fastcall
IDLPortOCXDispT<T>::get_AlignDisabled(void)
{
  VARIANT_BOOL Value;
  this->get_AlignDisabled((VARIANT_BOOL*)&Value);
  return Value;
}

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

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

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

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

template <class T> HRESULT __fastcall
IDLPortOCXDispT<T>::get_Enabled(VARIANT_BOOL* 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> VARIANT_BOOL __fastcall
IDLPortOCXDispT<T>::get_Enabled(void)
{
  VARIANT_BOOL Value;
  this->get_Enabled((VARIANT_BOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPortOCXDispT<T>::set_Enabled(VARIANT_BOOL 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
IDLPortOCXDispT<T>::InitiateAction()
{
  _TDispID _dispid(*this, OLETEXT("InitiateAction"), DISPID(21));
  return OleFunction(_dispid);
}

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

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

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

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

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

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

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

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

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

template <class T> HRESULT __fastcall
IDLPortOCXDispT<T>::SetSubComponent(VARIANT_BOOL IsSubComponent/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("SetSubComponent"), DISPID(29));
  TAutoArgs<1> _args;
  _args[1] = IsSubComponent /*[VT_BOOL:0]*/;
  return OleFunction(_dispid, _args);
}

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

// *********************************************************************//
// DispIntf :  IDLPortOCXEvents
// Flags :     (4096) Dispatchable
// GUID :      {0717F53D-BC00-4322-A1A7-FB2B283F5F98}
// *********************************************************************//
#endif  //   __TLB_NO_INTERFACE_WRAPPERS


#if !defined(__TLB_NO_EVENT_WRAPPERS) && defined(USING_ATLVCL)
// *********************************************************************//
// CONNECTIONPOINT/EVENT PROXY
// CoClasse         : DLPortOCX
// Interface d'événements : IDLPortOCXEvents
// *********************************************************************//
template <class T>
class TEvents_DLPortOCX : public IConnectionPointImpl<T,
                                                 &DIID_IDLPortOCXEvents,
                                                 CComUnkArray<CONNECTIONPOINT_ARRAY_SIZE> >
 /* Remarque : si vous rencontrez des problèmes avec les événements, remplacez CComUnkArray par CComDynamicUnkArray dans la ligne ci-dessus. */
{
public:
protected:
  IDLPortOCXEventsDisp m_EventIntfObj;
};

#endif  //   __TLB_NO_EVENT_WRAPPERS

};     // namespace Dlportocxcontrol1_tlb

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

#pragma option pop

#endif // DLPortOCXControl1_TLBH
