// ************************************************************************ //
// 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 04.02.2004 05:55:46 depuis la bibliothèque de types ci-dessous.

// ************************************************************************  //
// Bibl. types : H:\Program Files\Borland\composants\DlPrinterOcxControl\DLPrinterPortI.tlb (1)
// LIBID: {B44DFED5-1D49-42AF-B94C-799CE4629C65}
// LCID: 0
// Fichier d'aide : 
// Chaîne d'aide : DLPrinterPortI (bibliothèque)
// DepndLst: 
//   (1) v2.0 stdole, (D:\WINNT\System32\stdole2.tlb)
//   (2) v4.0 StdVCL, (D:\WINNT\System32\stdvcl40.dll)
// ************************************************************************ //
#ifndef   DLPrinterPortI_TLBH
#define   DLPrinterPortI_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

#include "OleCtrls.hpp"

// *********************************************************************//
// 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 Dlprinterporti_tlb
{

// *********************************************************************//
// Chaîne d'aide : DLPrinterPortI (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_DLPrinterPortI = {0xB44DFED5, 0x1D49, 0x42AF,{ 0xB9, 0x4C, 0x79,0x9C, 0xE4, 0x62,0x9C, 0x65} };
extern "C" const __declspec(selectany) GUID IID_IDLPrinterPortIOXX = {0x99CFB01D, 0xBC12, 0x45E0,{ 0x9A, 0xBB, 0x83,0x8E, 0x5A, 0xDB,0x9B, 0x0D} };
extern "C" const __declspec(selectany) GUID DIID_IDLPrinterPortIOXXEvents = {0x8ECA966B, 0xE944, 0x41AB,{ 0x95, 0xF1, 0x83,0x45, 0x4D, 0x00,0x16, 0xBF} };
extern "C" const __declspec(selectany) GUID CLSID_DLPrinterPortIOXX = {0xBA62642A, 0xD35A, 0x4375,{ 0x98, 0x91, 0xE1,0x04, 0xCE, 0x99,0xD6, 0xAF} };

// *********************************************************************//
// Déclaration Forward des types définis dans la bibliothèque de types    
// *********************************************************************//
interface DECLSPEC_UUID("{99CFB01D-BC12-45E0-9ABB-838E5ADB9B0D}") IDLPrinterPortIOXX;
typedef TComInterface<IDLPrinterPortIOXX, &IID_IDLPrinterPortIOXX> IDLPrinterPortIOXXPtr;

interface DECLSPEC_UUID("{8ECA966B-E944-41AB-95F1-83454D0016BF}") IDLPrinterPortIOXXEvents;
typedef TComInterface<IDLPrinterPortIOXXEvents, &DIID_IDLPrinterPortIOXXEvents> IDLPrinterPortIOXXEventsPtr;


// *********************************************************************//
// 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 IDLPrinterPortIOXX DLPrinterPortIOXX;
typedef IDLPrinterPortIOXXPtr DLPrinterPortIOXXPtr;

#define LIBID_OF_DLPrinterPortIOXX (&LIBID_DLPrinterPortI)
// *********************************************************************//
// Interface   : IDLPrinterPortIOXX
// Indicateurs : (4416) Dual OleAutomation Dispatchable
// GUID        : {99CFB01D-BC12-45E0-9ABB-838E5ADB9B0D}
// *********************************************************************//
interface IDLPrinterPortIOXX  : public IDispatch
{
public:
  virtual HRESULT STDMETHODCALLTYPE LPTStrobe(void) = 0; // [1]
  virtual HRESULT STDMETHODCALLTYPE LPTAutofd(VARIANT_BOOL Flag/*[in]*/) = 0; // [2]
  virtual HRESULT STDMETHODCALLTYPE LPTInit(void) = 0; // [3]
  virtual HRESULT STDMETHODCALLTYPE LPTSlctIn(void) = 0; // [4]
  virtual HRESULT STDMETHODCALLTYPE LPTPrintChar(short CH/*[in]*/, 
                                                 VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [5]
  virtual HRESULT STDMETHODCALLTYPE ReadPort(long Address/*[in]*/, short* Value/*[out,retval]*/) = 0; // [6]
  virtual HRESULT STDMETHODCALLTYPE WritePort(long Address/*[in]*/, short Data/*[in]*/) = 0; // [7]
  virtual HRESULT STDMETHODCALLTYPE GetPin(short index/*[in]*/, VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [8]
  virtual HRESULT STDMETHODCALLTYPE SetPin(short index/*[in]*/, VARIANT_BOOL state/*[in]*/) = 0; // [9]
  virtual HRESULT STDMETHODCALLTYPE get_LPTAckwl(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [10]
  virtual HRESULT STDMETHODCALLTYPE get_LPTBusy(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [11]
  virtual HRESULT STDMETHODCALLTYPE get_LPTPaperEnd(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [12]
  virtual HRESULT STDMETHODCALLTYPE get_LPTSlct(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [13]
  virtual HRESULT STDMETHODCALLTYPE get_LPTError(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [14]
  virtual HRESULT STDMETHODCALLTYPE get_LPTNumPorts(short* Value/*[out,retval]*/) = 0; // [15]
  virtual HRESULT STDMETHODCALLTYPE get_LPTNumber(short* Value/*[out,retval]*/) = 0; // [16]
  virtual HRESULT STDMETHODCALLTYPE set_LPTNumber(short Value/*[in]*/) = 0; // [16]
  virtual HRESULT STDMETHODCALLTYPE get_LPTBasePort(long* Value/*[out,retval]*/) = 0; // [17]
  virtual HRESULT STDMETHODCALLTYPE get_DoubleBuffered(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [18]
  virtual HRESULT STDMETHODCALLTYPE set_DoubleBuffered(VARIANT_BOOL Value/*[in]*/) = 0; // [18]
  virtual HRESULT STDMETHODCALLTYPE get_AlignDisabled(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [19]
  virtual HRESULT STDMETHODCALLTYPE get_VisibleDockClientCount(long* Value/*[out,retval]*/) = 0; // [20]
  virtual HRESULT STDMETHODCALLTYPE DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/) = 0; // [22]
  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; // [23]
  virtual HRESULT STDMETHODCALLTYPE IsRightToLeft(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [24]
  virtual HRESULT STDMETHODCALLTYPE UseRightToLeftReading(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [27]
  virtual HRESULT STDMETHODCALLTYPE UseRightToLeftScrollBar(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [28]
  virtual HRESULT STDMETHODCALLTYPE get_Visible(VARIANT_BOOL* Value/*[out,retval]*/) = 0; // [29]
  virtual HRESULT STDMETHODCALLTYPE set_Visible(VARIANT_BOOL Value/*[in]*/) = 0; // [29]
  virtual HRESULT STDMETHODCALLTYPE SetSubComponent(VARIANT_BOOL IsSubComponent/*[in]*/) = 0; // [31]
  virtual HRESULT STDMETHODCALLTYPE AboutBox(void) = 0; // [-552]

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

  VARIANT_BOOL __fastcall LPTPrintChar(short CH/*[in]*/)
  {
    VARIANT_BOOL Value;
    OLECHECK(this->LPTPrintChar(CH, (VARIANT_BOOL*)&Value));
    return Value;
  }

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

  VARIANT_BOOL __fastcall GetPin(short index/*[in]*/)
  {
    VARIANT_BOOL Value;
    OLECHECK(this->GetPin(index, (VARIANT_BOOL*)&Value));
    return Value;
  }

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

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

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

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

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

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

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

  long __fastcall get_LPTBasePort(void)
  {
    long Value;
    OLECHECK(this->get_LPTBasePort((long*)&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   VARIANT_BOOL    LPTAckwl = {read = get_LPTAckwl};
  __property   VARIANT_BOOL    LPTBusy = {read = get_LPTBusy};
  __property   VARIANT_BOOL    LPTPaperEnd = {read = get_LPTPaperEnd};
  __property   VARIANT_BOOL    LPTSlct = {read = get_LPTSlct};
  __property   VARIANT_BOOL    LPTError = {read = get_LPTError};
  __property   short           LPTNumPorts = {read = get_LPTNumPorts};
  __property   short           LPTNumber = {read = get_LPTNumber, write = set_LPTNumber};
  __property   long            LPTBasePort = {read = get_LPTBasePort};
  __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   : IDLPrinterPortIOXXEvents
// Indicateurs : (0)
// GUID        : {8ECA966B-E944-41AB-95F1-83454D0016BF}
// *********************************************************************//
interface IDLPrinterPortIOXXEvents : public TDispWrapper<IDispatch>
{

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

  HRESULT         __fastcall LPTStrobe(void);
  HRESULT         __fastcall LPTAutofd(VARIANT_BOOL Flag/*[in]*/);
  HRESULT         __fastcall LPTInit(void);
  HRESULT         __fastcall LPTSlctIn(void);
  HRESULT         __fastcall LPTPrintChar(short CH/*[in]*/, VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall LPTPrintChar(short CH/*[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 GetPin(short index/*[in]*/, VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall GetPin(short index/*[in]*/);
  HRESULT         __fastcall SetPin(short index/*[in]*/, VARIANT_BOOL state/*[in]*/);
  HRESULT         __fastcall get_LPTAckwl(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_LPTAckwl(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTAckwl(void);
  HRESULT         __fastcall get_LPTBusy(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_LPTBusy(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTBusy(void);
  HRESULT         __fastcall get_LPTPaperEnd(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_LPTPaperEnd(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTPaperEnd(void);
  HRESULT         __fastcall get_LPTSlct(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_LPTSlct(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTSlct(void);
  HRESULT         __fastcall get_LPTError(VARIANT_BOOL* Value/*[out,retval]*/);
  HRESULT         __fastcall get_LPTError(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTError(void);
  HRESULT         __fastcall get_LPTNumPorts(short* Value/*[out,retval]*/);
  short           __fastcall get_LPTNumPorts(void);
  HRESULT         __fastcall get_LPTNumber(short* Value/*[out,retval]*/);
  short           __fastcall get_LPTNumber(void);
  HRESULT         __fastcall set_LPTNumber(short Value/*[in]*/);
  HRESULT         __fastcall get_LPTBasePort(long* Value/*[out,retval]*/);
  long            __fastcall get_LPTBasePort(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   TOLEBOOL        LPTAckwl = {read = get_LPTAckwl};
  __property   TOLEBOOL        LPTBusy = {read = get_LPTBusy};
  __property   TOLEBOOL        LPTPaperEnd = {read = get_LPTPaperEnd};
  __property   TOLEBOOL        LPTSlct = {read = get_LPTSlct};
  __property   TOLEBOOL        LPTError = {read = get_LPTError};
  __property   short           LPTNumPorts = {read = get_LPTNumPorts};
  __property   short           LPTNumber = {read = get_LPTNumber, write = set_LPTNumber};
  __property   long            LPTBasePort = {read = get_LPTBasePort};
  __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 TCOMIDLPrinterPortIOXXT<IDLPrinterPortIOXX> TCOMIDLPrinterPortIOXX;

// *********************************************************************//
// DispIntf :  IDLPrinterPortIOXX
// Flags :     (4416) Dual OleAutomation Dispatchable
// GUID :      {99CFB01D-BC12-45E0-9ABB-838E5ADB9B0D}
// *********************************************************************//
template<class T>
class IDLPrinterPortIOXXDispT : public TAutoDriver<IDLPrinterPortIOXX>
{
public:
  IDLPrinterPortIOXXDispT(){}

  IDLPrinterPortIOXXDispT(IDLPrinterPortIOXX *pintf)
  {
    TAutoDriver<IDLPrinterPortIOXX>::Bind(pintf, false);
  }

  IDLPrinterPortIOXXDispT(IDLPrinterPortIOXXPtr pintf)
  {
    TAutoDriver<IDLPrinterPortIOXX>::Bind(pintf, true);
  }

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

  IDLPrinterPortIOXXDispT& operator=(IDLPrinterPortIOXXPtr pintf)
  {
    TAutoDriver<IDLPrinterPortIOXX>::Bind(pintf, true);
    return *this;
  }

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

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

  HRESULT         __fastcall LPTStrobe();
  HRESULT         __fastcall LPTAutofd(VARIANT_BOOL Flag/*[in]*/);
  HRESULT         __fastcall LPTInit();
  HRESULT         __fastcall LPTSlctIn();
  HRESULT         __fastcall LPTPrintChar(short CH/*[in]*/, VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall LPTPrintChar(short CH/*[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 GetPin(short index/*[in]*/, VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall GetPin(short index/*[in]*/);
  HRESULT         __fastcall SetPin(short index/*[in]*/, VARIANT_BOOL state/*[in]*/);
  HRESULT         __fastcall get_LPTAckwl(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_LPTAckwl(void);
  HRESULT         __fastcall get_LPTBusy(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_LPTBusy(void);
  HRESULT         __fastcall get_LPTPaperEnd(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_LPTPaperEnd(void);
  HRESULT         __fastcall get_LPTSlct(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_LPTSlct(void);
  HRESULT         __fastcall get_LPTError(VARIANT_BOOL* Value/*[out,retval]*/);
  VARIANT_BOOL    __fastcall get_LPTError(void);
  HRESULT         __fastcall get_LPTNumPorts(short* Value/*[out,retval]*/);
  short           __fastcall get_LPTNumPorts(void);
  HRESULT         __fastcall get_LPTNumber(short* Value/*[out,retval]*/);
  short           __fastcall get_LPTNumber(void);
  HRESULT         __fastcall set_LPTNumber(short Value/*[in]*/);
  HRESULT         __fastcall get_LPTBasePort(long* Value/*[out,retval]*/);
  long            __fastcall get_LPTBasePort(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   VARIANT_BOOL    LPTAckwl = {read = get_LPTAckwl};
  __property   VARIANT_BOOL    LPTBusy = {read = get_LPTBusy};
  __property   VARIANT_BOOL    LPTPaperEnd = {read = get_LPTPaperEnd};
  __property   VARIANT_BOOL    LPTSlct = {read = get_LPTSlct};
  __property   VARIANT_BOOL    LPTError = {read = get_LPTError};
  __property   short           LPTNumPorts = {read = get_LPTNumPorts};
  __property   short           LPTNumber = {read = get_LPTNumber, write = set_LPTNumber};
  __property   long            LPTBasePort = {read = get_LPTBasePort};
  __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 IDLPrinterPortIOXXDispT<IDLPrinterPortIOXX> IDLPrinterPortIOXXDisp;

// *********************************************************************//
// DispIntf :  IDLPrinterPortIOXXEvents
// Flags :     (0)
// GUID :      {8ECA966B-E944-41AB-95F1-83454D0016BF}
// *********************************************************************//
template <class T>
class IDLPrinterPortIOXXEventsDispT : public TAutoDriver<IDLPrinterPortIOXXEvents>
{
public:
  IDLPrinterPortIOXXEventsDispT(){}

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


};
typedef IDLPrinterPortIOXXEventsDispT<IDLPrinterPortIOXXEvents> IDLPrinterPortIOXXEventsDisp;

// *********************************************************************//
// SmartIntf: TCOMIDLPrinterPortIOXX
// Interface: IDLPrinterPortIOXX
// *********************************************************************//
template <class T> HRESULT __fastcall
TCOMIDLPrinterPortIOXXT<T>::LPTStrobe(void)
{
  return (*this)->LPTStrobe();
}

template <class T> HRESULT __fastcall
TCOMIDLPrinterPortIOXXT<T>::LPTAutofd(VARIANT_BOOL Flag/*[in]*/)
{
  return (*this)->LPTAutofd(Flag);
}

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

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

template <class T> HRESULT __fastcall
TCOMIDLPrinterPortIOXXT<T>::LPTPrintChar(short CH/*[in]*/, VARIANT_BOOL* Value/*[out,retval]*/)
{
  return (*this)->LPTPrintChar(CH, Value);
}

template <class T> VARIANT_BOOL __fastcall
TCOMIDLPrinterPortIOXXT<T>::LPTPrintChar(short CH/*[in]*/)
{
  VARIANT_BOOL Value;
  OLECHECK(this->LPTPrintChar(, (VARIANT_BOOL*)&Value));
  return Value;
}

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

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

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

template <class T> HRESULT __fastcall
TCOMIDLPrinterPortIOXXT<T>::GetPin(short index/*[in]*/, VARIANT_BOOL* Value/*[out,retval]*/)
{
  return (*this)->GetPin(index, Value);
}

template <class T> VARIANT_BOOL __fastcall
TCOMIDLPrinterPortIOXXT<T>::GetPin(short index/*[in]*/)
{
  VARIANT_BOOL Value;
  OLECHECK(this->GetPin(, (VARIANT_BOOL*)&Value));
  return Value;
}

template <class T> HRESULT __fastcall
TCOMIDLPrinterPortIOXXT<T>::SetPin(short index/*[in]*/, VARIANT_BOOL state/*[in]*/)
{
  return (*this)->SetPin(index, state);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// *********************************************************************//
// DispIntf :  IDLPrinterPortIOXX
// Flags :     (4416) Dual OleAutomation Dispatchable
// GUID :      {99CFB01D-BC12-45E0-9ABB-838E5ADB9B0D}
// *********************************************************************//
template <class T> HRESULT __fastcall
IDLPrinterPortIOXXDispT<T>::LPTStrobe()
{
  _TDispID _dispid(*this, OLETEXT("LPTStrobe"), DISPID(1));
  return OleFunction(_dispid);
}

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

template <class T> HRESULT __fastcall
IDLPrinterPortIOXXDispT<T>::LPTInit()
{
  _TDispID _dispid(*this, OLETEXT("LPTInit"), DISPID(3));
  return OleFunction(_dispid);
}

template <class T> HRESULT __fastcall
IDLPrinterPortIOXXDispT<T>::LPTSlctIn()
{
  _TDispID _dispid(*this, OLETEXT("LPTSlctIn"), DISPID(4));
  return OleFunction(_dispid);
}

template <class T> HRESULT __fastcall
IDLPrinterPortIOXXDispT<T>::LPTPrintChar(short CH/*[in]*/, VARIANT_BOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("LPTPrintChar"), DISPID(5));
  TAutoArgs<1> _args;
  _args[1] = CH /*[VT_I2:0]*/;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OleFunction(_dispid, _args));
}

template <class T> VARIANT_BOOL __fastcall
IDLPrinterPortIOXXDispT<T>::LPTPrintChar(short CH/*[in]*/)
{
  VARIANT_BOOL Value;
  this->LPTPrintChar(CH, (VARIANT_BOOL*)&Value);
  return Value;
}

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

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

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

template <class T> HRESULT __fastcall
IDLPrinterPortIOXXDispT<T>::GetPin(short index/*[in]*/, VARIANT_BOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("GetPin"), DISPID(8));
  TAutoArgs<1> _args;
  _args[1] = index /*[VT_I2:0]*/;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OleFunction(_dispid, _args));
}

template <class T> VARIANT_BOOL __fastcall
IDLPrinterPortIOXXDispT<T>::GetPin(short index/*[in]*/)
{
  VARIANT_BOOL Value;
  this->GetPin(index, (VARIANT_BOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPrinterPortIOXXDispT<T>::SetPin(short index/*[in]*/, VARIANT_BOOL state/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("SetPin"), DISPID(9));
  TAutoArgs<2> _args;
  _args[1] = index /*[VT_I2:0]*/;
  _args[2] = state /*[VT_BOOL:0]*/;
  return OleFunction(_dispid, _args);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// *********************************************************************//
// DispIntf :  IDLPrinterPortIOXXEvents
// Flags :     (0)
// GUID :      {8ECA966B-E944-41AB-95F1-83454D0016BF}
// *********************************************************************//
#endif  //   __TLB_NO_INTERFACE_WRAPPERS


#if !defined(__TLB_NO_EVENT_WRAPPERS) && defined(USING_ATLVCL)
// *********************************************************************//
// CONNECTIONPOINT/EVENT PROXY
// CoClasse         : DLPrinterPortIOXX
// Interface d'événements : IDLPrinterPortIOXXEvents
// *********************************************************************//
template <class T>
class TEvents_DLPrinterPortIOXX : public IConnectionPointImpl<T,
                                                 &DIID_IDLPrinterPortIOXXEvents,
                                                 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:
  IDLPrinterPortIOXXEventsDisp m_EventIntfObj;
};

#endif  //   __TLB_NO_EVENT_WRAPPERS

};     // namespace Dlprinterporti_tlb

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

#pragma option pop

#endif // DLPrinterPortI_TLBH
