summaryrefslogtreecommitdiffstats
path: root/sdk/dx8sdk/Include/tune.h
diff options
context:
space:
mode:
authorSergeanur <s.anureev@yandex.ua>2020-08-02 18:36:50 +0200
committerSergeanur <s.anureev@yandex.ua>2020-08-02 18:36:50 +0200
commita786dd45a4ebc6b91936b5e46d0ef0a9befc05af (patch)
treeced50966eaaf373f8733547046baf2bdc558662d /sdk/dx8sdk/Include/tune.h
parentMerge branch 'master' of https://github.com/GTAmodding/re3 into erorcun (diff)
downloadre3-a786dd45a4ebc6b91936b5e46d0ef0a9befc05af.tar
re3-a786dd45a4ebc6b91936b5e46d0ef0a9befc05af.tar.gz
re3-a786dd45a4ebc6b91936b5e46d0ef0a9befc05af.tar.bz2
re3-a786dd45a4ebc6b91936b5e46d0ef0a9befc05af.tar.lz
re3-a786dd45a4ebc6b91936b5e46d0ef0a9befc05af.tar.xz
re3-a786dd45a4ebc6b91936b5e46d0ef0a9befc05af.tar.zst
re3-a786dd45a4ebc6b91936b5e46d0ef0a9befc05af.zip
Diffstat (limited to 'sdk/dx8sdk/Include/tune.h')
-rw-r--r--sdk/dx8sdk/Include/tune.h1107
1 files changed, 1107 insertions, 0 deletions
diff --git a/sdk/dx8sdk/Include/tune.h b/sdk/dx8sdk/Include/tune.h
new file mode 100644
index 00000000..63920f90
--- /dev/null
+++ b/sdk/dx8sdk/Include/tune.h
@@ -0,0 +1,1107 @@
+//------------------------------------------------------------------------------
+// File: Tune.h
+//
+// Desc: Additional infrastructure to extend the tuner.idl. Works nicely
+// from C++.
+//
+// Copyright (c) 1999 - 2001, Microsoft Corporation. All rights reserved.
+//------------------------------------------------------------------------------
+
+
+#pragma once
+
+#ifndef TUNE_H
+#define TUNE_H
+
+#include <tuner.h>
+
+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<ITuningSpaceContainer> PQTuningSpaceContainer;
+typedef CComQIPtr<ITuningSpace> PQTuningSpace;
+typedef CComQIPtr<IAnalogRadioTuningSpace> PQAnalogRadioTuningSpace;
+typedef CComQIPtr<IAnalogTVTuningSpace> PQAnalogTVTuningSpace;
+typedef CComQIPtr<IATSCTuningSpace> PQATSCTuningSpace;
+typedef CComQIPtr<ITuneRequest> PQTuneRequest;
+typedef CComQIPtr<IChannelTuneRequest> PQChannelTuneRequest;
+typedef CComQIPtr<IATSCChannelTuneRequest> PQATSCChannelTuneRequest;
+typedef CComQIPtr<ILocator> PQLocator;
+typedef CComQIPtr<IATSCLocator> PQATSCLocator;
+typedef CComQIPtr<IDVBTuningSpace> PQDVBTuningSpace;
+typedef CComQIPtr<IDVBTuneRequest> PQDVBTuneRequest;
+typedef CComQIPtr<IDVBSLocator> PQDVBSLocator;
+typedef CComQIPtr<IDVBTLocator> PQDVBTLocator;
+typedef CComQIPtr<IDVBCLocator> PQDVBCLocator;
+typedef CComQIPtr<IAuxInTuningSpace> PQAuxInTuningSpace;
+
+// tuning space container
+class TNTuningSpaceContainer : public PQTuningSpaceContainer {
+ 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 TUNINGSPACETYPE, class TUNEREQUESTTYPE> 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<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TUNINGSPACETYPE(a) {}
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
+ TUNINGSPACETYPE::operator=(rhs);
+ return *this;
+ }
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
+ TUNINGSPACETYPE::operator=(rhs);
+ return *this;
+ }
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown *rhs) {
+ TUNINGSPACETYPE::operator=(rhs);
+ return *this;
+ }
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& 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<PQTuningSpace, PQTuneRequest> TNTuningSpace;
+
+template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNAnalogRadioTuningSpaceHelper : public TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> {
+public:
+ TNAnalogRadioTuningSpaceHelper() {}
+ TNAnalogRadioTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+ TNAnalogRadioTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(p) {}
+ TNAnalogRadioTuningSpaceHelper(const TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+ TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ template<class TS, class TR> TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TS, TR>& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(TUNINGSPACETYPE(rhs));
+ return *this;
+ }
+ TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown* rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::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);
+ }
+};
+typedef TNAnalogRadioTuningSpaceHelper<PQAnalogRadioTuningSpace, PQChannelTuneRequest> TNAnalogRadioTuningSpace;
+
+template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNAnalogTVTuningSpaceHelper : public TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> {
+public:
+ TNAnalogTVTuningSpaceHelper() {}
+ TNAnalogTVTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+ TNAnalogTVTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(p) {}
+ TNAnalogTVTuningSpaceHelper(const TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+ TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ template<class TS, class TR> TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TS, TR>& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(TUNINGSPACETYPE(rhs));
+ return *this;
+ }
+ TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown* rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::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<PQAnalogTVTuningSpace, PQChannelTuneRequest> TNAnalogTVTuningSpace;
+
+template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNAuxInTuningSpaceHelper : public TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> {
+public:
+ TNAuxInTuningSpaceHelper() {}
+ TNAuxInTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+ TNAuxInTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(p) {}
+ TNAuxInTuningSpaceHelper(const TNAuxInTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+ TNAuxInTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNAuxInTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ template<class TS, class TR> TNAuxInTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TS, TR>& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(TUNINGSPACETYPE(rhs));
+ return *this;
+ }
+ TNAuxInTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNAuxInTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown* rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+};
+typedef TNAuxInTuningSpaceHelper<PQAuxInTuningSpace, PQChannelTuneRequest> TNAuxInTuningSpace;
+
+template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNATSCTuningSpaceHelper : public TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> {
+public:
+ TNATSCTuningSpaceHelper() {}
+ TNATSCTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+ TNATSCTuningSpaceHelper(IUnknown *p) : TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(p) {}
+ TNATSCTuningSpaceHelper(const TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+
+ TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
+ TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ template<class TS, class TR> TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TS, TR>& rhs) {
+ TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(TUNINGSPACETYPE(rhs));
+ return *this;
+ }
+ TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
+ TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown* rhs) {
+ TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::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<PQATSCTuningSpace, PQATSCChannelTuneRequest> TNATSCTuningSpace;
+
+// dvb tuning space
+template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNDVBTuningSpaceHelper : public TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> {
+public:
+ TNDVBTuningSpaceHelper() {}
+ TNDVBTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+ TNDVBTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(p) {}
+ TNDVBTuningSpaceHelper(const TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
+ TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ template<class TS, class TR> TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TS, TR>& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(TUNINGSPACETYPE(rhs));
+ return *this;
+ }
+ TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown* rhs) {
+ TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::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<PQDVBTuningSpace, PQDVBTuneRequest> TNDVBTuningSpace;
+
+// locators
+template<class LOCATORTYPE> class TNLocatorHelper : public LOCATORTYPE {
+public:
+ TNLocatorHelper() {}
+ TNLocatorHelper(const LOCATORTYPE &a) : LOCATORTYPE(a) {}
+ TNLocatorHelper(IUnknown *p) : LOCATORTYPE(p) {}
+ TNLocatorHelper(const TNLocatorHelper<LOCATORTYPE> &a) : LOCATORTYPE(a) {}
+ TNLocatorHelper(ILocator *p) : LOCATORTYPE(p) {}
+ TNLocatorHelper<LOCATORTYPE>& operator=(TNLocatorHelper<LOCATORTYPE>& rhs) {
+ LOCATORTYPE::operator=(rhs);
+ return *this;
+ }
+ TNLocatorHelper<LOCATORTYPE>& operator=(LOCATORTYPE& rhs) {
+ LOCATORTYPE::operator=(rhs);
+ return *this;
+ }
+ TNLocatorHelper<LOCATORTYPE>& operator=(ILocator* rhs) {
+ LOCATORTYPE::operator=(rhs);
+ return *this;
+ }
+ TNLocatorHelper<LOCATORTYPE>& 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);
+ }
+
+ 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);
+ }
+ 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);
+ }
+
+ 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 TNLocatorHelper<PQLocator> TNLocator;
+
+template<class LOCATORTYPE> class TNATSCLocatorHelper : public TNLocatorHelper<LOCATORTYPE> {
+public:
+ TNATSCLocatorHelper() {}
+ TNATSCLocatorHelper(const LOCATORTYPE &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNATSCLocatorHelper(IUnknown *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
+ TNATSCLocatorHelper(const TNATSCLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNATSCLocatorHelper(IATSCLocator *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
+ TNATSCLocatorHelper(const TNLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNATSCLocatorHelper<LOCATORTYPE>& operator=(TNATSCLocatorHelper<LOCATORTYPE>& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNATSCLocatorHelper<LOCATORTYPE>& operator=(TNLocatorHelper<LOCATORTYPE>& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNATSCLocatorHelper<LOCATORTYPE>& operator=(LOCATORTYPE& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNATSCLocatorHelper<LOCATORTYPE>& operator=(IATSCLocator* rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNATSCLocatorHelper<LOCATORTYPE>& operator=(IUnknown* rhs) {
+ TNLocatorHelper<LOCATORTYPE>::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<PQATSCLocator> TNATSCLocator;
+
+template<class LOCATORTYPE> class TNDVBSLocatorHelper : public TNLocatorHelper<LOCATORTYPE> {
+public:
+ TNDVBSLocatorHelper() {}
+ TNDVBSLocatorHelper(const LOCATORTYPE &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNDVBSLocatorHelper(IUnknown *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
+ TNDVBSLocatorHelper(const TNDVBSLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNDVBSLocatorHelper(IDVBSLocator *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
+ TNDVBSLocatorHelper(const TNLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNDVBSLocatorHelper<LOCATORTYPE>& operator=(TNDVBSLocatorHelper<LOCATORTYPE>& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBSLocatorHelper<LOCATORTYPE>& operator=(TNLocatorHelper<LOCATORTYPE>& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBSLocatorHelper<LOCATORTYPE>& operator=(LOCATORTYPE& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBSLocatorHelper<LOCATORTYPE>& operator=(IDVBSLocator* rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBSLocatorHelper<LOCATORTYPE>& operator=(IUnknown* rhs) {
+ TNLocatorHelper<LOCATORTYPE>::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<PQDVBSLocator> TNDVBSLocator;
+
+
+
+template<class LOCATORTYPE> class TNDVBTLocatorHelper : public TNLocatorHelper<LOCATORTYPE> {
+public:
+ TNDVBTLocatorHelper() {}
+ TNDVBTLocatorHelper(const LOCATORTYPE &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNDVBTLocatorHelper(IUnknown *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
+ TNDVBTLocatorHelper(const TNDVBTLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNDVBTLocatorHelper(IDVBTLocator *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
+ TNDVBTLocatorHelper(const TNLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNDVBTLocatorHelper<LOCATORTYPE>& operator=(TNDVBTLocatorHelper<LOCATORTYPE>& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBTLocatorHelper<LOCATORTYPE>& operator=(TNLocatorHelper<LOCATORTYPE>& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBTLocatorHelper<LOCATORTYPE>& operator=(LOCATORTYPE& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBTLocatorHelper<LOCATORTYPE>& operator=(IDVBTLocator* rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBTLocatorHelper<LOCATORTYPE>& operator=(IUnknown* rhs) {
+ TNLocatorHelper<LOCATORTYPE>::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<PQDVBTLocator> TNDVBTLocator;
+
+template<class LOCATORTYPE> class TNDVBCLocatorHelper : public TNLocatorHelper<LOCATORTYPE> {
+public:
+ TNDVBCLocatorHelper() {}
+ TNDVBCLocatorHelper(const LOCATORTYPE &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNDVBCLocatorHelper(IUnknown *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
+ TNDVBCLocatorHelper(const TNDVBCLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNDVBCLocatorHelper(IDVBCLocator *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
+ TNDVBCLocatorHelper(const TNLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
+ TNDVBCLocatorHelper<LOCATORTYPE>& operator=(TNDVBCLocatorHelper<LOCATORTYPE>& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBCLocatorHelper<LOCATORTYPE>& operator=(TNLocatorHelper<LOCATORTYPE>& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBCLocatorHelper<LOCATORTYPE>& operator=(LOCATORTYPE& rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBCLocatorHelper<LOCATORTYPE>& operator=(IDVBCLocator* rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBCLocatorHelper<LOCATORTYPE>& operator=(IUnknown* rhs) {
+ TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+
+};
+typedef TNDVBCLocatorHelper<PQDVBCLocator> TNDVBCLocator;
+
+// tune requests
+template<class TUNEREQUESTTYPE, class LOCATORTYPE> class TNTuneRequestHelper : public TUNEREQUESTTYPE {
+public:
+ TNTuneRequestHelper() {}
+ TNTuneRequestHelper(const TUNEREQUESTTYPE &a) : TUNEREQUESTTYPE(a) {}
+ TNTuneRequestHelper(IUnknown *p) : TUNEREQUESTTYPE(p) {}
+ TNTuneRequestHelper(const TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TUNEREQUESTTYPE(a) {}
+ TNTuneRequestHelper(ITuneRequest *p) : TUNEREQUESTTYPE(p) {}
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& rhs) {
+ TUNEREQUESTTYPE::operator=(rhs);
+ return *this;
+ }
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TUNEREQUESTTYPE& rhs) {
+ TUNEREQUESTTYPE::operator=(rhs);
+ return *this;
+ }
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(ITuneRequest* rhs) {
+ TUNEREQUESTTYPE::operator=(rhs);
+ return *this;
+ }
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& 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<PQTuneRequest, PQLocator> TNTuneRequest;
+
+template<class TUNEREQUESTTYPE, class LOCATORTYPE> class TNChannelTuneRequestHelper : public TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> {
+public:
+ TNChannelTuneRequestHelper() {}
+ TNChannelTuneRequestHelper(const TNTuneRequest &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
+ TNChannelTuneRequestHelper(IChannelTuneRequest *p) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
+ TNChannelTuneRequestHelper(IUnknown *p) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
+ TNChannelTuneRequestHelper(const TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
+ TNChannelTuneRequestHelper(const TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
+ TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& rhs) {
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ template<class TR, class LOC> TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNTuneRequestHelper<TR, LOC>& rhs) {
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(TUNEREQUESTTYPE(rhs));
+ return *this;
+ }
+ TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TUNEREQUESTTYPE& rhs) {
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IChannelTuneRequest* rhs) {
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& 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<PQChannelTuneRequest, PQLocator> TNChannelTuneRequest;
+
+template<class TUNEREQUESTTYPE, class LOCATORTYPE> class TNATSCChannelTuneRequestHelper : public TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> {
+public:
+ TNATSCChannelTuneRequestHelper() {}
+ TNATSCChannelTuneRequestHelper(const TNTuneRequest &a) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
+ TNATSCChannelTuneRequestHelper(IATSCChannelTuneRequest *p) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
+ TNATSCChannelTuneRequestHelper(IUnknown *p) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
+ TNATSCChannelTuneRequestHelper(const TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
+ TNATSCChannelTuneRequestHelper(const TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
+ TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& rhs) {
+ TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ template<class TR, class LOC>TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNTuneRequestHelper<TR, LOC>& rhs) {
+ TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(TR(rhs));
+ return *this;
+ }
+ TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TUNEREQUESTTYPE& rhs) {
+ TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IATSCChannelTuneRequest *rhs) {
+ TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& 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<PQATSCChannelTuneRequest, PQATSCLocator> TNATSCChannelTuneRequest;
+
+template<class TUNEREQUESTTYPE, class LOCATORTYPE> class TNDVBTuneRequestHelper : public TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> {
+public:
+ TNDVBTuneRequestHelper() {}
+ TNDVBTuneRequestHelper(const TNTuneRequest &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
+ TNDVBTuneRequestHelper(IDVBTuneRequest *p) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
+ TNDVBTuneRequestHelper(IUnknown *p) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
+ TNDVBTuneRequestHelper(const TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
+ TNDVBTuneRequestHelper(const TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
+ TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& rhs) {
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ template<class TR, class LOC> TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNTuneRequestHelper<TR, LOC>& rhs) {
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(TUNEREQUESTTYPE(rhs));
+ return *this;
+ }
+ TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TUNEREQUESTTYPE& rhs) {
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IDVBTuneRequest* rhs) {
+ TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
+ return *this;
+ }
+ TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IUnknown* rhs) {
+ TUNEREQUESTTYPE::operator=(rhs);
+ return *this;
+ }
+ long ONID() {
+ _ASSERT(*this);
+ long c;
+ HRESULT hr = (*this)->get_ONID(&c);
+ if (FAILED(hr)) {
+ return -1;
+ }
+ return c;
+ }
+ HRESULT ONID(long c) {
+ _ASSERT(*this);
+ return (*this)->put_ONID(c);
+ }
+ long TSID() {
+ _ASSERT(*this);
+ long c;
+ HRESULT hr = (*this)->get_TSID(&c);
+ if (FAILED(hr)) {
+ return -1;
+ }
+ return c;
+ }
+ HRESULT TSID(long c) {
+ _ASSERT(*this);
+ return (*this)->put_TSID(c);
+ }
+ long SID() {
+ _ASSERT(*this);
+ long c;
+ HRESULT hr = (*this)->get_SID(&c);
+ if (FAILED(hr)) {
+ return -1;
+ }
+ return c;
+ }
+ HRESULT SID(long c) {
+ _ASSERT(*this);
+ return (*this)->put_SID(c);
+ }
+};
+typedef TNDVBTuneRequestHelper<PQDVBTuneRequest, PQLocator> TNDVBTuneRequest;
+}; // namespace
+
+#ifndef NO_DEFAULT_BDATUNINGMODEL_NAMESPACE
+using namespace BDATuningModel;
+#endif
+
+#endif
+// end of file - tune.h