git.sesse.net Git - vlc/blob - activex/utils.h

   1 /*****************************************************************************\r
   2  * utils.h: ActiveX control for VLC\r
   3  *****************************************************************************\r
   4  * Copyright (C) 2005 VideoLAN\r
   5  *\r
   6  * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>\r
   7  *\r
   8  * This program is free software; you can redistribute it and/or modify\r
   9  * it under the terms of the GNU General Public License as published by\r
  10  * the Free Software Foundation; either version 2 of the License, or\r
  11  * (at your option) any later version.\r
  12  *\r
  13  * This program is distributed in the hope that it will be useful,\r
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  16  * GNU General Public License for more details.\r
  17  *\r
  18  * You should have received a copy of the GNU General Public License\r
  19  * along with this program; if not, write to the Free Software\r
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.\r
  21  *****************************************************************************/\r
  22 \r
  23 #ifndef __UTILS_H__\r
  24 #define __UTILS_H__\r
  25 \r
  26 #include <ole2.h>\r
  27 \r
  28 #include <vector>\r
  29 \r
  30 // utilities\r
  31 extern char *CStrFromBSTR(int codePage, BSTR bstr);\r
  32 extern BSTR BSTRFromCStr(int codePage, const char *s);\r
  33 \r
  34 // properties\r
  35 extern HRESULT GetObjectProperty(LPUNKNOWN object, DISPID dispID, VARIANT& v);\r
  36 \r
  37 // enumeration\r
  38 template<class T> class VLCEnum : IUnknown\r
  39 {\r
  40 \r
  41 public:\r
  42 \r
  43     VLCEnum(REFIID riid, std::vector<T> &);\r
  44     VLCEnum(const VLCEnum<T> &);\r
  45     virtual ~VLCEnum() {};\r
  46 \r
  47     VLCEnum<T>& operator=(const VLCEnum<T> &t);\r
  48 \r
  49     // IUnknown methods\r
  50     STDMETHODIMP QueryInterface(REFIID riid, void **);\r
  51     STDMETHODIMP_(ULONG) AddRef(void);\r
  52     STDMETHODIMP_(ULONG) Release(void);\r
  53 \r
  54     // IEnumXXXX methods\r
  55     STDMETHODIMP Next(ULONG, T *, ULONG *);\r
  56     STDMETHODIMP Skip(ULONG);\r
  57     STDMETHODIMP Reset(void);\r
  58     // cloning is implemented by subclasses and must use copy constructor\r
  59     //STDMETHODIMP Clone(VLCEnum<T> **);\r
  60     // cloning is implemented by subclasses and must use copy constructor\r
  61 \r
  62     typedef void (*retainer)(T);\r
  63 \r
  64     void setRetainOperation(retainer retain) { _retain = retain; };\r
  65 \r
  66 private:\r
  67 \r
  68     LONG                                _refcount;\r
  69     std::vector<T>                      _v;\r
  70     typename std::vector<T>::iterator   _i;\r
  71     REFIID                              _riid;\r
  72     retainer                            _retain;\r
  73 };\r
  74 \r
  75 template<class T>\r
  76 VLCEnum<T>::VLCEnum(REFIID riid, std::vector<T> &v) :\r
  77     _refcount(1),\r
  78     _v(v),\r
  79     _riid(riid),\r
  80     _retain(NULL)\r
  81 {\r
  82     _i= v.begin();\r
  83 };\r
  84 \r
  85 template<class T>\r
  86 VLCEnum<T>::VLCEnum(const VLCEnum<T> &e) :\r
  87     _refcount(1),\r
  88     _v(e._v),\r
  89     _riid(e._riid)\r
  90 {\r
  91 };\r
  92 \r
  93 template<class T>\r
  94 VLCEnum<T>& VLCEnum<T>::operator=(const VLCEnum<T> &e)\r
  95 {\r
  96     this->_refcount = 1;\r
  97     this->_riid = e._riid;\r
  98     this->_v    = e._v;\r
  99     this->_i    = e._i;\r
 100 };\r
 101 \r
 102 template<class T>\r
 103 STDMETHODIMP VLCEnum<T>::QueryInterface(REFIID riid, void **ppv)\r
 104 {\r
 105     if( NULL == ppv ) return E_POINTER;\r
 106     if( (IID_IUnknown == riid) \r
 107      && ( _riid == riid) ) {\r
 108         AddRef();\r
 109         *ppv = reinterpret_cast<LPVOID>(this);\r
 110         return NOERROR;\r
 111     }\r
 112     return E_NOINTERFACE;\r
 113 };\r
 114 \r
 115 template<class T>\r
 116 STDMETHODIMP_(ULONG) VLCEnum<T>::AddRef(void)\r
 117 {\r
 118     return InterlockedIncrement(&_refcount);\r
 119 };\r
 120 \r
 121 template<class T>\r
 122 STDMETHODIMP_(ULONG) VLCEnum<T>::Release(void)\r
 123 {\r
 124     ULONG refcount = InterlockedDecrement(&_refcount);\r
 125     if( 0 == refcount )\r
 126     {\r
 127         delete this;\r
 128         return 0;\r
 129     }\r
 130     return refcount;\r
 131 };\r
 132 \r
 133 template<class T>\r
 134 STDMETHODIMP VLCEnum<T>::Next(ULONG celt, T *rgelt, ULONG *pceltFetched)\r
 135 {\r
 136     if( NULL == rgelt )\r
 137         return E_POINTER;\r
 138 \r
 139     if( (celt > 1) && (NULL == pceltFetched) )\r
 140         return E_INVALIDARG;\r
 141 \r
 142     ULONG c = 0;\r
 143     typename std::vector<T>::iterator end = _v.end();\r
 144 \r
 145     while( (c < celt) && (_i != end) )\r
 146     {\r
 147         rgelt[c] = *_i;\r
 148         if( NULL != _retain ) _retain(rgelt[c]);\r
 149         ++_i;\r
 150         ++c;\r
 151     }\r
 152 \r
 153     if( NULL != pceltFetched )\r
 154         *pceltFetched = c;\r
 155 \r
 156     return (c == celt) ? S_OK : S_FALSE;\r
 157 };\r
 158 \r
 159 template<class T>\r
 160 STDMETHODIMP VLCEnum<T>::Skip(ULONG celt)\r
 161 {\r
 162     ULONG c = 0;\r
 163     typename std::vector<T>::iterator end = _v.end();\r
 164 \r
 165     while( (c < celt) && (_i != end) )\r
 166     {\r
 167         ++_i;\r
 168         ++c;\r
 169     }\r
 170     return (c == celt) ? S_OK : S_FALSE;\r
 171 };\r
 172 \r
 173 template<class T>\r
 174 STDMETHODIMP VLCEnum<T>::Reset(void)\r
 175 {\r
 176     _i= _v.begin();\r
 177     return S_OK;\r
 178 };\r
 179 \r
 180 #endif\r
 181 \r