X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=activex%2Futils.h;h=6234ab3cebd08643457ad7097f5864e9ad48a666;hb=cd6fc843b73051fbfb30c4164b5d76054383ea06;hp=1aad39e6f82599217db5a28b5d3208b786ba49e8;hpb=35db6dd6ecab2daf4c03ccc2c0be4b25a42c092c;p=vlc

diff --git a/activex/utils.h b/activex/utils.h
index 1aad39e6f8..6234ab3ceb 100644
--- a/activex/utils.h
+++ b/activex/utils.h
@@ -17,7 +17,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
 #ifndef __UTILS_H__
@@ -28,156 +28,147 @@
 #include <vector>
 
 // utilities
-extern char *CStrFromBSTR(int codePage, BSTR bstr);
-extern BSTR BSTRFromCStr(int codePage, const char *s);
+extern char *CStrFromWSTR(UINT codePage, LPCWSTR wstr, UINT len);
+extern char *CStrFromBSTR(UINT codePage, BSTR bstr);
+extern BSTR BSTRFromCStr(UINT codePage, LPCSTR s);
 
 // properties
 extern HRESULT GetObjectProperty(LPUNKNOWN object, DISPID dispID, VARIANT& v);
 
 // properties
 extern HDC CreateDevDC(DVTARGETDEVICE *ptd);
+extern void DPFromHimetric(HDC hdc, LPPOINT pt, int count);
+extern void HimetricFromDP(HDC hdc, LPPOINT pt, int count);
 
-// enumeration
-template<class T> class VLCEnum : IUnknown
-{
+// URL
+extern LPWSTR CombineURL(LPCWSTR baseUrl, LPCWSTR url);
 
-public:
+/**************************************************************************************************/
 
-    VLCEnum(REFIID riid, std::vector<T> &);
-    VLCEnum(const VLCEnum<T> &);
-    virtual ~VLCEnum() {};
+/* this function object is used to dereference the iterator into a value */
+template <typename T, class Iterator>
+struct VLCDereference
+{
+    T operator()(const Iterator& i) const
+    {
+        return *i;
+    };
+};
 
-    VLCEnum<T>& operator=(const VLCEnum<T> &t);
+template<REFIID EnumeratorIID, class Enumerator, typename T, class Iterator, typename Dereference = VLCDereference<T, Iterator> >
+class VLCEnumIterator : public Enumerator
+{
 
-    // IUnknown methods
-    STDMETHODIMP QueryInterface(REFIID riid, void **);
-    STDMETHODIMP_(ULONG) AddRef(void);
-    STDMETHODIMP_(ULONG) Release(void);
+public:
 
-    // IEnumXXXX methods
-    STDMETHODIMP Next(ULONG, T *, ULONG *);
-    STDMETHODIMP Skip(ULONG);
-    STDMETHODIMP Reset(void);
-    // cloning is implemented by subclasses and must use copy constructor
-    //STDMETHODIMP Clone(VLCEnum<T> **);
+    VLCEnumIterator(const Iterator& from, const Iterator& to) :
+        _refcount(1),
+        _begin(from),
+        _curr(from),
+        _end(to)
+    {};
 
-    typedef void (*retainer)(T);
+    VLCEnumIterator(const VLCEnumIterator& e) :
+        Enumerator(),
+        _refcount(e._refcount),
+        _begin(e._begin),
+        _curr(e._curr),
+        _end(e._end)
+    {};
 
-    void setRetainOperation(retainer retain) { _retain = retain; };
+    virtual ~VLCEnumIterator()
+    {};
 
-private:
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+    {
+        if( NULL == ppv )
+            return E_POINTER;
+        if( (IID_IUnknown == riid)
+         || (EnumeratorIID == riid) )
+        {
+            AddRef();
+            *ppv = reinterpret_cast<LPVOID>(this);
+            return NOERROR;
+        }
+        // standalone object
+        return E_NOINTERFACE;
+    };
+
+    STDMETHODIMP_(ULONG) AddRef(void)
+    {
+        return InterlockedIncrement(&_refcount);
+    };
 
-    LONG                                _refcount;
-    std::vector<T>                      _v;
-    typename std::vector<T>::iterator   _i;
-    REFIID                              _riid;
-    retainer                            _retain;
-};
+    STDMETHODIMP_(ULONG) Release(void)
+    {
+        ULONG refcount = InterlockedDecrement(&_refcount);
+        if( 0 == refcount )
+        {
+            delete this;
+            return 0;
+        }
+        return refcount;
+    };
 
-template<class T>
-VLCEnum<T>::VLCEnum(REFIID riid, std::vector<T> &v) :
-    _refcount(1),
-    _v(v),
-    _riid(riid),
-    _retain(NULL)
-{
-    _i= v.begin();
-};
 
-template<class T>
-VLCEnum<T>::VLCEnum(const VLCEnum<T> &e) :
-    _refcount(1),
-    _v(e._v),
-    _riid(e._riid)
-{
-};
+    // IEnumXXXX methods
+    STDMETHODIMP Next(ULONG celt, T *rgelt, ULONG *pceltFetched)
+    {
+        if( NULL == rgelt )
+            return E_POINTER;
 
-template<class T>
-VLCEnum<T>& VLCEnum<T>::operator=(const VLCEnum<T> &e)
-{
-    this->_refcount = 1;
-    this->_riid = e._riid;
-    this->_v    = e._v;
-    this->_i    = e._i;
-    return this;
-};
+        if( (celt > 1) && (NULL == pceltFetched) )
+            return E_INVALIDARG;
 
-template<class T>
-STDMETHODIMP VLCEnum<T>::QueryInterface(REFIID riid, void **ppv)
-{
-    if( NULL == ppv ) return E_POINTER;
-    if( (IID_IUnknown == riid) 
-     && ( _riid == riid) ) {
-        AddRef();
-        *ppv = reinterpret_cast<LPVOID>(this);
-        return NOERROR;
-    }
-    return E_NOINTERFACE;
-};
+        ULONG c = 0;
 
-template<class T>
-STDMETHODIMP_(ULONG) VLCEnum<T>::AddRef(void)
-{
-    return InterlockedIncrement(&_refcount);
-};
+        while( (c < celt) && (_curr != _end) )
+        {
+            rgelt[c] = dereference(_curr);
+            ++_curr;
+            ++c;
+        }
 
-template<class T>
-STDMETHODIMP_(ULONG) VLCEnum<T>::Release(void)
-{
-    ULONG refcount = InterlockedDecrement(&_refcount);
-    if( 0 == refcount )
-    {
-        delete this;
-        return 0;
-    }
-    return refcount;
-};
+        if( NULL != pceltFetched )
+            *pceltFetched = c;
 
-template<class T>
-STDMETHODIMP VLCEnum<T>::Next(ULONG celt, T *rgelt, ULONG *pceltFetched)
-{
-    if( NULL == rgelt )
-        return E_POINTER;
+        return (c == celt) ? S_OK : S_FALSE;
+    };
 
-    if( (celt > 1) && (NULL == pceltFetched) )
-        return E_INVALIDARG;
+    STDMETHODIMP Skip(ULONG celt)
+    {
+        ULONG c = 0;
 
-    ULONG c = 0;
-    typename std::vector<T>::iterator end = _v.end();
+        while( (c < celt) && (_curr != _end) )
+        {
+            ++_curr;
+            ++c;
+        }
+        return (c == celt) ? S_OK : S_FALSE;
+    };
 
-    while( (c < celt) && (_i != end) )
+    STDMETHODIMP Reset(void)
     {
-        rgelt[c] = *_i;
-        if( NULL != _retain ) _retain(rgelt[c]);
-        ++_i;
-        ++c;
-    }
+        _curr = _begin;
+        return S_OK;
+    };
 
-    if( NULL != pceltFetched )
-        *pceltFetched = c;
+    STDMETHODIMP Clone(Enumerator **ppEnum)
+    {
+        if( NULL == ppEnum )
+            return E_POINTER;
+        *ppEnum = dynamic_cast<Enumerator *>(new VLCEnumIterator(*this));
+        return (NULL != *ppEnum ) ? S_OK : E_OUTOFMEMORY;
+    };
 
-    return (c == celt) ? S_OK : S_FALSE;
-};
+private:
 
-template<class T>
-STDMETHODIMP VLCEnum<T>::Skip(ULONG celt)
-{
-    ULONG c = 0;
-    typename std::vector<T>::iterator end = _v.end();
+    LONG     _refcount;
+    Iterator _begin, _curr, _end;
 
-    while( (c < celt) && (_i != end) )
-    {
-        ++_i;
-        ++c;
-    }
-    return (c == celt) ? S_OK : S_FALSE;
-};
+    Dereference dereference;
 
-template<class T>
-STDMETHODIMP VLCEnum<T>::Reset(void)
-{
-    _i= _v.begin();
-    return S_OK;
 };
 
 #endif