source: trunk/Utilities/ShowHresult/NotifyIconWindow.h @ 151

Last change on this file since 151 was 151, checked in by roman, 10 years ago

Some 500 more identifiers

  • Property svn:keywords set to Id
File size: 25.0 KB
Line 
1////////////////////////////////////////////////////////////
2// Copyright (C) Roman Ryltsov, 2008-2011
3// Created by Roman Ryltsov roman@alax.info
4//
5// $Id: NotifyIconWindow.h 151 2012-11-26 12:00:51Z roman $
6
7#pragma once
8
9#include <vfwmsgs.h>
10#include <asferr.h> // FACILITY_NS
11#include <nserror.h> // FACILITY_NS
12#include <mferror.h> // FACILITY_MF
13#include <wmcodecdsp.h> // FACILITY_WMAAECMA
14#include <ddraw.h> // _FACD3D
15//#include <d3d9helper.h> // _FACD3D
16#include <d3d9.h> // _FACD3D
17#include <d2derr.h> // FACILITY_D2D
18#include <wincodec.h> // FACILITY_WINCODEC_ERR
19#include <wia_lh.h> // FACILITY_WIA
20#include <corerror.h> // FACILITY_URT
21#include <audioclient.h> // FACILITY_AUDCLNT
22#include <p2p.h> // FACILITY_P2P
23
24#include <adserr.h>
25#include <azroles.h>
26#include <callobj.h>
27#include <cryptxml.h>
28#include <functiondiscoveryerror.h>
29#include <infotech.h>
30#include <naperror.h>
31#include <pstore.h>
32#include <sherrors.h>
33#include <ShObjIdl.h>
34#include <SubsMgr.h>
35#include <UrlMon.h>
36#include <wcmerrors.h>
37
38#include "rowinhttp.h"
39#include "AboutDialog.h"
40
41////////////////////////////////////////////////////////////
42// CNotifyIconWindow
43
44class CNotifyIconWindow : 
45        public CMessageOnlyWindowImpl<CNotifyIconWindow>
46{
47public:
48
49DECLARE_WND_CLASS(_T("CNotifyIconWindow"))
50
51BEGIN_MSG_MAP_EX(CNotifyIconWindow)
52        _Z4(atlTraceUI, 4, _T("uMsg 0x%04X, wParam 0x%08X, lParam 0x%08X\n"), uMsg, wParam, lParam);
53        //CHAIN_MSG_MAP(CMessageOnlyWindowImpl<CNotifyIconWindow>)
54        MSG_WM_CREATE(OnCreate)
55        MSG_WM_DESTROY(OnDestroy)
56        MSG_WM_CHANGECBCHAIN(OnChangeCbChain)
57        MSG_WM_DRAWCLIPBOARD(OnDrawClipboard)
58        MSG_WM_MOUSEMOVE(OnMouseMove)
59        MSG_WM_LBUTTONDBLCLK(OnLButtonDblClk)
60        MSG_WM_RBUTTONUP(OnRButtonUp)
61        MESSAGE_HANDLER_EX(NIN_BALLOONUSERCLICK, OnNotifyIconBalloonUserClick)
62        MESSAGE_HANDLER_EX(WM_NOTIFYICON, OnNotifyIcon)
63        COMMAND_ID_HANDLER_EX(ID_APP_ABOUT, OnApplicationAbout)
64        COMMAND_ID_HANDLER_EX(ID_APP_EXIT, OnApplicationExit)
65        REFLECT_NOTIFICATIONS()
66END_MSG_MAP()
67
68public:
69
70        //////////////////////////////////////////////////////////
71        // Window Message Identifiers
72
73        enum
74        {
75                WM_FIRST = WM_APP,
76                WM_NOTIFYICON,
77        };
78
79private:
80        ULONGLONG m_nCommonControlsVersion;
81        ULONGLONG m_nShellVersion;
82        NOTIFYICONDATA m_NotifyIconData;
83        CWindow m_NextClipboardViewerWindow;
84        CString m_sQuery;
85
86        static BOOL IsQuartzResult(HRESULT nResult, CString* psMessage = NULL)
87        {
88                if(HRESULT_FACILITY(nResult) != FACILITY_ITF)
89                        return FALSE;
90                const SCODE nCode = HRESULT_CODE(nResult);
91                if(nCode < 0x0200)// && nCode <= 0xFFFF)
92                        return FALSE;
93                const CString sMessage = AtlFormatSystemMessage(CDataLibraryMap::LoadLibrary(_T("quartz.dll")), nResult);
94                if(sMessage.IsEmpty())
95                        return FALSE;
96                if(psMessage)
97                        *psMessage = sMessage;
98                return TRUE;
99        }
100        static BOOL LookupQuartzIdentifier(HRESULT nValue, CString& sIdentifier)
101        {
102                _A(sIdentifier.IsEmpty());
103                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
104                {
105                        #define A(x) { x, #x },
106                        #include "DsIdentifier.inc"
107                        #undef A
108                };
109                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
110                        if(g_pMap[nIndex].nValue == nValue)
111                        {
112                                sIdentifier = CString(g_pMap[nIndex].pszName);
113                                return TRUE;
114                        }
115                return FALSE;
116        }
117        static BOOL IsWmResult(HRESULT nResult, CString* psMessage = NULL)
118        {
119                if(HRESULT_FACILITY(nResult) != FACILITY_NS)
120                        return FALSE;
121                // SUGG: Cache loaded libraries
122                HMODULE hModule = NULL;
123                const SCODE nCode = HRESULT_CODE(nResult);
124                CString sMessage;
125                if(nCode >= 2000 && nCode < 3000) // 2000 -  2999 = ASF (defined in ASFERR.MC)
126                        sMessage = AtlFormatSystemMessage(CDataLibraryMap::LoadLibrary(_T("asferror.dll")), nResult);
127                else
128                        sMessage = AtlFormatSystemMessage(CDataLibraryMap::LoadLibrary(_T("wmerror.dll")), nResult);
129                if(sMessage.IsEmpty())
130                        return FALSE;
131                if(psMessage)
132                        *psMessage = sMessage;
133                return TRUE;
134        }
135        static BOOL LookupWmIdentifier(HRESULT nValue, CString& sIdentifier)
136        {
137                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
138                {
139                        #define A(x) { x, #x },
140                        #include "WmIdentifier.inc"
141                        #undef A
142                };
143                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
144                        if(g_pMap[nIndex].nValue == nValue)
145                        {
146                                sIdentifier = CString(g_pMap[nIndex].pszName);
147                                return TRUE;
148                        }
149                return FALSE;
150        }
151        static BOOL IsMfResult(HRESULT nResult, CString* psMessage = NULL)
152        {
153                if(HRESULT_FACILITY(nResult) != FACILITY_MF)
154                        return FALSE;
155                const CString sMessage = AtlFormatSystemMessage(CDataLibraryMap::LoadLibrary(_T("mferror.dll")), nResult);
156                if(sMessage.IsEmpty())
157                        return FALSE;
158                if(psMessage)
159                        *psMessage = sMessage;
160                return TRUE;
161        }
162        static BOOL LookupMfIdentifier(HRESULT nValue, CString& sIdentifier)
163        {
164                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
165                {
166                        #define A(x) { x, #x },
167                        #include "MfIdentifier.inc"
168                        #undef A
169                };
170                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
171                        if(g_pMap[nIndex].nValue == nValue)
172                        {
173                                sIdentifier = CString(g_pMap[nIndex].pszName);
174                                return TRUE;
175                        }
176                return FALSE;
177        }
178        static BOOL IsAudioClientResult(HRESULT nResult, CString* psMessage = NULL, CString* psIdentifier = NULL)
179        {
180                if(HRESULT_FACILITY(nResult) != FACILITY_AUDCLNT)
181                        return FALSE;
182                psMessage;
183                CString sIdentifier;
184                if(!LookupAudioClientIdentifier(nResult, sIdentifier))
185                        return FALSE;
186                if(psIdentifier)
187                        *psIdentifier = sIdentifier;
188                return TRUE;
189        }
190        static BOOL LookupAudioClientIdentifier(HRESULT nValue, CString& sIdentifier)
191        {
192                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
193                {
194                        #define A(x) { x, #x },
195                        #include "AudioClientIdentifier.inc"
196                        #undef A
197                };
198                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
199                        if(g_pMap[nIndex].nValue == nValue)
200                        {
201                                sIdentifier = CString(g_pMap[nIndex].pszName);
202                                return TRUE;
203                        }
204                return FALSE;
205        }
206        static BOOL IsWs2Result(HRESULT nResult, CString* psMessage = NULL)
207        {
208                if(HRESULT_FACILITY(nResult) != FACILITY_WIN32)
209                        return FALSE;
210                const SCODE nCode = HRESULT_CODE(nResult);
211                if(nCode < 10000 || nCode >= 11150) // WSABASEERR, ...
212                        return FALSE;
213                const CString sMessage = AtlFormatSystemMessage(CDataLibraryMap::LoadLibrary(_T("ws2_32.dll")), nResult);
214                if(sMessage.IsEmpty())
215                        return FALSE;
216                if(psMessage)
217                        *psMessage = sMessage;
218                return TRUE;
219        }
220        static BOOL IsWinHttpResult(HRESULT nResult, CString* psMessage = NULL)
221        {
222                if(HRESULT_FACILITY(nResult) != FACILITY_WIN32)
223                        return FALSE;
224                const LONG nCode = HRESULT_CODE(nResult);
225                if(nCode < 12000 || nCode >= 12200) // WINHTTP_ERROR_BASE, WINHTTP_ERROR_LAST
226                        return FALSE;
227                const CString sMessage = AtlFormatSystemMessage(CDataLibraryMap::LoadLibrary(_T("winhttp.dll")), nResult);
228                if(sMessage.IsEmpty())
229                        return FALSE;
230                if(psMessage)
231                        *psMessage = sMessage;
232                return TRUE;
233        }
234        static BOOL IsWinInetResult(HRESULT nResult, CString* psMessage = NULL)
235        {
236                if(HRESULT_FACILITY(nResult) != FACILITY_WIN32)
237                        return FALSE;
238                const LONG nCode = HRESULT_CODE(nResult);
239                if(nCode < 12000 || nCode >= 12200) // INTERNET_ERROR_BASE, INTERNET_ERROR_LAST
240                        return FALSE;
241                const CString sMessage = AtlFormatSystemMessage(CDataLibraryMap::LoadLibrary(_T("wininet.dll")), nResult);
242                if(sMessage.IsEmpty())
243                        return FALSE;
244                if(psMessage)
245                        *psMessage = sMessage;
246                return TRUE;
247        }
248        static BOOL LookupSystemIdentifier(HRESULT nValue, CString& sIdentifier)
249        {
250                if(HRESULT_SEVERITY(nValue) == SEVERITY_ERROR && HRESULT_FACILITY(nValue) == FACILITY_WIN32)
251                        nValue = HRESULT_CODE(nValue);
252                if(nValue < 0 || nValue >= 16384)
253                        return FALSE;
254                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
255                {
256                        #define A(x) { x, #x },
257                        #include "SystemIdentifier.inc"
258                        #undef A
259                };
260                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
261                        if(g_pMap[nIndex].nValue == nValue)
262                        {
263                                sIdentifier = CString(g_pMap[nIndex].pszName);
264                                return TRUE;
265                        }
266                return FALSE;
267        }
268        static BOOL LookupHresultSystemIdentifier(HRESULT nValue, CString& sIdentifier)
269        {
270                //if(HRESULT_SEVERITY(nValue) != SEVERITY_ERROR)
271                //      return _T("");
272                if((UINT) HRESULT_FACILITY(nValue) >= 0x40)
273                        return FALSE;
274                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
275                {
276                        #define A(x) { x, #x },
277                        #include "SystemHresultIdentifier.inc"
278                        #undef A
279                };
280                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
281                        if(g_pMap[nIndex].nValue == nValue)
282                        {
283                                sIdentifier = CString(g_pMap[nIndex].pszName);
284                                return TRUE;
285                        }
286                return FALSE;
287        }
288        static BOOL IsD3dResult(HRESULT nResult, CString* psMessage = NULL, CString* psIdentifier = NULL)
289        {
290                if(HRESULT_FACILITY(nResult) != _FACD3D)
291                        return FALSE;
292                psMessage;
293                CString sIdentifier;
294                if(!LookupD3dIdentifier(nResult, sIdentifier))
295                        return FALSE;
296                if(psIdentifier)
297                        *psIdentifier = sIdentifier;
298                return TRUE;
299        }
300        static BOOL LookupD3dIdentifier(HRESULT nValue, CString& sIdentifier)
301        {
302                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
303                {
304                        #define A(x) { x, #x },
305                        #include "D3dIdentifier.inc"
306                        #undef A
307                };
308                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
309                        if(g_pMap[nIndex].nValue == nValue)
310                        {
311                                sIdentifier = CString(g_pMap[nIndex].pszName);
312                                return TRUE;
313                        }
314                return FALSE;
315        }
316        static BOOL IsD2dResult(HRESULT nResult, CString* psMessage = NULL, CString* psIdentifier = NULL)
317        {
318                if(HRESULT_FACILITY(nResult) != FACILITY_D2D)
319                        return FALSE;
320                psMessage;
321                CString sIdentifier;
322                if(!LookupD2dIdentifier(nResult, sIdentifier))
323                        return FALSE;
324                if(psIdentifier)
325                        *psIdentifier = sIdentifier;
326                return TRUE;
327        }
328        static BOOL LookupD2dIdentifier(HRESULT nValue, CString& sIdentifier)
329        {
330                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
331                {
332                        #define A(x) { x, #x },
333                        #include "D2dIdentifier.inc"
334                        #undef A
335                };
336                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
337                        if(g_pMap[nIndex].nValue == nValue)
338                        {
339                                sIdentifier = CString(g_pMap[nIndex].pszName);
340                                return TRUE;
341                        }
342                return FALSE;
343        }
344        static BOOL IsWicResult(HRESULT nResult, CString* psMessage = NULL, CString* psIdentifier = NULL)
345        {
346                if(HRESULT_FACILITY(nResult) != FACILITY_WINCODEC_ERR)
347                        return FALSE;
348                psMessage;
349                CString sIdentifier;
350                if(!LookupWicIdentifier(nResult, sIdentifier))
351                        return FALSE;
352                if(psIdentifier)
353                        *psIdentifier = sIdentifier;
354                return TRUE;
355        }
356        static BOOL LookupWicIdentifier(HRESULT nValue, CString& sIdentifier)
357        {
358                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
359                {
360                        #define A(x) { x, #x },
361                        #include "WicIdentifier.inc"
362                        #undef A
363                };
364                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
365                        if(g_pMap[nIndex].nValue == nValue)
366                        {
367                                sIdentifier = CString(g_pMap[nIndex].pszName);
368                                return TRUE;
369                        }
370                return FALSE;
371        }
372        static BOOL IsWiaResult(HRESULT nResult, CString* psMessage = NULL, CString* psIdentifier = NULL)
373        {
374                if(HRESULT_FACILITY(nResult) != FACILITY_WIA)
375                        return FALSE;
376                psMessage;
377                CString sIdentifier;
378                if(!LookupWiaIdentifier(nResult, sIdentifier))
379                        return FALSE;
380                if(psIdentifier)
381                        *psIdentifier = sIdentifier;
382                return TRUE;
383        }
384        static BOOL LookupWiaIdentifier(HRESULT nValue, CString& sIdentifier)
385        {
386                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
387                {
388                        #define A(x) { x, #x },
389                        #include "WiaIdentifier.inc"
390                        #undef A
391                };
392                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
393                        if(g_pMap[nIndex].nValue == nValue)
394                        {
395                                sIdentifier = CString(g_pMap[nIndex].pszName);
396                                return TRUE;
397                        }
398                return FALSE;
399        }
400        static BOOL IsUrtResult(HRESULT nResult, CString* psMessage = NULL, CString* psIdentifier = NULL)
401        {
402                if(HRESULT_FACILITY(nResult) != FACILITY_URT)
403                        return FALSE;
404                psMessage;
405                CString sIdentifier;
406                if(!LookupUrtIdentifier(nResult, sIdentifier))
407                        return FALSE;
408                if(psIdentifier)
409                        *psIdentifier = sIdentifier;
410                return TRUE;
411        }
412        static BOOL LookupUrtIdentifier(HRESULT nValue, CString& sIdentifier)
413        {
414                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
415                {
416                        #define A(x) { x, #x },
417                        #include "UrtIdentifier.inc"
418                        #undef A
419                };
420                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
421                        if(g_pMap[nIndex].nValue == nValue)
422                        {
423                                sIdentifier = CString(g_pMap[nIndex].pszName);
424                                return TRUE;
425                        }
426                return FALSE;
427        }
428        static BOOL IsP2pResult(HRESULT nResult, CString* psMessage = NULL, CString* psIdentifier = NULL)
429        {
430                if(HRESULT_FACILITY(nResult) != FACILITY_P2P)
431                        return FALSE;
432                psMessage;
433                CString sIdentifier;
434                if(!LookupP2pIdentifier(nResult, sIdentifier))
435                        return FALSE;
436                if(psIdentifier)
437                        *psIdentifier = sIdentifier;
438                return TRUE;
439        }
440        static BOOL LookupP2pIdentifier(HRESULT nValue, CString& sIdentifier)
441        {
442                static const struct { HRESULT nValue; LPCSTR pszName; } g_pMap[] = 
443                {
444                        #define A(x) { x, #x },
445                        #include "P2pIdentifier.inc"
446                        #undef A
447                };
448                for(SIZE_T nIndex = 0; nIndex < DIM(g_pMap); nIndex++)
449                        if(g_pMap[nIndex].nValue == nValue)
450                        {
451                                sIdentifier = CString(g_pMap[nIndex].pszName);
452                                return TRUE;
453                        }
454                return FALSE;
455        }
456
457public:
458// CNotifyIconWindow
459        static ULONGLONG GetCommonControlsVersion() throw()
460        {
461                DWORD nMajorVersion, nMinorVersion;
462                _W(SUCCEEDED(AtlGetCommCtrlVersion(&nMajorVersion, &nMinorVersion)));
463                return (ULONGLONG) ((nMajorVersion << 16) + nMinorVersion) << 32;
464        }
465        static ULONGLONG GetShellVersion() throw()
466        {
467                DWORD nMajorVersion, nMinorVersion;
468                _W(SUCCEEDED(AtlGetShellVersion(&nMajorVersion, &nMinorVersion)));
469                return (ULONGLONG) ((nMajorVersion << 16) + nMinorVersion) << 32;
470        }
471        CNotifyIconWindow()
472        {
473        }
474        HWND Create()
475        {
476                return __super::Create(NULL, rcDefault, _T("AlaxInfo.ShowHresult.NotifyIconWindow"));
477        }
478        static CString GetDefaultInfoTitle()
479        {
480                return AtlLoadString(IDS_NOTIFYICON_DEFAULTTIPTITLE);
481        }
482        static DWORD GetDefaultInfoFlags() throw()
483        {
484                return NIIF_NONE;
485        }
486        VOID SetBalloonToolTip(DWORD nFlags, LPCTSTR pszTitle, LPCTSTR pszText, UINT nTimeout = 30 * 1000)
487        {
488                if(IsWindow() && m_NotifyIconData.uFlags & NIF_INFO)
489                {
490                        m_NotifyIconData.uTimeout = nTimeout;
491                        m_NotifyIconData.dwInfoFlags = nFlags;
492                        _tcsncpy_s(m_NotifyIconData.szInfoTitle, pszTitle, _TRUNCATE);
493                        _tcsncpy_s(m_NotifyIconData.szInfo, pszText, _TRUNCATE);
494                        _W(Shell_NotifyIcon(NIM_MODIFY, &m_NotifyIconData));
495                }
496        }
497        static BOOL IsDecimal(TCHAR nCharacter) throw()
498        {
499                return _tcschr(_T("0123456789"), nCharacter) != NULL;
500        }
501        static BOOL IsDecimal(const TCHAR* pszCharacters, SIZE_T nCount) throw()
502        {
503                for(SIZE_T nIndex = 0; nIndex < nCount; nIndex++)
504                        if(!IsDecimal(pszCharacters[nIndex]))
505                                return FALSE;
506                return TRUE;
507        }
508        static BOOL IsDecimal(const TCHAR* pszCharacters) throw()
509        {
510                return IsDecimal(pszCharacters, _tcslen(pszCharacters));
511        }
512        static BOOL IsHexadecimal(TCHAR nCharacter) throw()
513        {
514                return _tcschr(_T("0123456789ABCDEFabcdef"), nCharacter) != NULL;
515        }
516        static BOOL IsHexadecimal(const TCHAR* pszCharacters, SIZE_T nCount) throw()
517        {
518                for(SIZE_T nIndex = 0; nIndex < nCount; nIndex++)
519                        if(!IsHexadecimal(pszCharacters[nIndex]))
520                                return FALSE;
521                return TRUE;
522        }
523        static BOOL IsHexadecimal(const TCHAR* pszCharacters) throw()
524        {
525                return IsHexadecimal(pszCharacters, _tcslen(pszCharacters));
526        }
527        BOOL Process(LPCTSTR pszText)
528        {
529                #pragma region Parse
530                if(_tcslen(pszText) > 24)
531                        return FALSE;
532                CString sText = pszText;
533                sText.Trim();
534                #pragma region Delete Trailing L (as in 0x00000000L)
535                if(!sText.IsEmpty() && _tcschr(_T("Ll"), sText[sText.GetLength() - 1]))
536                        sText.Delete(sText.GetLength() - 1);
537                #pragma endregion
538                #pragma region Unquote Single Quote
539                if(sText.GetLength() > 2 && sText[0] == _T('\'') && sText[sText.GetLength() - 1] == _T('\''))
540                {
541                        sText = sText.Mid(1, sText.GetLength() - 2);
542                        sText.Trim();
543                }
544                #pragma endregion
545                if(sText.IsEmpty())
546                        return FALSE;
547                LONGLONG nLongLongResult;
548                #pragma region Hexadecimal
549                if(_tcsnicmp(sText, _T("0x"), 2) == 0)
550                {
551                        if(!IsHexadecimal((LPCTSTR) sText + 2))
552                                return FALSE;
553                        if(!StrToInt64Ex(sText, STIF_SUPPORT_HEX, &nLongLongResult))
554                                return FALSE; 
555                } else
556                #pragma endregion
557                #pragma region Integer
558                {
559                        SIZE_T nIndex = 0;
560                        if(sText[0] == _T('-'))
561                                nIndex++;
562                        if(!IsDecimal((LPCTSTR) sText + nIndex))
563                        {
564                                #pragma region Eight Characater Long Hexadecimal without Prefix
565                                if(sText.GetLength() == nIndex + 8 && IsHexadecimal((LPCTSTR) sText + nIndex))
566                                {
567                                        sText.Insert(0, _T("0x"));
568                                        if(!StrToInt64Ex(sText, STIF_SUPPORT_HEX, &nLongLongResult))
569                                                return FALSE; 
570                                } else
571                                #pragma endregion
572                                        return FALSE;
573                        } else
574                                nLongLongResult = _ttoi64((LPCTSTR) sText + nIndex);
575                        if(nIndex)
576                                nLongLongResult = -nLongLongResult;
577                }
578                #pragma endregion
579                const LONG nHighLongLongResult = (LONG) (nLongLongResult >> 32);
580                if(!nLongLongResult || nHighLongLongResult > 0 || nHighLongLongResult < -1)
581                        return FALSE;
582                HRESULT nResult = (LONG) nLongLongResult;
583                #pragma endregion
584                #pragma region Lookup
585                // NOTE: Include file regular expression replacement: ^.+?\#define +([^ ]+?) +MAKE_D3D.+\r?$ -> A($1)
586                CString sTitle, sMessage, sIdentifier;
587                if(IsQuartzResult(nResult, &sMessage))// || LookupQuartzIdentifier(nResult, sIdentifier))
588                {
589                        LookupQuartzIdentifier(nResult, sIdentifier);
590                        sTitle = _T("DirectShow");
591                } else if(IsWmResult(nResult, &sMessage))
592                {
593                        LookupWmIdentifier(nResult, sIdentifier);
594                        sTitle = _T("Windows Media");
595                } else if(IsMfResult(nResult, &sMessage))
596                {
597                        LookupMfIdentifier(nResult, sIdentifier);
598                        sTitle = _T("Media Foundation");
599                } else if(IsAudioClientResult(nResult, &sMessage, &sIdentifier) || LookupAudioClientIdentifier(nResult, sIdentifier))
600                        sTitle = _T("Audio Client");
601                #pragma region Obsolete?
602                // NOTE: These are perhaps useless in Windows 7, but I am under impression they are helpful in earlier systems
603                else if(IsWs2Result(nResult, &sMessage))
604                        sTitle = _T("Sockets");
605                else if(IsWinHttpResult(nResult, &sMessage))
606                        sTitle = _T("WinHTTP");
607                else if(IsWinInetResult(nResult, &sMessage))
608                        sTitle = _T("WinInet");
609                #pragma endregion
610                #pragma region Win32 Priority
611                else if(HRESULT_SEVERITY(nResult) == SEVERITY_ERROR && HRESULT_FACILITY(nResult) == FACILITY_WIN32 && (UINT) HRESULT_CODE(nResult) < 300)
612                {
613                        sMessage = AtlFormatSystemMessage(nResult);
614                        if(!LookupSystemIdentifier(nResult, sIdentifier))
615                                 LookupHresultSystemIdentifier(nResult, sIdentifier);
616                        if(!sMessage.IsEmpty() || !sIdentifier.IsEmpty())
617                                sTitle = _T("System");
618                }
619                #pragma endregion
620                else if(IsD3dResult(nResult, &sMessage, &sIdentifier) || LookupD3dIdentifier(nResult, sIdentifier))
621                        sTitle = _T("DirectDraw/Direct3D");
622                else if(IsD2dResult(nResult, &sMessage, &sIdentifier) || LookupD2dIdentifier(nResult, sIdentifier))
623                        sTitle = _T("Direct2D");
624                else if(IsWicResult(nResult, &sMessage, &sIdentifier) || LookupWicIdentifier(nResult, sIdentifier))
625                        sTitle = _T("WinCodec");
626                else if(IsWiaResult(nResult, &sMessage, &sIdentifier) || LookupWiaIdentifier(nResult, sIdentifier))
627                        sTitle = _T("WIA");
628                else if(IsUrtResult(nResult, &sMessage, &sIdentifier) || LookupUrtIdentifier(nResult, sIdentifier))
629                        sTitle = _T(".NET");
630                else if(IsP2pResult(nResult, &sMessage, &sIdentifier) || LookupP2pIdentifier(nResult, sIdentifier))
631                        sTitle = _T("P2P");
632                else 
633                {
634                        sMessage = AtlFormatSystemMessage(nResult);
635                        if(!LookupSystemIdentifier(nResult, sIdentifier))
636                                 LookupHresultSystemIdentifier(nResult, sIdentifier);
637                        if(!sMessage.IsEmpty() || !sIdentifier.IsEmpty())
638                                sTitle = _T("System");
639                }
640                if(sMessage.IsEmpty() && sTitle.IsEmpty())
641                        return FALSE;
642                #pragma endregion
643                #pragma region Present
644                _A(!sTitle.IsEmpty());
645                m_sQuery = AtlFormatString(_T("0x%08X"), nResult) + _T(" ") + sIdentifier + _T(" ") + sMessage;
646                CRoArrayT<CString> TitleArray;
647                _W(TitleArray.Add(AtlFormatString(_T("0x%08X"), nResult)) >= 0);
648                if(!sIdentifier.IsEmpty())
649                        _W(TitleArray.Add(sIdentifier) >= 0);
650                if(!sTitle.IsEmpty())
651                        _W(TitleArray.Add(sTitle) >= 0);
652                if(sMessage.IsEmpty())
653                        sMessage = _T("(no message found)");
654                SetBalloonToolTip(NIIF_INFO, _StringHelper::Join(TitleArray, _T(" - ")), sMessage);
655                #pragma endregion
656                return TRUE;
657        }
658
659// Window message handelrs
660        LRESULT OnCreate(CREATESTRUCT*)
661        {
662                m_nCommonControlsVersion = GetCommonControlsVersion();
663                m_nShellVersion = GetShellVersion();
664                SetIcon(AtlLoadIconImage(IDI_MODULE, LR_DEFAULTCOLOR, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON)), TRUE);
665                SetIcon(AtlLoadIconImage(IDI_MODULE, LR_DEFAULTCOLOR, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON)), FALSE);
666                CIcon Icon = AtlLoadIconImage(IDI_MODULE, LR_DEFAULTCOLOR, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
667                CString sTip = AtlLoadString(IDS_PROJNAME);
668                ZeroMemory(&m_NotifyIconData, sizeof m_NotifyIconData);
669                m_NotifyIconData.hWnd = m_hWnd;
670                m_NotifyIconData.uID = 1;
671                m_NotifyIconData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_STATE;
672                m_NotifyIconData.uCallbackMessage = WM_NOTIFYICON;
673                m_NotifyIconData.hIcon = Icon;
674                _tcsncpy_s(m_NotifyIconData.szTip, sTip,  _TRUNCATE);
675                if(m_nShellVersion >= 0x0005000000000000) // 5.0
676                {
677                        m_NotifyIconData.cbSize = sizeof m_NotifyIconData; 
678                        m_NotifyIconData.uFlags |= NIF_INFO;
679                        _tcsncpy_s(m_NotifyIconData.szInfoTitle, GetDefaultInfoTitle(), _TRUNCATE);
680                        m_NotifyIconData.dwInfoFlags = GetDefaultInfoFlags();
681                } else
682                        m_NotifyIconData.cbSize = NOTIFYICONDATA_V1_SIZE; 
683                _W(Shell_NotifyIcon(NIM_ADD, &m_NotifyIconData));
684                m_NotifyIconData.uFlags &= ~(NIF_ICON | NIF_STATE);
685                m_NextClipboardViewerWindow = SetClipboardViewer();
686                _pAtlModule->Lock();
687                #if defined(_DEBUG)
688                //Process(AtlFormatString(_T("%d"), 0x80040227)); // VFW_E_WRONG_STATE
689                //Process(_T("0xC00D36B9")); // MF_E_NO_MORE_TYPES)
690                //Process(AtlFormatString(_T("0x%x"), HRESULT_FROM_WIN32(WSAEADDRINUSE))); // WSAEADDRINUSE
691                //Process(AtlFormatString(_T("0x%x"), HRESULT_FROM_WIN32(ERROR_WINHTTP_AUTODETECTION_FAILED))); // ERROR_WINHTTP_AUTODETECTION_FAILED
692                Process(_T("0x80131029L"));
693                //Process(_T("-2147312566"));
694                #endif // defined(_DEBUG)
695                return TRUE;
696        }
697        LRESULT OnDestroy() throw()
698        {
699                _pAtlModule->Unlock();
700                _W(ChangeClipboardChain(m_NextClipboardViewerWindow));
701                _W(Shell_NotifyIcon(NIM_DELETE, &m_NotifyIconData));
702                m_NotifyIconData.hWnd = NULL;
703                // NOTE: Safety double-posting
704                PostQuitMessage(0);
705                return 0;
706        }
707        LRESULT OnChangeCbChain(CWindow RemovedWindow, CWindow NextWindow)
708        {
709                if(m_NextClipboardViewerWindow == RemovedWindow)
710                        m_NextClipboardViewerWindow = NextWindow;
711                else if(m_NextClipboardViewerWindow)
712                        m_NextClipboardViewerWindow.SendMessage(WM_CHANGECBCHAIN, (WPARAM) (HWND) RemovedWindow, (LPARAM) (HWND) NextWindow);
713                return 0;
714        }
715        LRESULT OnDrawClipboard()
716        {
717                if(OpenClipboard()) 
718                {
719                        _ATLTRY
720                        {
721                                if(IsClipboardFormatAvailable(CF_UNICODETEXT))
722                                {
723                                        CGlobalMemoryWeakHandle DataHandle = (HGLOBAL) GetClipboardData(CF_UNICODETEXT);
724                                        __E(DataHandle);
725                                        CGlobalMemoryHandle::CLockT<WCHAR> pszData(DataHandle);
726                                        Process(CW2CT(pszData));
727                                }
728                        }
729                        _ATLCATCHALL()
730                        {
731                                _W(CloseClipboard());
732                                _ATLRETHROW;
733                        }
734                        _W(CloseClipboard());
735                }
736                if(m_NextClipboardViewerWindow)
737                        m_NextClipboardViewerWindow.SendMessage(WM_DRAWCLIPBOARD, m_pCurrentMsg->wParam, m_pCurrentMsg->lParam);
738                return 0;
739        }
740        LRESULT OnMouseMove(UINT, CPoint)
741        {
742                return 0;
743        }
744        LRESULT OnLButtonDblClk(UINT, CPoint)
745        {
746                if(!IsWindowEnabled())
747                        return 0;
748                INT nDefaultCommandIdentifier = ID_APP_ABOUT;
749                //CWaitCursor WaitCursor;
750                if(nDefaultCommandIdentifier)
751                        _W(PostMessage(WM_COMMAND, nDefaultCommandIdentifier));
752                return 0;
753        }
754        LRESULT OnRButtonUp(UINT, CPoint)
755        {
756                CMenu ContainerMenu;
757                _W(ContainerMenu.LoadMenu(IDR_NOTIFYICON));
758                CMenuHandle Menu;
759                INT nDefaultCommandIdentifier = ID_APP_ABOUT;
760                Menu = ContainerMenu.GetSubMenu(0);
761                //CWaitCursor WaitCursor;
762                _A(Menu);
763                if(nDefaultCommandIdentifier)
764                        _W(Menu.SetMenuDefaultItem(nDefaultCommandIdentifier));
765                CPoint Position;
766                GetCursorPos(&Position);
767                _W(SetForegroundWindow(m_hWnd));
768                _W(Menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_TOPALIGN | TPM_VERTICAL, Position.x, Position.y, m_hWnd));
769                return 0;
770        }
771        LRESULT OnNotifyIconBalloonUserClick(UINT, WPARAM, LPARAM)
772        {
773                if(m_sQuery.IsEmpty())
774                        return 0;
775                CWinHttpRequestIdentifier Identifier(_T("http://google.com/search"));
776                Identifier.AddSearchValue(_T("q"), m_sQuery);
777                CWaitCursor WaitCursor;
778                ShellExecute(m_hWnd, NULL, CW2CT(Identifier.GetValue()), NULL, NULL, SW_SHOWDEFAULT);
779                return 0;
780        }
781        LRESULT OnNotifyIcon(UINT uMsg, WPARAM wParam, LPARAM lParam) throw()
782        {
783                _A(wParam == m_NotifyIconData.uID);
784                return SendMessage((UINT) lParam);
785        }
786        LRESULT OnApplicationAbout(UINT, INT, HWND) throw()
787        {
788                CAboutDialog Dialog;
789                EnableWindow(FALSE);
790                Dialog.DoModal();
791                EnableWindow(TRUE);
792                return 0;
793        }
794        LRESULT OnApplicationExit(UINT = 0, INT = ID_APP_EXIT, HWND = NULL) throw()
795        {
796                PostQuitMessage(0);
797                return 0;
798        }
799};
Note: See TracBrowser for help on using the repository browser.