00001
00002
00003
00004
00005
00006 #ifndef __WXUTIL__
00007 #define __WXUTIL__
00008
00009 #pragma warning(disable: 4705)
00010
00011 class CCritSec {
00012
00013
00014
00015 CCritSec(const CCritSec &refCritSec);
00016 CCritSec &operator=(const CCritSec &refCritSec);
00017
00018 CRITICAL_SECTION m_CritSec;
00019
00020 #ifdef DEBUG
00021 public:
00022 DWORD m_currentOwner;
00023 DWORD m_lockCount;
00024 BOOL m_fTrace;
00025 public:
00026 CCritSec();
00027 ~CCritSec();
00028 void Lock();
00029 void Unlock();
00030 #else
00031
00032 public:
00033 CCritSec() {
00034 InitializeCriticalSection(&m_CritSec);
00035 };
00036
00037 ~CCritSec() {
00038 DeleteCriticalSection(&m_CritSec);
00039 };
00040
00041 void Lock() {
00042 EnterCriticalSection(&m_CritSec);
00043 };
00044
00045 void Unlock() {
00046 LeaveCriticalSection(&m_CritSec);
00047 };
00048 #endif
00049 };
00050
00051 #ifdef DEBUG
00052 BOOL WINAPI CritCheckIn(CCritSec * pcCrit);
00053 BOOL WINAPI CritCheckIn(const CCritSec * pcCrit);
00054 BOOL WINAPI CritCheckOut(CCritSec * pcCrit);
00055 BOOL WINAPI CritCheckOut(const CCritSec * pcCrit);
00056 void WINAPI DbgLockTrace(CCritSec * pcCrit, BOOL fTrace);
00057 #else
00058 #define CritCheckIn(x) TRUE
00059 #define CritCheckOut(x) TRUE
00060 #define DbgLockTrace(pc, fT)
00061 #endif
00062
00063 class CAutoLock {
00064
00065
00066
00067 CAutoLock(const CAutoLock &refAutoLock);
00068 CAutoLock &operator=(const CAutoLock &refAutoLock);
00069
00070 protected:
00071 CCritSec * m_pLock;
00072
00073 public:
00074 CAutoLock(CCritSec * plock)
00075 {
00076 m_pLock = plock;
00077 m_pLock->Lock();
00078 };
00079
00080 ~CAutoLock() {
00081 m_pLock->Unlock();
00082 };
00083 };
00084
00085 class CAMEvent
00086 {
00087
00088
00089
00090 CAMEvent(const CAMEvent &refEvent);
00091 CAMEvent &operator=(const CAMEvent &refEvent);
00092
00093 protected:
00094 HANDLE m_hEvent;
00095 public:
00096 CAMEvent(BOOL fManualReset = FALSE);
00097 ~CAMEvent();
00098
00099
00100 operator HANDLE () const { return m_hEvent; };
00101
00102 void Set() {EXECUTE_ASSERT(SetEvent(m_hEvent));};
00103 BOOL Wait(DWORD dwTimeout = INFINITE) {
00104 return (WaitForSingleObject(m_hEvent, dwTimeout) == WAIT_OBJECT_0);
00105 };
00106 void Reset() { ResetEvent(m_hEvent); };
00107 BOOL Check() { return Wait(0); };
00108 };
00109
00110 class CAMMsgEvent : public CAMEvent
00111 {
00112
00113 public:
00114
00115
00116 BOOL WaitMsg(DWORD dwTimeout = INFINITE);
00117 };
00118
00119 #define CTimeoutEvent CAMEvent
00120
00121 class AM_NOVTABLE CAMThread {
00122
00123
00124
00125 CAMThread(const CAMThread &refThread);
00126 CAMThread &operator=(const CAMThread &refThread);
00127
00128 CAMEvent m_EventSend;
00129 CAMEvent m_EventComplete;
00130
00131 DWORD m_dwParam;
00132 DWORD m_dwReturnVal;
00133
00134 protected:
00135 HANDLE m_hThread;
00136
00137
00138
00139 virtual DWORD ThreadProc() = 0;
00140
00141 public:
00142 CAMThread();
00143 virtual ~CAMThread();
00144
00145 CCritSec m_AccessLock;
00146 CCritSec m_WorkerLock;
00147
00148
00149
00150 static DWORD WINAPI InitialThreadProc(LPVOID pv);
00151
00152
00153 BOOL Create();
00154
00155
00156
00157 DWORD CallWorker(DWORD);
00158
00159
00160
00161 void Close() {
00162 HANDLE hThread = (HANDLE)InterlockedExchangePointer(&m_hThread, 0);
00163 if (hThread) {
00164 WaitForSingleObject(hThread, INFINITE);
00165 CloseHandle(hThread);
00166 }
00167 };
00168
00169
00170
00171 BOOL ThreadExists(void) const
00172 {
00173 if (m_hThread == 0) {
00174 return FALSE;
00175 } else {
00176 return TRUE;
00177 }
00178 }
00179
00180
00181 DWORD GetRequest();
00182
00183
00184 BOOL CheckRequest(DWORD * pParam);
00185
00186
00187 void Reply(DWORD);
00188
00189
00190
00191 HANDLE GetRequestHandle() const { return m_EventSend; };
00192
00193
00194 DWORD GetRequestParam() const { return m_dwParam; };
00195
00196
00197
00198 static HRESULT CoInitializeHelper();
00199 };
00200
00201 #define DEFAULT_QUEUESIZE 2
00202
00203 template <class T> class CQueue {
00204 private:
00205 HANDLE hSemPut;
00206 HANDLE hSemGet;
00207 CRITICAL_SECTION CritSect;
00208 int nMax;
00209 int iNextPut;
00210 int iNextGet;
00211 T *QueueObjects;
00212
00213 void Initialize(int n) {
00214 iNextPut = iNextGet = 0;
00215 nMax = n;
00216 InitializeCriticalSection(&CritSect);
00217 hSemPut = CreateSemaphore(NULL, n, n, NULL);
00218 hSemGet = CreateSemaphore(NULL, 0, n, NULL);
00219 QueueObjects = new T[n];
00220 }
00221
00222 public:
00223 CQueue(int n) {
00224 Initialize(n);
00225 }
00226
00227 CQueue() {
00228 Initialize(DEFAULT_QUEUESIZE);
00229 }
00230
00231 ~CQueue() {
00232 delete [] QueueObjects;
00233 DeleteCriticalSection(&CritSect);
00234 CloseHandle(hSemPut);
00235 CloseHandle(hSemGet);
00236 }
00237
00238 T GetQueueObject() {
00239 int iSlot;
00240 T Object;
00241 LONG lPrevious;
00242
00243
00244
00245
00246 WaitForSingleObject(hSemGet, INFINITE);
00247
00248 EnterCriticalSection(&CritSect);
00249 iSlot = iNextGet++ % nMax;
00250 Object = QueueObjects[iSlot];
00251 LeaveCriticalSection(&CritSect);
00252
00253
00254
00255
00256 ReleaseSemaphore(hSemPut, 1L, &lPrevious);
00257 return Object;
00258 }
00259
00260 void PutQueueObject(T Object) {
00261 int iSlot;
00262 LONG lPrevious;
00263
00264
00265
00266
00267 WaitForSingleObject(hSemPut, INFINITE);
00268
00269 EnterCriticalSection(&CritSect);
00270 iSlot = iNextPut++ % nMax;
00271 QueueObjects[iSlot] = Object;
00272 LeaveCriticalSection(&CritSect);
00273
00274
00275
00276
00277 ReleaseSemaphore(hSemGet, 1L, &lPrevious);
00278 }
00279 };
00280
00281 int WINAPIV wsprintfWInternal(LPWSTR, LPCWSTR, ...);
00282
00283 LPWSTR
00284 WINAPI
00285 lstrcpyWInternal(
00286 LPWSTR lpString1,
00287 LPCWSTR lpString2
00288 );
00289 LPWSTR
00290 WINAPI
00291 lstrcpynWInternal(
00292 LPWSTR lpString1,
00293 LPCWSTR lpString2,
00294 int iMaxLength
00295 );
00296 int
00297 WINAPI
00298 lstrcmpWInternal(
00299 LPCWSTR lpString1,
00300 LPCWSTR lpString2
00301 );
00302 int
00303 WINAPI
00304 lstrcmpiWInternal(
00305 LPCWSTR lpString1,
00306 LPCWSTR lpString2
00307 );
00308 int
00309 WINAPI
00310 lstrlenWInternal(
00311 LPCWSTR lpString
00312 );
00313
00314 #ifndef UNICODE
00315 #define wsprintfW wsprintfWInternal
00316 #define lstrcpyW lstrcpyWInternal
00317 #define lstrcpynW lstrcpynWInternal
00318 #define lstrcmpW lstrcmpWInternal
00319 #define lstrcmpiW lstrcmpiWInternal
00320 #define lstrlenW lstrlenWInternal
00321 #endif
00322
00323 extern "C"
00324 void * __stdcall memmoveInternal(void *, const void *, size_t);
00325
00326 inline void * __cdecl memchrInternal(const void *buf, int chr, size_t cnt)
00327 {
00328 #ifdef _X86_
00329 void *pRet = NULL;
00330
00331 _asm {
00332 cld
00333 mov ecx, cnt
00334 mov edi, buf
00335 mov eax, chr
00336 repne scasb
00337 jnz exit_memchr
00338 dec edi
00339
00340 mov pRet, edi
00341 exit_memchr:
00342 }
00343 return pRet;
00344
00345 #else
00346 while ( cnt && (*(unsigned char *)buf != (unsigned char)chr) ) {
00347 buf = (unsigned char *)buf + 1;
00348 cnt--;
00349 }
00350
00351 return(cnt ? (void *)buf : NULL);
00352 #endif
00353 }
00354
00355 void WINAPI IntToWstr(int i, LPWSTR wstr);
00356
00357 #define WstrToInt(sz) _wtoi(sz)
00358 #define atoiW(sz) _wtoi(sz)
00359 #define atoiA(sz) atoi(sz)
00360
00361 extern const DWORD bits555[3];
00362 extern const DWORD bits565[3];
00363 extern const DWORD bits888[3];
00364
00365 STDAPI_(const GUID) GetTrueColorType(const BITMAPINFOHEADER *pbmiHeader);
00366 STDAPI_(const GUID) GetBitmapSubtype(const BITMAPINFOHEADER *pbmiHeader);
00367 STDAPI_(WORD) GetBitCount(const GUID *pSubtype);
00368
00369 STDAPI_(CHAR *) GetSubtypeNameA(const GUID *pSubtype);
00370 STDAPI_(WCHAR *) GetSubtypeNameW(const GUID *pSubtype);
00371
00372 #ifdef UNICODE
00373 #define GetSubtypeName GetSubtypeNameW
00374 #else
00375 #define GetSubtypeName GetSubtypeNameA
00376 #endif
00377
00378 STDAPI_(LONG) GetBitmapFormatSize(const BITMAPINFOHEADER *pHeader);
00379 STDAPI_(DWORD) GetBitmapSize(const BITMAPINFOHEADER *pHeader);
00380 STDAPI_(BOOL) ContainsPalette(const VIDEOINFOHEADER *pVideoInfo);
00381 STDAPI_(const RGBQUAD *) GetBitmapPalette(const VIDEOINFOHEADER *pVideoInfo);
00382
00383 BOOL WINAPI IsEqualObject(IUnknown *pFirst, IUnknown *pSecond);
00384
00385 #define EqualPins(pPin1, pPin2) IsEqualObject(pPin1, pPin2)
00386
00387 LONGLONG WINAPI llMulDiv(LONGLONG a, LONGLONG b, LONGLONG c, LONGLONG rnd);
00388 LONGLONG WINAPI Int64x32Div32(LONGLONG a, LONG b, LONG c, LONG rnd);
00389
00390 STDAPI WriteBSTR(BSTR * pstrDest, LPCWSTR szSrc);
00391 STDAPI FreeBSTR(BSTR* pstr);
00392
00393 STDAPI AMGetWideString(LPCWSTR pszString, LPWSTR *ppszReturn);
00394
00395 DWORD WINAPI WaitDispatchingMessages(
00396 HANDLE hObject,
00397 DWORD dwWait,
00398 HWND hwnd = NULL,
00399 UINT uMsg = 0,
00400 HANDLE hEvent = NULL);
00401
00402 #define AmHresultFromWin32(x) (MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, x))
00403
00404 HRESULT AmGetLastErrorToHResult(void);
00405
00406 IUnknown* QzAtlComPtrAssign(IUnknown** pp, IUnknown* lp);
00407
00408 template <class T>
00409 class QzCComPtr
00410 {
00411 public:
00412 typedef T _PtrClass;
00413 QzCComPtr() {p=NULL;}
00414 QzCComPtr(T* lp)
00415 {
00416 if ((p = lp) != NULL)
00417 p->AddRef();
00418 }
00419 QzCComPtr(const QzCComPtr<T>& lp)
00420 {
00421 if ((p = lp.p) != NULL)
00422 p->AddRef();
00423 }
00424 ~QzCComPtr() {if (p) p->Release();}
00425 void Release() {if (p) p->Release(); p=NULL;}
00426 operator T*() {return (T*)p;}
00427 T& operator*() {ASSERT(p!=NULL); return *p; }
00428
00429
00430 T** operator&() { ASSERT(p==NULL); return &p; }
00431 T* operator->() { ASSERT(p!=NULL); return p; }
00432 T* operator=(T* lp){return (T*)QzAtlComPtrAssign((IUnknown**)&p, lp);}
00433 T* operator=(const QzCComPtr<T>& lp)
00434 {
00435 return (T*)QzAtlComPtrAssign((IUnknown**)&p, lp.p);
00436 }
00437 #if _MSC_VER>1020
00438 bool operator!(){return (p == NULL);}
00439 #else
00440 BOOL operator!(){return (p == NULL) ? TRUE : FALSE;}
00441 #endif
00442 T* p;
00443 };
00444
00445 #endif
