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

// C++ TLBWRTR : $Revision:   1.134.1.41  $
// Fichier généré le 04.02.2004 19:35:04 depuis la bibliothèque de types ci-dessous.

// ************************************************************************ //
// Bibl.Types     : C:\DLPOrt\Cbuilder5\OCX\PrinterOCXControl\DLPrinterPortI.tlb (1)
// IID\LCID       : {BDD92659-E727-452B-AD12-61A00AC0093B}\0
// Fichier d'aide : 
// DepndLst       : 
//   (1) v2.0 stdole, (C:\WINDOWS\SYSTEM\stdole2.tlb)
//   (2) v4.0 StdVCL, (C:\WINDOWS\SYSTEM\STDVCL40.DLL)
// ************************************************************************ //
#ifndef   __DLPrinterPortI_TLB_h__
#define   __DLPrinterPortI_TLB_h__

#pragma option push -b -w-inl

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


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

namespace Dlprinterporti_tlb
{

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


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

// *********************************************************************//
// Déclaration Forward des types définis dans la bibliothèque de types    
// *********************************************************************//
interface DECLSPEC_UUID("{4227CAF2-D78E-435C-BEEB-9E7B3AC24043}") IDLPrinterPortIOXX;
typedef TComInterface<IDLPrinterPortIOXX, &IID_IDLPrinterPortIOXX> IDLPrinterPortIOXXPtr;
interface DECLSPEC_UUID("{ED407783-DA41-41D1-B72C-3F56483DA38D}") IDLPrinterPortIOXXEvents;
typedef TComInterface<IDLPrinterPortIOXXEvents, &DIID_IDLPrinterPortIOXXEvents> IDLPrinterPortIOXXEventsPtr;

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

#define LIBID_OF_DLPrinterPortIOXX (&LIBID_DLPrinterPortI)
// *********************************************************************//
// Interface   : IDLPrinterPortIOXX
// Indicateurs : (4416) Dual OleAutomation Dispatchable
// GUID        : {4227CAF2-D78E-435C-BEEB-9E7B3AC24043}
// *********************************************************************//
interface IDLPrinterPortIOXX  : public IDispatch
{
public:
  virtual HRESULT STDMETHODCALLTYPE LPTStrobe(void) = 0; // [1]
  virtual HRESULT STDMETHODCALLTYPE LPTAutofd(TOLEBOOL 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]*/, TOLEBOOL* 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]*/, TOLEBOOL* Value/*[out,retval]*/) = 0; // [8]
  virtual HRESULT STDMETHODCALLTYPE SetPin(short index/*[in]*/, TOLEBOOL state/*[in]*/) = 0; // [9]
  virtual HRESULT STDMETHODCALLTYPE get_LPTAckwl(TOLEBOOL* Value/*[out,retval]*/) = 0; // [10]
  virtual HRESULT STDMETHODCALLTYPE get_LPTBusy(TOLEBOOL* Value/*[out,retval]*/) = 0; // [11]
  virtual HRESULT STDMETHODCALLTYPE get_LPTPaperEnd(TOLEBOOL* Value/*[out,retval]*/) = 0; // [12]
  virtual HRESULT STDMETHODCALLTYPE get_LPTSlct(TOLEBOOL* Value/*[out,retval]*/) = 0; // [13]
  virtual HRESULT STDMETHODCALLTYPE get_LPTError(TOLEBOOL* 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(TOLEBOOL* Value/*[out,retval]*/) = 0; // [18]
  virtual HRESULT STDMETHODCALLTYPE set_DoubleBuffered(TOLEBOOL Value/*[in]*/) = 0; // [18]
  virtual HRESULT STDMETHODCALLTYPE get_VisibleDockClientCount(long* Value/*[out,retval]*/) = 0; // [19]
  virtual HRESULT STDMETHODCALLTYPE DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/) = 0; // [21]
  virtual HRESULT STDMETHODCALLTYPE get_Enabled(TOLEBOOL* Value/*[out,retval]*/) = 0; // [-514]
  virtual HRESULT STDMETHODCALLTYPE set_Enabled(TOLEBOOL Value/*[in]*/) = 0; // [-514]
  virtual HRESULT STDMETHODCALLTYPE InitiateAction(void) = 0; // [22]
  virtual HRESULT STDMETHODCALLTYPE IsRightToLeft(TOLEBOOL* Value/*[out,retval]*/) = 0; // [23]
  virtual HRESULT STDMETHODCALLTYPE UseRightToLeftReading(TOLEBOOL* Value/*[out,retval]*/) = 0; // [26]
  virtual HRESULT STDMETHODCALLTYPE UseRightToLeftScrollBar(TOLEBOOL* Value/*[out,retval]*/) = 0; // [27]
  virtual HRESULT STDMETHODCALLTYPE get_Visible(TOLEBOOL* Value/*[out,retval]*/) = 0; // [28]
  virtual HRESULT STDMETHODCALLTYPE set_Visible(TOLEBOOL Value/*[in]*/) = 0; // [28]
  virtual HRESULT STDMETHODCALLTYPE get_Cursor(short* Value/*[out,retval]*/) = 0; // [29]
  virtual HRESULT STDMETHODCALLTYPE set_Cursor(short Value/*[in]*/) = 0; // [29]
  virtual HRESULT STDMETHODCALLTYPE AboutBox(void) = 0; // [-552]

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


  __property   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   long            VisibleDockClientCount = {read = get_VisibleDockClientCount};
  __property   TOLEBOOL        Enabled = {read = get_Enabled, write = set_Enabled};
  __property   TOLEBOOL        Visible = {read = get_Visible, write = set_Visible};
  __property   short           Cursor = {read = get_Cursor, write = set_Cursor};

#endif //   __TLB_NO_INTERFACE_WRAPPERS

};

// *********************************************************************//
// Interface   : IDLPrinterPortIOXXEvents
// Indicateurs : (0)
// GUID        : {ED407783-DA41-41D1-B72C-3F56483DA38D}
// *********************************************************************//
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(TOLEBOOL Flag/*[in]*/);
  HRESULT         __fastcall LPTInit(void);
  HRESULT         __fastcall LPTSlctIn(void);
  HRESULT         __fastcall LPTPrintChar(short CH/*[in]*/, TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __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]*/, TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall GetPin(short index/*[in]*/);
  HRESULT         __fastcall SetPin(short index/*[in]*/, TOLEBOOL state/*[in]*/);
  HRESULT         __fastcall get_LPTAckwl(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTAckwl(void);
  HRESULT         __fastcall get_LPTBusy(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTBusy(void);
  HRESULT         __fastcall get_LPTPaperEnd(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTPaperEnd(void);
  HRESULT         __fastcall get_LPTSlct(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTSlct(void);
  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(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_DoubleBuffered(void);
  HRESULT         __fastcall set_DoubleBuffered(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_VisibleDockClientCount(long* Value/*[out,retval]*/);
  long            __fastcall get_VisibleDockClientCount(void);
  HRESULT         __fastcall DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/);
  long            __fastcall DrawTextBiDiModeFlagsReadingOnly(void);
  HRESULT         __fastcall get_Enabled(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Enabled(void);
  HRESULT         __fastcall set_Enabled(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall InitiateAction(void);
  HRESULT         __fastcall IsRightToLeft(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall IsRightToLeft(void);
  HRESULT         __fastcall UseRightToLeftReading(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall UseRightToLeftReading(void);
  HRESULT         __fastcall UseRightToLeftScrollBar(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall UseRightToLeftScrollBar(void);
  HRESULT         __fastcall get_Visible(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Visible(void);
  HRESULT         __fastcall set_Visible(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_Cursor(short* Value/*[out,retval]*/);
  short           __fastcall get_Cursor(void);
  HRESULT         __fastcall set_Cursor(short Value/*[in]*/);
  HRESULT         __fastcall AboutBox(void);

  __property   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   long            VisibleDockClientCount = {read = get_VisibleDockClientCount};
  __property   TOLEBOOL        Enabled = {read = get_Enabled, write = set_Enabled};
  __property   TOLEBOOL        Visible = {read = get_Visible, write = set_Visible};
  __property   short           Cursor = {read = get_Cursor, write = set_Cursor};
};
typedef TCOMIDLPrinterPortIOXXT<IDLPrinterPortIOXX> TCOMIDLPrinterPortIOXX;

// *********************************************************************//
// DispIntf:  IDLPrinterPortIOXX
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {4227CAF2-D78E-435C-BEEB-9E7B3AC24043}
// *********************************************************************//
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(TOLEBOOL Flag/*[in]*/);
  HRESULT         __fastcall LPTInit();
  HRESULT         __fastcall LPTSlctIn();
  HRESULT         __fastcall LPTPrintChar(short CH/*[in]*/, TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __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]*/, TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall GetPin(short index/*[in]*/);
  HRESULT         __fastcall SetPin(short index/*[in]*/, TOLEBOOL state/*[in]*/);
  HRESULT         __fastcall get_LPTAckwl(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTAckwl(void);
  HRESULT         __fastcall get_LPTBusy(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTBusy(void);
  HRESULT         __fastcall get_LPTPaperEnd(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTPaperEnd(void);
  HRESULT         __fastcall get_LPTSlct(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_LPTSlct(void);
  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(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_DoubleBuffered(void);
  HRESULT         __fastcall set_DoubleBuffered(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_VisibleDockClientCount(long* Value/*[out,retval]*/);
  long            __fastcall get_VisibleDockClientCount(void);
  HRESULT         __fastcall DrawTextBiDiModeFlagsReadingOnly(long* Value/*[out,retval]*/);
  long            __fastcall DrawTextBiDiModeFlagsReadingOnly(void);
  HRESULT         __fastcall get_Enabled(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Enabled(void);
  HRESULT         __fastcall set_Enabled(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall InitiateAction();
  HRESULT         __fastcall IsRightToLeft(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall IsRightToLeft(void);
  HRESULT         __fastcall UseRightToLeftReading(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall UseRightToLeftReading(void);
  HRESULT         __fastcall UseRightToLeftScrollBar(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall UseRightToLeftScrollBar(void);
  HRESULT         __fastcall get_Visible(TOLEBOOL* Value/*[out,retval]*/);
  TOLEBOOL        __fastcall get_Visible(void);
  HRESULT         __fastcall set_Visible(TOLEBOOL Value/*[in]*/);
  HRESULT         __fastcall get_Cursor(short* Value/*[out,retval]*/);
  short           __fastcall get_Cursor(void);
  HRESULT         __fastcall set_Cursor(short Value/*[in]*/);
  HRESULT         __fastcall AboutBox();

  __property   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   long            VisibleDockClientCount = {read = get_VisibleDockClientCount};
  __property   TOLEBOOL        Enabled = {read = get_Enabled, write = set_Enabled};
  __property   TOLEBOOL        Visible = {read = get_Visible, write = set_Visible};
  __property   short           Cursor = {read = get_Cursor, write = set_Cursor};
};
typedef IDLPrinterPortIOXXDispT<IDLPrinterPortIOXX> IDLPrinterPortIOXXDisp;

// *********************************************************************//
// DispIntf:  IDLPrinterPortIOXXEvents
// Flags:     (0)
// GUID:      {ED407783-DA41-41D1-B72C-3F56483DA38D}
// *********************************************************************//
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(TOLEBOOL 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]*/, TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->LPTPrintChar(CH, Value);
}

template <class T> TOLEBOOL __fastcall
TCOMIDLPrinterPortIOXXT<T>::LPTPrintChar(short CH/*[in]*/)
{
  TOLEBOOL Value;
  OLECHECK(this->LPTPrintChar(CH, (TOLEBOOL*)&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(Address, (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]*/, TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->GetPin(index, Value);
}

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

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

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

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

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

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

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

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

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

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

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

template <class T> TOLEBOOL __fastcall
TCOMIDLPrinterPortIOXXT<T>::get_LPTError(void)
{
  TOLEBOOL Value;
  OLECHECK(this->get_LPTError((TOLEBOOL*)&Value));
  return 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(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->get_DoubleBuffered(Value);
}

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

template <class T> HRESULT __fastcall
TCOMIDLPrinterPortIOXXT<T>::set_DoubleBuffered(TOLEBOOL Value/*[in]*/)
{
  return (*this)->set_DoubleBuffered(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(TOLEBOOL* Value/*[out,retval]*/)
{
  return (*this)->get_Enabled(Value);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// *********************************************************************//
// DispIntf:  IDLPrinterPortIOXX
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {4227CAF2-D78E-435C-BEEB-9E7B3AC24043}
// *********************************************************************//
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(TOLEBOOL 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]*/, TOLEBOOL* 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> TOLEBOOL __fastcall
IDLPrinterPortIOXXDispT<T>::LPTPrintChar(short CH/*[in]*/)
{
  TOLEBOOL Value;
  this->LPTPrintChar(CH, (TOLEBOOL*)&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]*/, TOLEBOOL* 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> TOLEBOOL __fastcall
IDLPrinterPortIOXXDispT<T>::GetPin(short index/*[in]*/)
{
  TOLEBOOL Value;
  this->GetPin(index, (TOLEBOOL*)&Value);
  return Value;
}

template <class T> HRESULT __fastcall
IDLPrinterPortIOXXDispT<T>::SetPin(short index/*[in]*/, TOLEBOOL 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(TOLEBOOL* 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> TOLEBOOL __fastcall
IDLPrinterPortIOXXDispT<T>::get_LPTAckwl(void)
{
  TOLEBOOL Value;
  this->get_LPTAckwl((TOLEBOOL*)&Value);
  return Value;
}

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

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

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

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

template <class T> HRESULT __fastcall
IDLPrinterPortIOXXDispT<T>::set_DoubleBuffered(TOLEBOOL 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_VisibleDockClientCount(long* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("VisibleDockClientCount"), DISPID(19));
  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(21));
  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(TOLEBOOL* Value/*[out,retval]*/)
{
  _TDispID _dispid(*this, OLETEXT("Enabled"), DISPID(-514));
  TAutoArgs<0> _args;
  return OutRetValSetterPtr(Value /*[VT_BOOL:1]*/, _args, OlePropertyGet(_dispid, _args));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <class T> HRESULT __fastcall
IDLPrinterPortIOXXDispT<T>::set_Cursor(short Value/*[in]*/)
{
  _TDispID _dispid(*this, OLETEXT("Cursor"), DISPID(29));
  TAutoArgs<1> _args;
  _args[1] = Value /*[VT_I2:0]*/;
  return OlePropertyPut(_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:      {ED407783-DA41-41D1-B72C-3F56483DA38D}
// *********************************************************************//
#endif  //   __TLB_NO_INTERFACE_WRAPPERS


#if !defined(__TLB_NO_EVENT_WRAPPERS) && defined(USING_ATLVCL)
// *********************************************************************//
// CONNECTIONPOINT/EVENT PROXY
// CoClass         : DLPrinterPortIOXX
// Event Interface : IDLPrinterPortIOXXEvents
// *********************************************************************//
template <class T>
class TEvents_DLPrinterPortIOXX : public IConnectionPointImpl<T,
                                                 &DIID_IDLPrinterPortIOXXEvents,
                                                 CComUnkArray<CONNECTIONPOINT_ARRAY_SIZE> >
{
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_TLB_h__
