//------------------------------------------------------------------------------ // File: Tune.h // // Desc: Additional infrastructure to extend the tuner.idl. Works nicely // from C++. // // Copyright (c) 1999 - 2007, Microsoft Corporation. All rights reserved. //------------------------------------------------------------------------------ #pragma once #ifndef TUNE_H #define TUNE_H #include namespace BDATuningModel { const long DEFAULT_MIN_CHANNEL = 2; const long DEFAULT_MAX_CHANNEL = 999; const long DEFAULT_MIN_FREQUENCY = 535; //bottom us am const long DEFAULT_MAX_FREQUENCY = 108000; // top us fm const long DEFAULT_ANALOG_TUNER_COUNTRY_CODE = 1; //usa const TunerInputType DEFAULT_ANALOG_TUNER_INPUT_TYPE = TunerInputCable; //usa typedef CComQIPtr PQTuningSpaceContainer; typedef CComQIPtr PQTuningSpace; typedef CComQIPtr PQAnalogRadioTuningSpace; typedef CComQIPtr PQAnalogTVTuningSpace; typedef CComQIPtr PQATSCTuningSpace; typedef CComQIPtr PQDigitalCableTuningSpace; typedef CComQIPtr PQTuneRequest; typedef CComQIPtr PQChannelTuneRequest; typedef CComQIPtr PQChannelIDTuneRequest; typedef CComQIPtr PQATSCChannelTuneRequest; typedef CComQIPtr PQDigitalCableTuneRequest; typedef CComQIPtr PQLocator; typedef CComQIPtr PQDigitalLocator; typedef CComQIPtr PQATSCLocator; typedef CComQIPtr PQDVBTuningSpace; typedef CComQIPtr PQDVBTuneRequest; typedef CComQIPtr PQDVBSLocator; typedef CComQIPtr PQDVBSLocator2; typedef CComQIPtr PQDVBTLocator; typedef CComQIPtr PQDVBTLocator2; typedef CComQIPtr PQDVBCLocator; typedef CComQIPtr PQAuxInTuningSpace; typedef CComQIPtr PQBDAComparable; // tuning space container class TNTuningSpaceContainer : public PQTuningSpaceContainer { public: TNTuningSpaceContainer() {} TNTuningSpaceContainer(const PQTuningSpaceContainer &a) : PQTuningSpaceContainer(a) {} TNTuningSpaceContainer(ITuningSpace *p) : PQTuningSpaceContainer(p) {} TNTuningSpaceContainer(IUnknown *p) : PQTuningSpaceContainer(p) {} TNTuningSpaceContainer(const TNTuningSpaceContainer &a) : PQTuningSpaceContainer(a) {} TNTuningSpaceContainer& operator=(TNTuningSpaceContainer& rhs) { PQTuningSpaceContainer::operator=(rhs); return *this; } }; // tuning spaces template class TNTuningSpaceHelper : public TUNINGSPACETYPE { public: TNTuningSpaceHelper() {} TNTuningSpaceHelper(const TUNINGSPACETYPE &a) : TUNINGSPACETYPE(a) {} TNTuningSpaceHelper(ITuningSpace *p) : TUNINGSPACETYPE(p) {} TNTuningSpaceHelper(IUnknown *p) : TUNINGSPACETYPE(p) {} TNTuningSpaceHelper(const TNTuningSpaceHelper &a) : TUNINGSPACETYPE(a) {} TNTuningSpaceHelper& operator=(TNTuningSpaceHelper& rhs) { TUNINGSPACETYPE::operator=(rhs); return *this; } TNTuningSpaceHelper& operator=(TUNINGSPACETYPE& rhs) { TUNINGSPACETYPE::operator=(rhs); return *this; } TNTuningSpaceHelper& operator=(IUnknown *rhs) { TUNINGSPACETYPE::operator=(rhs); return *this; } TNTuningSpaceHelper& operator=(ITuningSpace *rhs) { TUNINGSPACETYPE::operator=(rhs); return *this; } bool operator==(TUNINGSPACETYPE& rhs) { CComBSTR rhsname; HRESULT hr = rhs->get_UniqueName(&rhsname); if (FAILED(hr)) { return false; } CComBSTR name; hr = (*this)->get_UniqueName(&name); if (FAILED(hr)) { return false; } return name == rhsname; } bool operator!=(TUNINGSPACETYPE& rhs) { return !operator==(rhs); } PQTuneRequest CreateTuneRequest() { PQTuneRequest p; HRESULT hr = (*this)->CreateTuneRequest(&p); if (FAILED(hr)) { return PQTuneRequest(); } return p; } PQLocator Locator() { _ASSERT(*this); PQLocator ts; HRESULT hr = (*this)->get_DefaultLocator(&ts); if (FAILED(hr)) { return PQLocator(); } return ts; } HRESULT Locator(PQLocator& l) { _ASSERT(*this); return (*this)->put_Locator(l); } void Clone() { PQTuningSpace t; HRESULT hr = (*this)->Clone(&t); if (FAILED(hr) || !t) { Release(); // clone failed, clear ourselves return; } TUNINGSPACETYPE::operator=(t); } }; typedef TNTuningSpaceHelper TNTuningSpace; template class TNAnalogRadioTuningSpaceHelper : public TNTuningSpaceHelper { public: TNAnalogRadioTuningSpaceHelper() {} TNAnalogRadioTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper(a) {} TNAnalogRadioTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper(p) {} TNAnalogRadioTuningSpaceHelper(const TNAnalogRadioTuningSpaceHelper &a) : TNTuningSpaceHelper(a) {} TNAnalogRadioTuningSpaceHelper& operator=(TNAnalogRadioTuningSpaceHelper& rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } template TNAnalogRadioTuningSpaceHelper& operator=(TNTuningSpaceHelper& rhs) { TNTuningSpaceHelper::operator=(TUNINGSPACETYPE(rhs)); return *this; } TNAnalogRadioTuningSpaceHelper& operator=(TUNINGSPACETYPE& rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } TNAnalogRadioTuningSpaceHelper& operator=(IUnknown* rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } long MaxFrequency() { _ASSERT(*this); long freq; HRESULT hr = (*this)->get_MaxFrequency(&freq); if (FAILED(hr)) { freq = DEFAULT_MAX_FREQUENCY; } return freq; } HRESULT MaxFrequency(long freq) { _ASSERT(*this); return (*this)->put_MaxFrequency(freq); } long MinFrequency() { _ASSERT(*this); long freq; HRESULT hr = (*this)->get_MinFrequency(&freq); if (FAILED(hr)) { freq = DEFAULT_MIN_FREQUENCY; } return freq; } HRESULT MinFrequency(long freq) { _ASSERT(*this); return (*this)->put_MinFrequency(freq); } long CountryCode() { _ASSERT(*this); long cc; HRESULT hr = (*this)->get_CountryCode(&cc); if (FAILED(hr)) { cc = DEFAULT_ANALOG_TUNER_INPUT_TYPE; } return cc; } HRESULT CountryCode(long cc) { _ASSERT(*this); return (*this)->put_CountryCode(cc); } }; typedef TNAnalogRadioTuningSpaceHelper TNAnalogRadioTuningSpace; template class TNAnalogTVTuningSpaceHelper : public TNTuningSpaceHelper { public: TNAnalogTVTuningSpaceHelper() {} TNAnalogTVTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper(a) {} TNAnalogTVTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper(p) {} TNAnalogTVTuningSpaceHelper(const TNAnalogTVTuningSpaceHelper &a) : TNTuningSpaceHelper(a) {} TNAnalogTVTuningSpaceHelper& operator=(TNAnalogTVTuningSpaceHelper& rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } template TNAnalogTVTuningSpaceHelper& operator=(TNTuningSpaceHelper& rhs) { TNTuningSpaceHelper::operator=(TUNINGSPACETYPE(rhs)); return *this; } TNAnalogTVTuningSpaceHelper& operator=(TUNINGSPACETYPE& rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } TNAnalogTVTuningSpaceHelper& operator=(IUnknown* rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } TunerInputType InputType() { _ASSERT(*this); TunerInputType ti; HRESULT hr = (*this)->get_InputType(&ti); if (FAILED(hr)) { ti = DEFAULT_ANALOG_TUNER_INPUT_TYPE; } return ti; } HRESULT InputType(TunerInputType ti) { _ASSERT(*this); return (*this)->put_InputType(&ti); } long CountryCode() { _ASSERT(*this); long cc; HRESULT hr = (*this)->get_CountryCode(&cc); if (FAILED(hr)) { cc = DEFAULT_ANALOG_TUNER_INPUT_TYPE; } return cc; } HRESULT CountryCode(long cc) { _ASSERT(*this); return (*this)->put_CountryCode(cc); } long MinChannel() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MinChannel(&chan); if (FAILED(hr)) { chan = DEFAULT_MIN_CHANNEL; } return chan; } HRESULT MinChannel(long chan) { _ASSERT(*this); return (*this)->put_MinChannel(chan); } long MaxChannel() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MaxChannel(&chan); if (FAILED(hr)) { chan = DEFAULT_MAX_CHANNEL; } return chan; } HRESULT MaxChannel(long chan) { _ASSERT(*this); return (*this)->put_MaxChannel(chan); } }; typedef TNAnalogTVTuningSpaceHelper TNAnalogTVTuningSpace; template class TNAuxInTuningSpaceHelper : public TNTuningSpaceHelper { public: TNAuxInTuningSpaceHelper() {} TNAuxInTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper(a) {} TNAuxInTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper(p) {} TNAuxInTuningSpaceHelper(const TNAuxInTuningSpaceHelper &a) : TNTuningSpaceHelper(a) {} TNAuxInTuningSpaceHelper& operator=(TNAuxInTuningSpaceHelper& rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } template TNAuxInTuningSpaceHelper& operator=(TNTuningSpaceHelper& rhs) { TNTuningSpaceHelper::operator=(TUNINGSPACETYPE(rhs)); return *this; } TNAuxInTuningSpaceHelper& operator=(TUNINGSPACETYPE& rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } TNAuxInTuningSpaceHelper& operator=(IUnknown* rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } long CountryCode() { _ASSERT(*this); long cc; HRESULT hr = (*this)->get_CountryCode(&cc); if (FAILED(hr)) { cc = DEFAULT_ANALOG_TUNER_INPUT_TYPE; } return cc; } HRESULT CountryCode(long cc) { _ASSERT(*this); return (*this)->put_CountryCode(cc); } }; typedef TNAuxInTuningSpaceHelper TNAuxInTuningSpace; template class TNATSCTuningSpaceHelper : public TNAnalogTVTuningSpaceHelper { public: TNATSCTuningSpaceHelper() {} TNATSCTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNAnalogTVTuningSpaceHelper(a) {} TNATSCTuningSpaceHelper(IUnknown *p) : TNAnalogTVTuningSpaceHelper(p) {} TNATSCTuningSpaceHelper(const TNATSCTuningSpaceHelper &a) : TNAnalogTVTuningSpaceHelper(a) {} TNATSCTuningSpaceHelper& operator=(TNATSCTuningSpaceHelper& rhs) { TNAnalogTVTuningSpaceHelper::operator=(rhs); return *this; } template TNATSCTuningSpaceHelper& operator=(TNTuningSpaceHelper& rhs) { TNAnalogTVTuningSpaceHelper::operator=(TUNINGSPACETYPE(rhs)); return *this; } TNATSCTuningSpaceHelper& operator=(TUNINGSPACETYPE& rhs) { TNAnalogTVTuningSpaceHelper::operator=(rhs); return *this; } TNATSCTuningSpaceHelper& operator=(IUnknown* rhs) { TNAnalogTVTuningSpaceHelper::operator=(rhs); return *this; } long MinMinorChannel() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MinMinorChannel(&chan); if (FAILED(hr)) { chan = DEFAULT_MIN_CHANNEL; } return chan; } HRESULT MinMinorChannel(long chan) { _ASSERT(*this); return (*this)->put_MinMinorChannel(chan); } long MaxMinorChannel() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MaxMinorChannel(&chan); if (FAILED(hr)) { chan = DEFAULT_MAX_CHANNEL; } return chan; } HRESULT MaxMinorChannel(long chan) { _ASSERT(*this); return (*this)->put_MaxMinorChannel(chan); } long MinPhysicalChannel() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MinPhysicalChannel(&chan); if (FAILED(hr)) { chan = DEFAULT_MIN_CHANNEL; } return chan; } HRESULT MinPhysicalChannel(long chan) { _ASSERT(*this); return (*this)->put_MinPhysicalChannel(chan); } long MaxPhysicalChannel() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MaxPhysicalChannel(&chan); if (FAILED(hr)) { chan = DEFAULT_MAX_CHANNEL; } return chan; } HRESULT MaxPhysicalChannel(long chan) { _ASSERT(*this); return (*this)->put_MaxPhysicalChannel(chan); } }; typedef TNATSCTuningSpaceHelper TNATSCTuningSpace; // DigitalCable template class TNDigitalCableTuningSpaceHelper : public TNATSCTuningSpaceHelper { public: TNDigitalCableTuningSpaceHelper() {} TNDigitalCableTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNATSCTuningSpaceHelper(a) {} TNDigitalCableTuningSpaceHelper(IUnknown *p) : TNATSCTuningSpaceHelper(p) {} TNDigitalCableTuningSpaceHelper(const TNDigitalCableTuningSpaceHelper &a) : TNATSCTuningSpaceHelper(a) {} TNDigitalCableTuningSpaceHelper& operator=(TNDigitalCableTuningSpaceHelper& rhs) { TNATSCTuningSpaceHelper::operator=(rhs); return *this; } template TNDigitalCableTuningSpaceHelper& operator=(TNTuningSpaceHelper& rhs) { TNATSCTuningSpaceHelper::operator=(TUNINGSPACETYPE(rhs)); return *this; } TNDigitalCableTuningSpaceHelper& operator=(TUNINGSPACETYPE& rhs) { TNATSCTuningSpaceHelper::operator=(rhs); return *this; } TNDigitalCableTuningSpaceHelper& operator=(IUnknown* rhs) { TNATSCTuningSpaceHelper::operator=(rhs); return *this; } long MinMajorChannel() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MinMajorChannel(&chan); if (FAILED(hr)) { chan = DEFAULT_MIN_CHANNEL; } return chan; } HRESULT MinMajorChannel(long chan) { _ASSERT(*this); return (*this)->put_MinMajorChannel(chan); } long MaxMajorChannel() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MaxMajorChannel(&chan); if (FAILED(hr)) { chan = DEFAULT_MAX_CHANNEL; } return chan; } HRESULT MaxMajorChannel(long chan) { _ASSERT(*this); return (*this)->put_MaxMajorChannel(chan); } long MinSourceID() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MinSourceID(&chan); if (FAILED(hr)) { chan = DEFAULT_MIN_CHANNEL; } return chan; } HRESULT MinSourceID(long chan) { _ASSERT(*this); return (*this)->put_MinSourceID(chan); } long MaxSourceID() { _ASSERT(*this); long chan; HRESULT hr = (*this)->get_MaxSourceID(&chan); if (FAILED(hr)) { chan = DEFAULT_MAX_CHANNEL; } return chan; } HRESULT MaxSourceID(long chan) { _ASSERT(*this); return (*this)->put_MaxSourceID(chan); } }; typedef TNDigitalCableTuningSpaceHelper TNDigitalCableTuningSpace; // dvb tuning space template class TNDVBTuningSpaceHelper : public TNTuningSpaceHelper { public: TNDVBTuningSpaceHelper() {} TNDVBTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper(a) {} TNDVBTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper(p) {} TNDVBTuningSpaceHelper(const TNDVBTuningSpaceHelper &a) : TNTuningSpaceHelper(a) {} TNDVBTuningSpaceHelper& operator=(TNDVBTuningSpaceHelper& rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } template TNDVBTuningSpaceHelper& operator=(TNTuningSpaceHelper& rhs) { TNTuningSpaceHelper::operator=(TUNINGSPACETYPE(rhs)); return *this; } TNDVBTuningSpaceHelper& operator=(TUNINGSPACETYPE& rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } TNDVBTuningSpaceHelper& operator=(IUnknown* rhs) { TNTuningSpaceHelper::operator=(rhs); return *this; } DVBSystemType SystemType() const { DVBSystemType st; HRESULT hr = (*this)->get_SystemType(&st); if (FAILED(hr)) { return DVB_Cable; } return st; } HRESULT SystemType(DVBSystemType st) { _ASSERT(*this); return (*this)->put_SystemType(st); } }; typedef TNDVBTuningSpaceHelper TNDVBTuningSpace; // locators template class TNLocatorHelper : public LOCATORTYPE { public: TNLocatorHelper() {} TNLocatorHelper(const LOCATORTYPE &a) : LOCATORTYPE(a) {} TNLocatorHelper(IUnknown *p) : LOCATORTYPE(p) {} TNLocatorHelper(const TNLocatorHelper &a) : LOCATORTYPE(a) {} TNLocatorHelper(ILocator *p) : LOCATORTYPE(p) {} TNLocatorHelper& operator=(TNLocatorHelper& rhs) { LOCATORTYPE::operator=(rhs); return *this; } TNLocatorHelper& operator=(LOCATORTYPE& rhs) { LOCATORTYPE::operator=(rhs); return *this; } TNLocatorHelper& operator=(ILocator* rhs) { LOCATORTYPE::operator=(rhs); return *this; } TNLocatorHelper& operator=(IUnknown* rhs) { LOCATORTYPE::operator=(rhs); return *this; } void Clone() { PQLocator t; HRESULT hr = (*this)->Clone(&t); if (FAILED(hr) || !t) { Release(); // clone failed, clear ourselves return; } LOCATORTYPE::operator=(t); } long CarrierFrequency() { _ASSERT(*this); long f; HRESULT hr = (*this)->get_CarrierFrequency(&f); if (FAILED(hr)) { return -1; } return f; } HRESULT CarrierFrequency(long f) { _ASSERT(*this); return (*this)->put_CarrierFrequency(f); } ModulationType Modulation() { _ASSERT(*this); ModulationType f; HRESULT hr = (*this)->get_Modulation(&f); if (FAILED(hr)) { return BDA_MOD_NOT_SET; } return f; } HRESULT Modulation(ModulationType f) { _ASSERT(*this); return (*this)->put_Modulation(f); } }; typedef TNLocatorHelper TNLocator; template class TNDigitalLocatorHelper : public TNLocatorHelper { public: TNDigitalLocatorHelper() {} TNDigitalLocatorHelper(const LOCATORTYPE &a) : TNLocatorHelper(a) {} TNDigitalLocatorHelper(IUnknown *p) : TNLocatorHelper(p) {} TNDigitalLocatorHelper(const TNDigitalLocatorHelper &a) : TNLocatorHelper(a) {} TNDigitalLocatorHelper(ILocator *p) : TNLocatorHelper(p) {} TNDigitalLocatorHelper& operator=(TNDigitalLocatorHelper& rhs) { LOCATORTYPE::operator=(rhs); return *this; } TNDigitalLocatorHelper& operator=(LOCATORTYPE& rhs) { TNLocatorHelper::operator=(rhs); return *this; } TNDigitalLocatorHelper& operator=(ILocator* rhs) { TNLocatorHelper::operator=(rhs); return *this; } TNDigitalLocatorHelper& operator=(IUnknown* rhs) { TNLocatorHelper::operator=(rhs); return *this; } FECMethod InnerFEC() { _ASSERT(*this); FECMethod f; HRESULT hr = (*this)->get_InnerFEC(&f); if (FAILED(hr)) { return BDA_FEC_METHOD_NOT_SET; } return f; } HRESULT InnerFEC(FECMethod f) { _ASSERT(*this); return (*this)->put_InnerFEC(f); } BinaryConvolutionCodeRate InnerFECRate() { _ASSERT(*this); BinaryConvolutionCodeRate f; HRESULT hr = (*this)->get_InnerFECRate(&f); if (FAILED(hr)) { return BDA_BCC_RATE_NOT_SET; } return f; } HRESULT InnerFECRate(BinaryConvolutionCodeRate f) { _ASSERT(*this); return (*this)->put_InnerFECRate(f); } FECMethod OuterFEC() { _ASSERT(*this); FECMethod f; HRESULT hr = (*this)->get_OuterFEC(&f); if (FAILED(hr)) { return BDA_FEC_METHOD_NOT_SET; } return f; } HRESULT OuterFEC(FECMethod f) { _ASSERT(*this); return (*this)->put_OuterFEC(f); } BinaryConvolutionCodeRate OuterFECRate() { _ASSERT(*this); BinaryConvolutionCodeRate f; HRESULT hr = (*this)->get_OuterFECRate(&f); if (FAILED(hr)) { return BDA_BCC_RATE_NOT_SET; } return f; } HRESULT OuterFECRate(BinaryConvolutionCodeRate f) { _ASSERT(*this); return (*this)->put_OuterFECRate(f); } long SymbolRate() { _ASSERT(*this); long f; HRESULT hr = (*this)->get_SymbolRate(&f); if (FAILED(hr)) { return -1; } return f; } HRESULT SymbolRate(long f) { _ASSERT(*this); return (*this)->put_SymbolRate(f); } }; typedef TNDigitalLocatorHelper TNDigitalLocator; template class TNATSCLocatorHelper : public TNDigitalLocatorHelper { public: TNATSCLocatorHelper() {} TNATSCLocatorHelper(const LOCATORTYPE &a) : TNDigitalLocatorHelper(a) {} TNATSCLocatorHelper(IUnknown *p) : TNDigitalLocatorHelper(p) {} TNATSCLocatorHelper(const TNATSCLocatorHelper &a) : TNDigitalLocatorHelper(a) {} TNATSCLocatorHelper(IATSCLocator *p) : TNDigitalLocatorHelper(p) {} TNATSCLocatorHelper(const TNLocatorHelper &a) : TNDigitalLocatorHelper(a) {} TNATSCLocatorHelper& operator=(TNATSCLocatorHelper& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNATSCLocatorHelper& operator=(TNLocatorHelper& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNATSCLocatorHelper& operator=(LOCATORTYPE& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNATSCLocatorHelper& operator=(IATSCLocator* rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNATSCLocatorHelper& operator=(IUnknown* rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } long PhysicalChannel() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_PhysicalChannel(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT PhysicalChannel(long pc) { _ASSERT(*this); return (*this)->put_PhysicalChannel(pc); } long TSID() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_TSID(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT TSID(long pc) { _ASSERT(*this); return (*this)->put_TSID(pc); } long ProgramNumber() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_ProgramNumber(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT ProgramNumber(long pc) { _ASSERT(*this); return (*this)->put_ProgramNumber(pc); } }; typedef TNATSCLocatorHelper TNATSCLocator; template class TNDVBSLocatorHelper : public TNDigitalLocatorHelper { public: TNDVBSLocatorHelper() {} TNDVBSLocatorHelper(const LOCATORTYPE &a) : TNDigitalLocatorHelper(a) {} TNDVBSLocatorHelper(IUnknown *p) : TNDigitalLocatorHelper(p) {} TNDVBSLocatorHelper(const TNDVBSLocatorHelper &a) : TNDigitalLocatorHelper(a) {} TNDVBSLocatorHelper(IDVBSLocator *p) : TNDigitalLocatorHelper(p) {} TNDVBSLocatorHelper(const TNLocatorHelper &a) : TNDigitalLocatorHelper(a) {} TNDVBSLocatorHelper& operator=(TNDVBSLocatorHelper& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBSLocatorHelper& operator=(TNDigitalLocatorHelper& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBSLocatorHelper& operator=(LOCATORTYPE& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBSLocatorHelper& operator=(IDVBSLocator* rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBSLocatorHelper& operator=(IUnknown* rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } Polarisation SignalPolarisation() { _ASSERT(*this); Polarisation pc; HRESULT hr = (*this)->get_SignalPolarisation(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT SignalPolarisation(Polarisation pc) { _ASSERT(*this); return (*this)->put_SignalPolarisation(pc); } VARIANT_BOOL WestPosition() { _ASSERT(*this); VARIANT_BOOL pc; HRESULT hr = (*this)->get_WestPosition(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT WestPosition(VARIANT_BOOL pc) { _ASSERT(*this); return (*this)->put_WestPosition(pc); } long OrbitalPosition() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_OrbitalPosition(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT OrbitalPosition(long pc) { _ASSERT(*this); return (*this)->put_OrbitalPosition(pc); } long Azimuth() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_Azimuth(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT Azimuth(long pc) { _ASSERT(*this); return (*this)->put_Azimuth(pc); } long Elevation() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_Elevation(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT Elevation(long pc) { _ASSERT(*this); return (*this)->put_Elevation(pc); } }; typedef TNDVBSLocatorHelper TNDVBSLocator; template class TNDVBSLocator2Helper : public TNDVBSLocatorHelper { public: TNDVBSLocator2Helper() {} TNDVBSLocator2Helper(const LOCATORTYPE &a) : TNDVBSLocatorHelper(a) {} TNDVBSLocator2Helper(IUnknown *p) : TNDVBSLocatorHelper(p) {} TNDVBSLocator2Helper(const TNDVBSLocator2Helper &a) : TNDVBSLocatorHelper(a) {} TNDVBSLocator2Helper(IDVBSLocator2 *p) : TNDVBSLocatorHelper(p) {} TNDVBSLocator2Helper(const TNLocatorHelper &a) : TNDVBSLocatorHelper(a) {} TNDVBSLocator2Helper& operator=(TNDVBSLocator2Helper& rhs) { TNDVBSLocatorHelper::operator=(rhs); return *this; } TNDVBSLocator2Helper& operator=(TNDVBSLocatorHelper& rhs) { TNDVBSLocatorHelper::operator=(rhs); return *this; } TNDVBSLocator2Helper& operator=(TNDigitalLocatorHelper& rhs) { TNDVBSLocatorHelper::operator=(rhs); return *this; } TNDVBSLocator2Helper& operator=(LOCATORTYPE& rhs) { TNDVBSLocatorHelper::operator=(rhs); return *this; } TNDVBSLocator2Helper& operator=(IDVBSLocator2* rhs) { TNDVBSLocatorHelper::operator=(rhs); return *this; } TNDVBSLocator2Helper& operator=(IUnknown* rhs) { TNDVBSLocatorHelper::operator=(rhs); return *this; } LNB_Source DiseqLNBSource() { _ASSERT(*this); LNB_Source pc; HRESULT hr = (*this)->get_DiseqLNBSource(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT DiseqLNBSource(LNB_Source pc) { _ASSERT(*this); return (*this)->put_DiseqLNBSource(pc); } long LocalOscillatorOverrideLow() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_LocalOscillatorOverrideLow(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT LocalOscillatorOverrideLow(long pc) { _ASSERT(*this); return (*this)->put_LocalOscillatorOverrideLow(pc); } long LocalOscillatorOverrideHigh() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_LocalOscillatorOverrideHigh(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT LocalOscillatorOverrideHigh(long pc) { _ASSERT(*this); return (*this)->put_LocalOscillatorOverrideHigh(pc); } long LocalLNBSwitchOverride() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_LocalLNBSwitchOverride(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT LocalLNBSwitchOverride(long pc) { _ASSERT(*this); return (*this)->put_LocalLNBSwitchOverride(pc); } long LocalSpectralInversionOverride() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_LocalSpectralInversionOverride(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT LocalSpectralInversionOverride(long pc) { _ASSERT(*this); return (*this)->put_LocalSpectralInversionOverride(pc); } RollOff SignalRollOff() { _ASSERT(*this); RollOff pc; HRESULT hr = (*this)->get_SignalRollOff(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT SignalRollOff(long pc) { _ASSERT(*this); return (*this)->put_SignalRollOff(pc); } Pilot SignalPilot() { _ASSERT(*this); Pilot pc; HRESULT hr = (*this)->get_SignalPilot(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT SignalPilot(long pc) { _ASSERT(*this); return (*this)->put_SignalPilot(pc); } }; typedef TNDVBSLocator2Helper TNDVBSLocator2; template class TNDVBTLocatorHelper : public TNDigitalLocatorHelper { public: TNDVBTLocatorHelper() {} TNDVBTLocatorHelper(const LOCATORTYPE &a) : TNDigitalLocatorHelper(a) {} TNDVBTLocatorHelper(IUnknown *p) : TNDigitalLocatorHelper(p) {} TNDVBTLocatorHelper(const TNDVBTLocatorHelper &a) : TNDigitalLocatorHelper(a) {} TNDVBTLocatorHelper(IDVBTLocator *p) : TNDigitalLocatorHelper(p) {} TNDVBTLocatorHelper(const TNLocatorHelper &a) : TNDigitalLocatorHelper(a) {} TNDVBTLocatorHelper& operator=(TNDVBTLocatorHelper& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBTLocatorHelper& operator=(TNDigitalLocatorHelper& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBTLocatorHelper& operator=(LOCATORTYPE& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBTLocatorHelper& operator=(IDVBTLocator* rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBTLocatorHelper& operator=(IUnknown* rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } long BandWidth() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_BandWidth(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT BandWidth(long pc) { _ASSERT(*this); return (*this)->put_BandWidth(pc); } FECMethod LPInnerFec() { _ASSERT(*this); FECMethod pc; HRESULT hr = (*this)->get_LPInnerFec(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT LPInnerFec(FECMethod pc) { _ASSERT(*this); return (*this)->put_LPInnerFec(pc); } BinaryConvolutionCodeRate LPInnerFecRate() { _ASSERT(*this); BinaryConvolutionCodeRate pc; HRESULT hr = (*this)->get_LPInnerFecRate(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT LPInnerFecRate(BinaryConvolutionCodeRate pc) { _ASSERT(*this); return (*this)->put_LPInnerFecRate(pc); } HierarchyAlpha HAlpha() { _ASSERT(*this); HierarchyAlpha pc; HRESULT hr = (*this)->get_HAlpha(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT HAlpha(HierarchyAlpha pc) { _ASSERT(*this); return (*this)->put_HAlpha(pc); } GuardInterval Guard() { _ASSERT(*this); GuardInterval pc; HRESULT hr = (*this)->get_Guard(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT Guard(GuardInterval pc) { _ASSERT(*this); return (*this)->put_Guard(pc); } TransmissionMode Mode() { _ASSERT(*this); TransmissionMode pc; HRESULT hr = (*this)->get_Mode(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT Mode(TransmissionMode pc) { _ASSERT(*this); return (*this)->put_Mode(pc); } VARIANT_BOOL OtherFrequencyInUse() { _ASSERT(*this); VARIANT_BOOL pc; HRESULT hr = (*this)->get_OtherFrequencyInUse(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT OtherFrequencyInUse(VARIANT_BOOL pc) { _ASSERT(*this); return (*this)->put_OtherFrequencyInUse(pc); } }; typedef TNDVBTLocatorHelper TNDVBTLocator; template class TNDVBTLocator2Helper : public TNDVBTLocatorHelper { public: TNDVBTLocator2Helper() {} TNDVBTLocator2Helper(const LOCATORTYPE &a) : TNDVBTLocatorHelper(a) {} TNDVBTLocator2Helper(IUnknown *p) : TNDVBTLocatorHelper(p) {} TNDVBTLocator2Helper(const TNDVBTLocatorHelper &a) : TNDVBTLocatorHelper(a) {} TNDVBTLocator2Helper(IDVBTLocator2 *p) : TNDVBTLocatorHelper(p) {} TNDVBTLocator2Helper(const TNLocatorHelper &a) : TNDVBTLocatorHelper(a) {} TNDVBTLocator2Helper& operator=(TNDVBTLocator2Helper& rhs) { TNDVBTLocatorHelper::operator=(rhs); return *this; } TNDVBTLocator2Helper& operator=(TNDVBTLocatorHelper& rhs) { TNDVBTLocatorHelper::operator=(rhs); return *this; } TNDVBTLocator2Helper& operator=(LOCATORTYPE& rhs) { TNDVBTLocatorHelper::operator=(rhs); return *this; } TNDVBTLocator2Helper& operator=(IDVBTLocator2* rhs) { TNDVBTLocatorHelper::operator=(rhs); return *this; } TNDVBTLocator2Helper& operator=(IUnknown* rhs) { TNDVBTLocatorHelper::operator=(rhs); return *this; } long PhysicalLayerPipeId() { _ASSERT(*this); long pc; HRESULT hr = (*this)->get_PhysicalLayerPipeId(&pc); if (FAILED(hr)) { return -1; } return pc; } HRESULT PhysicalLayerPipeId(long pc) { _ASSERT(*this); return (*this)->put_PhysicalLayerPipeId(pc); } }; typedef TNDVBTLocator2Helper TNDVBTLocator2; template class TNDVBCLocatorHelper : public TNDigitalLocatorHelper { public: TNDVBCLocatorHelper() {} TNDVBCLocatorHelper(const LOCATORTYPE &a) : TNDigitalLocatorHelper(a) {} TNDVBCLocatorHelper(IUnknown *p) : TNDigitalLocatorHelper(p) {} TNDVBCLocatorHelper(const TNDVBCLocatorHelper &a) : TNDigitalLocatorHelper(a) {} TNDVBCLocatorHelper(IDVBCLocator *p) : TNDigitalLocatorHelper(p) {} TNDVBCLocatorHelper(const TNLocatorHelper &a) : TNDigitalLocatorHelper(a) {} TNDVBCLocatorHelper& operator=(TNDVBCLocatorHelper& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBCLocatorHelper& operator=(TNDigitalLocatorHelper& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBCLocatorHelper& operator=(LOCATORTYPE& rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBCLocatorHelper& operator=(IDVBCLocator* rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } TNDVBCLocatorHelper& operator=(IUnknown* rhs) { TNDigitalLocatorHelper::operator=(rhs); return *this; } }; typedef TNDVBCLocatorHelper TNDVBCLocator; // tune requests template class TNTuneRequestHelper : public TUNEREQUESTTYPE { public: TNTuneRequestHelper() {} TNTuneRequestHelper(const TUNEREQUESTTYPE &a) : TUNEREQUESTTYPE(a) {} TNTuneRequestHelper(IUnknown *p) : TUNEREQUESTTYPE(p) {} TNTuneRequestHelper(const TNTuneRequestHelper &a) : TUNEREQUESTTYPE(a) {} TNTuneRequestHelper(ITuneRequest *p) : TUNEREQUESTTYPE(p) {} TNTuneRequestHelper& operator=(TNTuneRequestHelper& rhs) { TUNEREQUESTTYPE::operator=(rhs); return *this; } TNTuneRequestHelper& operator=(TUNEREQUESTTYPE& rhs) { TUNEREQUESTTYPE::operator=(rhs); return *this; } TNTuneRequestHelper& operator=(ITuneRequest* rhs) { TUNEREQUESTTYPE::operator=(rhs); return *this; } TNTuneRequestHelper& operator=(IUnknown* rhs) { TUNEREQUESTTYPE::operator=(rhs); return *this; } // this function creates a new instance of the base ITuneRequest* and copies // all the values of the current ITuneRequest and sets this to the new one // this provides the value semantics needed by the network providers void Clone() { PQTuneRequest t; HRESULT hr = (*this)->Clone(&t); if (FAILED(hr) || !t) { Release(); // clone failed, clear ourselves return; } TUNEREQUESTTYPE::operator=(t); } PQTuningSpace TuningSpace() { _ASSERT(*this); PQTuningSpace ts; HRESULT hr = (*this)->get_TuningSpace(&ts); if (FAILED(hr)) { return PQTuningSpace(); } return ts; } LOCATORTYPE Locator() { _ASSERT(*this); PQLocator pc; HRESULT hr = (*this)->get_Locator(&pc); if (FAILED(hr)) { return PQLocator().p; } return pc.p; } HRESULT Locator(LOCATORTYPE& pc) { _ASSERT(*this); return (*this)->put_Locator(pc); } }; typedef TNTuneRequestHelper TNTuneRequest; template class TNChannelTuneRequestHelper : public TNTuneRequestHelper { public: TNChannelTuneRequestHelper() {} TNChannelTuneRequestHelper(const TNTuneRequest &a) : TNTuneRequestHelper(a) {} TNChannelTuneRequestHelper(IChannelTuneRequest *p) : TNTuneRequestHelper(p) {} TNChannelTuneRequestHelper(IUnknown *p) : TNTuneRequestHelper(p) {} TNChannelTuneRequestHelper(const TNTuneRequestHelper &a) : TNTuneRequestHelper(a) {} TNChannelTuneRequestHelper(const TNChannelTuneRequestHelper &a) : TNTuneRequestHelper(a) {} TNChannelTuneRequestHelper& operator=(TNChannelTuneRequestHelper& rhs) { TNTuneRequestHelper::operator=(rhs); return *this; } template TNChannelTuneRequestHelper& operator=(TNTuneRequestHelper& rhs) { TNTuneRequestHelper::operator=(TUNEREQUESTTYPE(rhs)); return *this; } TNChannelTuneRequestHelper& operator=(TUNEREQUESTTYPE& rhs) { TNTuneRequestHelper::operator=(rhs); return *this; } TNChannelTuneRequestHelper& operator=(IChannelTuneRequest* rhs) { TNTuneRequestHelper::operator=(rhs); return *this; } TNChannelTuneRequestHelper& operator=(IUnknown* rhs) { TUNEREQUESTTYPE::operator=(rhs); return *this; } long Channel() { _ASSERT(*this); long c; HRESULT hr = (*this)->get_Channel(&c); if (FAILED(hr)) { return -1; } return c; } HRESULT Channel(long c) { _ASSERT(*this); return (*this)->put_Channel(c); } }; typedef TNChannelTuneRequestHelper TNChannelTuneRequest; template class TNChannelIDTuneRequestHelper : public TNTuneRequestHelper { public: TNChannelIDTuneRequestHelper() {} TNChannelIDTuneRequestHelper(const TNTuneRequest &a) : TNTuneRequestHelper(a) {} TNChannelIDTuneRequestHelper(IChannelIDTuneRequest *p) : TNTuneRequestHelper(p) {} TNChannelIDTuneRequestHelper(IUnknown *p) : TNTuneRequestHelper(p) {} TNChannelIDTuneRequestHelper(const TNTuneRequestHelper &a) : TNTuneRequestHelper(a) {} TNChannelIDTuneRequestHelper(const TNChannelIDTuneRequestHelper &a) : TNTuneRequestHelper(a) {} TNChannelIDTuneRequestHelper& operator=(TNChannelIDTuneRequestHelper& rhs) { TNTuneRequestHelper::operator=(rhs); return *this; } template TNChannelIDTuneRequestHelper& operator=(TNTuneRequestHelper& rhs) { TNTuneRequestHelper::operator=(TUNEREQUESTTYPE(rhs)); return *this; } TNChannelIDTuneRequestHelper& operator=(TUNEREQUESTTYPE& rhs) { TNTuneRequestHelper::operator=(rhs); return *this; } TNChannelIDTuneRequestHelper& operator=(IChannelIDTuneRequest* rhs) { TNTuneRequestHelper::operator=(rhs); return *this; } TNChannelIDTuneRequestHelper& operator=(IUnknown* rhs) { TUNEREQUESTTYPE::operator=(rhs); return *this; } BSTR ChannelID() { _ASSERT(*this); BSTR chanid; HRESULT hr = (*this)->get_ChannelID(&chanid); if (FAILED(hr)) { return NULL; } return chanid; } HRESULT ChannelID(BSTR chanid) { _ASSERT(*this); return (*this)->put_ChannelID(chanid); } }; typedef TNChannelIDTuneRequestHelper TNChannelIDTuneRequest; template class TNATSCChannelTuneRequestHelper : public TNChannelTuneRequestHelper { public: TNATSCChannelTuneRequestHelper() {} TNATSCChannelTuneRequestHelper(const TNTuneRequest &a) : TNChannelTuneRequestHelper(a) {} TNATSCChannelTuneRequestHelper(IATSCChannelTuneRequest *p) : TNChannelTuneRequestHelper(p) {} TNATSCChannelTuneRequestHelper(IUnknown *p) : TNChannelTuneRequestHelper(p) {} TNATSCChannelTuneRequestHelper(const TNChannelTuneRequestHelper &a) : TNChannelTuneRequestHelper(a) {} TNATSCChannelTuneRequestHelper(const TNATSCChannelTuneRequestHelper &a) : TNChannelTuneRequestHelper(a) {} TNATSCChannelTuneRequestHelper& operator=(TNATSCChannelTuneRequestHelper& rhs) { TNChannelTuneRequestHelper::operator=(rhs); return *this; } templateTNATSCChannelTuneRequestHelper& operator=(TNTuneRequestHelper& rhs) { TNChannelTuneRequestHelper::operator=(TR(rhs)); return *this; } TNATSCChannelTuneRequestHelper& operator=(TUNEREQUESTTYPE& rhs) { TNChannelTuneRequestHelper::operator=(rhs); return *this; } TNATSCChannelTuneRequestHelper& operator=(IATSCChannelTuneRequest *rhs) { TNChannelTuneRequestHelper::operator=(rhs); return *this; } TNTuneRequestHelper& operator=(IUnknown* rhs) { TUNEREQUESTTYPE::operator=(rhs); return *this; } long MinorChannel() { _ASSERT(*this); long mc; HRESULT hr = (*this)->get_MinorChannel(&mc); if (FAILED(hr)) { return -1; } return mc; } HRESULT MinorChannel(long mc) { _ASSERT(*this); return (*this)->put_MinorChannel(mc); } }; typedef TNATSCChannelTuneRequestHelper TNATSCChannelTuneRequest; //digital cable template class TNDigitalCableTuneRequestHelper : public TNATSCChannelTuneRequestHelper { public: TNDigitalCableTuneRequestHelper() {} TNDigitalCableTuneRequestHelper(const TNTuneRequest &a) : TNATSCChannelTuneRequestHelper(a) {} TNDigitalCableTuneRequestHelper(IDigitalCableTuneRequest *p) : TNATSCChannelTuneRequestHelper(p) {} TNDigitalCableTuneRequestHelper(IUnknown *p) : TNATSCChannelTuneRequestHelper(p) {} TNDigitalCableTuneRequestHelper(const TNATSCChannelTuneRequestHelper &a) : TNATSCChannelTuneRequestHelper(a) {} TNDigitalCableTuneRequestHelper(const TNDigitalCableTuneRequestHelper &a) : TNATSCChannelTuneRequestHelper(a) {} TNDigitalCableTuneRequestHelper& operator=(TNDigitalCableTuneRequestHelper& rhs) { TNATSCChannelTuneRequestHelper::operator=(rhs); return *this; } templateTNDigitalCableTuneRequestHelper& operator=(TNTuneRequestHelper& rhs) { TNATSCChannelTuneRequestHelper::operator=(TR(rhs)); return *this; } TNDigitalCableTuneRequestHelper& operator=(TUNEREQUESTTYPE& rhs) { TNATSCChannelTuneRequestHelper::operator=(rhs); return *this; } TNDigitalCableTuneRequestHelper& operator=(IDigitalCableTuneRequest *rhs) { TNATSCChannelTuneRequestHelper::operator=(rhs); return *this; } TNTuneRequestHelper& operator=(IUnknown* rhs) { TUNEREQUESTTYPE::operator=(rhs); return *this; } long MajorChannel() { _ASSERT(*this); long mc; HRESULT hr = (*this)->get_MajorChannel(&mc); if (FAILED(hr)) { return -1; } return mc; } HRESULT MajorChannel(long mc) { _ASSERT(*this); return (*this)->put_MajorChannel(mc); } long SourceID() { _ASSERT(*this); long mc; HRESULT hr = (*this)->get_SourceID(&mc); if (FAILED(hr)) { return -1; } return mc; } HRESULT SourceID(long mc) { _ASSERT(*this); return (*this)->put_SourceID(mc); } }; typedef TNDigitalCableTuneRequestHelper TNDigitalCableTuneRequest; template class TNDVBTuneRequestHelper : public TNTuneRequestHelper { public: TNDVBTuneRequestHelper() {} TNDVBTuneRequestHelper(const TNTuneRequest &a) : TNTuneRequestHelper(a) {} TNDVBTuneRequestHelper(IDVBTuneRequest *p) : TNTuneRequestHelper(p) {} TNDVBTuneRequestHelper(IUnknown *p) : TNTuneRequestHelper(p) {} TNDVBTuneRequestHelper(const TNTuneRequestHelper