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

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

Win32 facility priority for well known codes (might be reused in other "families" of codes

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