ShellUtil.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: Shell utility functions (Migrated from UtilFunc.cpp)
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/Common.h>
#include <uLib/UtilFunc.h>
#include <uLib/Debug.h>
#include <uLib/StrFunc.h>

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Shell
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

IMalloc* ShMalloc = NULL; // Hint: Init/free in MainWnd. Lifespan == program.

static WORD shFlags = 0;
#define SHF_INITIALIZED 0x0001
#define SHF_USE_OLE     0x0002
#define SHF_SHMALLOC    0x0004

bool ShellFuncInitialized()
{
    return BITS_SET( SHF_INITIALIZED, shFlags );
}

static HRESULT _initShMalloc()
{
    HRESULT rc = CoGetMalloc( MEMCTX_TASK, &ShMalloc );
    if (SUCCEEDED( rc )) shFlags |= SHF_SHMALLOC;
    else DPrint( DP_ERROR, _F("CoGetMalloc failed: %s\n"), SysErrorMsg( rc ));
    return rc;
}

bool InitShellFunc( bool useOle, DWORD coFlag )
{
    HRESULT rc = 0;
    if (0 == (shFlags & SHF_INITIALIZED))
    {
        if (useOle)
        {
            rc = OleInitialize( NULL );
            if (SUCCEEDED( rc )) shFlags |= (SHF_INITIALIZED | SHF_USE_OLE);
            else DPrint( DP_ERROR, _F("OleInitialize failed: %s\n"), SysErrorMsg( rc ));
        }
        else
        {
            rc = CoInitializeEx( NULL, coFlag ); //COINIT_APARTMENTTHREADED| COINIT_SPEED_OVER_MEMORY
            // Memo: COINIT_MULTITHREADED is not the average case..
            if (SUCCEEDED( rc )) shFlags |= SHF_INITIALIZED;
            else DPrint( DP_ERROR, _F("CoInitializeEx failed: %s\n"), SysErrorMsg( rc ));
        }
    }
    if (0 == (shFlags & SHF_SHMALLOC))
    {
        rc = _initShMalloc();
    }
    if (FAILED( rc )) SetLastError( rc );
    return SUCCEEDED( rc );
}

void DoneShellFunc()
{
    if (shFlags & SHF_SHMALLOC)
    {
        ShMalloc->Release();
        ShMalloc = NULL;
    }
    if (shFlags & SHF_INITIALIZED)
    {
        if (shFlags & SHF_USE_OLE) OleUninitialize();
        else CoUninitialize();
    }
    shFlags = 0;
}

PVOID ShellFreeEx( PVOID pBlk )
{
    if (pBlk)
    {
        if (!ShMalloc) _initShMalloc();
        if (ShMalloc)
        {
            ShMalloc->Free( pBlk );
            pBlk = NULL;
        }
    }
    return pBlk;
}

/* Alphatest for GetPathNamePIDL:
    InitShellFunc();
    TCHAR sBuf[ MAX_PATH ];
    ULONG Attr = SFGAO_FILESYSTEM;

    LPITEMIDLIST pIdl = GetPathNamePIDL( "C:\\Windows\\System32", &Attr ); // <<==--

    if (SHGetPathFromIDList( pIdl, sBuf ))
        printf( "pIdl = '%s' {0x%08X}\n", sBuf, Attr );
    pIdl = ShellFreeEx( pIdl );
    DoneShellFunc();
*/
LPITEMIDLIST GetPathNamePIDL( CSTR Dir, ULONG* pAttrib )
{
    IShellFolder* pShell;
    ULONG        chUsed; //, attrib = SFGAO_FILESYSTEM;
    LPITEMIDLIST pidl = NULL;

    if (SUCCEEDED( SHGetDesktopFolder( &pShell )))
    {
      #ifdef _UNICODE
        #define wPath (PWSTR)Dir
      #else
        WCHAR wPath[ MAX_PATH ];
        MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, Dir,-1, wPath, MAX_PATH );
      #endif
        // Convert the Unicode path to an ITEMIDLIST.
        bool ok = SUCCEEDED(
            pShell->ParseDisplayName(
                (HWND)NULL, (IBindCtx*)NULL, wPath, &chUsed, &pidl, pAttrib
                ));
        if (!ok) pidl = NULL;
        pShell->Release();
    }
    return pidl;
}

bool RecycleFile( CSTR Name, bool Confirm, bool Single ) // Move file(s) to the trash can.
{
    SHFILEOPSTRUCT fop;
    IF_DEBUG( memset( &fop, 0, sizeof(fop) ));

    fop.wFunc = FO_DELETE;

    // Leverage the fact that newStr always overallocate by 1 char,
    // precisely for the purpose of easy double-NUL termination.

    fop.pFrom = Single ? newStr( Name ) : Name;
    if (!fop.pFrom) return false;

    fop.fFlags = FOF_ALLOWUNDO| FOF_FILESONLY| FOF_NO_CONNECTED_ELEMENTS;
    if (!Confirm) fop.fFlags |= FOF_NOCONFIRMATION;
    fop.hwnd = hMainWnd;

    int rc = SHFileOperation( &fop );

    if (Single) deleteStr( fop.pFrom );
    if (rc) SetLastError( rc ); // Note: For debugging.. See MSDN SHFileOperation.
    return ((rc == 0) && !fop.fAnyOperationsAborted);
}

// Return the packed version number of a DLL, or 0 if it doesn't export DllGetVersion.

DWORD GetDLLVersion( CSTR FName )
{
    DWORD ver = 0; // Assume failure some way or another...
    HINSTANCE hlib = LoadLibrary( FName );
    if (hlib)
    {
        HRESULT (CALLBACK *DllGetVersion)( DLLVERSIONINFO* );
        (FARPROC&) DllGetVersion = GetProcAddress( hlib, "DllGetVersion" );
        if (DllGetVersion)
        {
            DLLVERSIONINFO vi; IF_DEBUG( memset( &vi, 0, sizeof(vi) ));
            vi.cbSize = sizeof(DLLVERSIONINFO);
            bool ok = SUCCEEDED( DllGetVersion( &vi ));
            if (ok) ver = PACKVERSION( vi.dwMajorVersion, vi.dwMinorVersion );
        }
        FreeLibrary( hlib );
    }
    return ver;
}

// Create a shell link file.
// Based on a public Microsoft example.
// (For some mysterious reason, doxygen excludes the code for this)

HRESULT Shell_CreateLink( CSTR LinkFilePathname, const PLINKDATA pd )
{
    HRESULT       hres;
    IShellLink*   ShLink;
    IPersistFile* File;

    if (!IsString( LinkFilePathname ) || !pd || !pd->Pathname)
        return E_INVALIDARG; //HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );

    bool _inited = ShellFuncInitialized();
    if (!_inited) hres = CoInitialize( NULL );

    // Create a shell link object

    hres = CoCreateInstance (
        CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
        IID_IShellLink, (void**)&ShLink
        );
    if (SUCCEEDED( hres )) // Initialize the shell link object
    {
        ShLink->SetPath( pd->Pathname );

        if (pd->Flags & LDF_ARGS) ShLink->SetArguments( pd->Args );
        if (pd->Flags & LDF_DESC) ShLink->SetDescription( pd->Desc );
        if (pd->Flags & LDF_SHOWCMD) ShLink->SetShowCmd( pd->ShowCmd );
        if (pd->Flags & LDF_HOTKEY) ShLink->SetHotkey( pd->Hotkey );
        if (pd->Flags & LDF_PIDL) ShLink->SetIDList( pd->IdList );

        if (pd->Flags & LDF_ICON)
            ShLink->SetIconLocation( pd->IconPath, pd->IconIndex );

        if (pd->Flags & LDF_WORKDIR)
            ShLink->SetWorkingDirectory( pd->WorkingDir );

        // Save the shell link object to disk

        hres = ShLink->QueryInterface( IID_IPersistFile, (void**)&File );
        if (SUCCEEDED( hres ))
        {
            #ifdef _UNICODE
            hres = File->Save( LinkFilePathname, true );
            #else // Convert the ANSI path to a Unicode path
                WCHAR wzPath[ MAX_PATH ] = {0};
                MultiByteToWideChar( CP_ACP,0, LinkFilePathname,-1, wzPath,MAX_PATH );
                hres = File->Save( wzPath, true );
            #endif
            File->Release();
        }
        ShLink->Release();
    }

    if (!_inited) CoUninitialize();
    return hres;
}

// Resolve a shell "lnk" file.
// Based on a public Microsoft example.
// (For some mysterious reason, doxygen excludes the code for this)

HRESULT Shell_ResolveLink( HWND hWnd, CSTR LinkFile, PLINKDATA pd )
{
    HRESULT         hres;
    IShellLink*     ShLink;
    IPersistFile*   File;
    WIN32_FIND_DATA fd;

    if (!IsString( LinkFile ) || !pd)
        return E_INVALIDARG; //HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );

    *pd->Pathname = 0; // Assume failure

    bool _inited = ShellFuncInitialized();
    if (!_inited) hres = CoInitialize( NULL );

    hres = CoCreateInstance(
        CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
        IID_IShellLink, (void**)&ShLink//psl
        );
    if (SUCCEEDED( hres ))
    {
        hres = ShLink->QueryInterface( IID_IPersistFile, (void**)&File ); //ppf
        if (SUCCEEDED( hres ))
        {
          #ifdef _UNICODE
            #define wszLink LinkFile
          #else
            WCHAR wszLink[ MAX_PATH ];
            MultiByteToWideChar( CP_ACP, 0, LinkFile,-1, wszLink, MAX_PATH );
            // PONDER: Add code to check MultiByteToWideChar for success.
          #endif
            hres = File->Load( wszLink, STGM_READ );
            if (SUCCEEDED( hres ))
            {
                //hres = ShLink->Resolve( hWnd, SLR_NOUPDATE ); // Resolve the link.
                hres = ShLink->Resolve( hWnd, 0 ); // Resolve the link.
                if (SUCCEEDED( hres ))
                {
                    hres = ShLink->GetPath(
                        pd->Pathname, MAX_PATH, &fd, SLGP_SHORTPATH
                        );
                    if (SUCCEEDED( hres ))
                    {
                        if (pd->Flags & LDF_DESC)
                            hres = ShLink->GetDescription(
                                pd->Desc, MAX_PATH
                                );
                        if (pd->Flags & LDF_ARGS)
                            hres = ShLink->GetArguments(
                                pd->Args, MAX_PATH
                                );
                        if (pd->Flags & LDF_ICON)
                            hres = ShLink->GetIconLocation(
                                pd->IconPath, MAX_PATH, &pd->IconIndex
                                );
                        if (pd->Flags & LDF_WORKDIR)
                            hres = ShLink->GetWorkingDirectory(
                                pd->WorkingDir, MAX_PATH
                                );

                        if (pd->Flags & LDF_PIDL)
                            hres = ShLink->GetIDList( &pd->IdList );
                        if (pd->Flags & LDF_HOTKEY)
                            hres = ShLink->GetHotkey( &pd->Hotkey );
                        if (pd->Flags & LDF_SHOWCMD)
                            hres = ShLink->GetShowCmd( &pd->ShowCmd );
                    }
                }
            }
            File->Release();
        }
        ShLink->Release();
    }

    if (!_inited) CoUninitialize();
    return hres;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//void AlphatestShellLink()
//{
//    #ifndef MAKE_HOTKEY
//    #define MAKE_HOTKEY( key,flags ) (WORD)((flags) << 8) | key
//    #endif
//
//    HRESULT hr;
//    CCSTR linkname = MY_ULIBDIR "\\RosIDE (dbg).lnk";
//    LINKDATA ld = {0};
//
//    ld.Flags = LDF_ALL & ~LDF_PIDL;
//    ld.IconIndex = 0;
//    ld.ShowCmd = SW_SHOWNORMAL;
//    ld.Hotkey = MAKE_HOTKEY( 'Q', HOTKEYF_ALT| HOTKEYF_CONTROL ); // Alt-Ctrl-Q
//
//    ld.Pathname = newStrBuf( MAX_PATH );
//    ld.Desc = newStrBuf( MAX_PATH );
//    ld.Args = newStrBuf( MAX_PATH );
//    ld.IconPath = newStrBuf( MAX_PATH );
//    ld.WorkingDir = newStrBuf( MAX_PATH );
//
//  BEGIN_STRSAFE_OVERRIDE
//    strcpy( ld.Pathname, MY_IDEDIR "\\vs2oo8\\Debug\\RosIDE.exe" );
//    strcpy( ld.WorkingDir, MY_IDEDIR "\\" );
//    strcpy( ld.IconPath, ld.Pathname );
//    strcpy( ld.Args, "/test /link" );
//    strcpy( ld.Desc, "ReactOS Integrated Development Environment" );
//  END_STRSAFE_OVERRIDE
//
//    hr = Shell_CreateLink( linkname, &ld ); // Ok
//
//    memset( ld.Pathname, 0, _TBYTES( MAX_PATH ));
//    memset( ld.Desc, 0, _TBYTES( MAX_PATH ));
//    memset( ld.Args, 0, _TBYTES( MAX_PATH ));
//    memset( ld.IconPath, 0, _TBYTES( MAX_PATH ));
//    memset( ld.WorkingDir, 0, _TBYTES( MAX_PATH ));
//    ld.IconIndex = ld.ShowCmd = ld.Hotkey = 0;
//    ld.Flags |= LDF_PIDL;
//
//    hr = Shell_ResolveLink( hMainWnd, linkname, &ld ); // Ok
//
//    TCHAR pidlPath[ MAX_PATH ] = {0};
//    if (SHGetPathFromIDList( ld.IdList, pidlPath ))
//        DPrint( DP_DEBUG, "PIDL: '%s'\n", pidlPath );
//
//    ShellFreeEx( ld.IdList );
//}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


HRESULT ShowShareFolderUI( HWND hParent, CSTR Path )
{
    HRESULT hres;
    // Note: This function has no associated .lib file.
    static HRESULT (NTAPI *_ShowShareFolderUI)( HWND hParent, LPCWSTR wzPath );
    if (!_ShowShareFolderUI)
    {
        HMODULE hMod = LoadLibraryA( "ntshrui.dll" );
        if (hMod) (FARPROC&)_ShowShareFolderUI = GetProcAddress( hMod, "ShowShareFolderUI" );
        TRACE( DP_DEBUG, _F("_ShowShareFolderUI = %p\n"), _ShowShareFolderUI );
    }
    if (!_ShowShareFolderUI) hres = E_FAIL;
    else
    {
        #ifdef _UNICODE
            #define wzPath Path
        #else
            WCHAR wzPath[ MAX_PATH ];
            MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, Path, -1, wzPath, dimof(wzPath) );
        #endif
        hres = _ShowShareFolderUI( hParent, wzPath );
    }
    return hres;
}

// This one pre-dates SHCreateStreamOnFile (which has more options).

HRESULT CreateStreamOnFile( _in CSTR FName, _out IStream** ppStrm, _out DWORD* pSize )
{
    ULARGE_INTEGER fsize;
    MEMORYSTATUSEX mems;
    HANDLE  hGlb, hFile;
    PVOID   pGlb;
    DWORD   cbRd, dwSize;

    HRESULT hr = 0;

    memset( &mems, 0, sizeof(mems) );
    mems.dwLength = sizeof(mems);
    if (!GlobalMemoryStatusEx( &mems )) mems.ullAvailPhys = 0;

    hFile = CreateFile( FName, GENERIC_RW, 0,0, OPEN_EXISTING, 0,0 );
    if (BAD_HANDLE( hFile ))
        hr = HRESULT_FROM_WIN32( GetLastError() ); // E.g. Access denied
    else
    {
        fsize.LowPart = GetFileSize( hFile, &fsize.HighPart );

        // Limit allowed file size to DWORD range and 1/2 of available RAM.
        // Using ullAvailVirtual here would be pointless, since we want pure RAM access.
        // The DWORD range is because ReadFile return cbRead only that large,
        // and 1/2 a "somewhat reasonable" (agh) runtime limit for extreme cases.

        mems.ullAvailPhys /= 2;
        if (fsize.HighPart || (fsize.QuadPart > mems.ullAvailPhys))
            hr = E_OUTOFMEMORY; //HRESULT_FROM_WIN32( ERROR_OUTOFMEMORY );
        else
        {
            dwSize = fsize.LowPart; // Abbreviate
            if (pSize) *pSize = dwSize;

            hGlb = GlobalAlloc( GMEM_MOVEABLE| GMEM_SHARE, dwSize );
            if (!hGlb) hr = E_OUTOFMEMORY;
            else
            {
                pGlb = GlobalLock( hGlb );
                if (!pGlb) hr = E_HANDLE;
                else
                {
                    if (!ReadFile( hFile, pGlb, dwSize, &cbRd, 0 ) || (cbRd != dwSize))
                        hr = HRESULT_FROM_WIN32( GetLastError() );

                    GlobalUnlock( hGlb );
                    if (SUCCEEDED( hr ))
                    {
                        hr = CreateStreamOnHGlobal( hGlb, TRUE, ppStrm );
                    }
                    // CreateStreamOnHGlobal initially determines the stream size
                    // by GlobalSize, so call IStream::SetSize, since the exact
                    // stream size is probably rather important to the caller.

                    if (SUCCEEDED( hr )) hr = (*ppStrm)->SetSize( fsize );
                }
                if (FAILED( hr )) GlobalFree( hGlb );
            }
        }
        CloseHandle( hFile );
    }
    return hr;
}

#if 0 // In the odd case you need an IStream on an HMAPFILE (I can't really see why).

IStream* CreateStreamOnMappedFile( CSTR FName, DWORD PageAccess, HMAPFILE* phFile )
{
    IStream* pStream = NULL;
    PBYTE pData = NULL;

    HMAPFILE hFile = LoadAndMapFile( FName, PageAccess, &pData );
    UINT cbData = hFile ? (UINT) GetMappedSize( hFile ) : 0;

   #if (_WIN32_IE >= 0x600)
    if (pData) pStream = SHCreateMemStream( pData, cbData );
   #else
    if (pData)
    {
        // Prior to Windows Vista, this function was not included in the public Shlwapi.h file,
        // nor was it exported by name from Shlwapi.dll. To use it on earlier systems, you must
        // call it directly from the Shlwapi.dll file as ordinal 12.

        static IStream* (__stdcall *_SHCreateMemStream)( const PBYTE pInit, UINT cbInit );
        if (!_SHCreateMemStream)
        {
            HMODULE hLib = LoadLibrary( _T("SHLWAPI.DLL") );
            if (hLib) (FARPROC&)_SHCreateMemStream = GetProcAddress( hLib, CSTR( 12 ));
        }
        if (_SHCreateMemStream) pStream = _SHCreateMemStream( pData, cbData );
    }
   #endif

    if (phFile) *phFile = hFile;
    return pStream;
}


void ReleaseMappedFileStream( IStream* pStm, HMAPFILE hFile )
{
    RELEASE_OBJ( pStm );
    UnloadMappedFile( hFile );
}
#endif

#if USE_VISUALSTYLE_HACK

bool EnableVisualStyles( bool Enable )
{
    static ULONG_PTR actCookie; // = FALSE;
    static const UINT_PTR shellManifestId = 124;

    BOOL ok = FALSE;
    if (Enable)
    {
        if (actCookie) ok = TRUE; // Already activated
        else {
            // Enable visual styles by using the manifest in SHELL32.DLL.
            TCHAR sysDir[ MAX_PATH ];
            ACTCTX actCtx = {
                sizeof(actCtx),
                ACTCTX_FLAG_RESOURCE_NAME_VALID
                | ACTCTX_FLAG_SET_PROCESS_DEFAULT
                | ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID,
                _T("shell32.dll"), 0,0,
                sysDir, (CSTR)shellManifestId, NULL, NULL
                };
            UINT cch = GetSystemDirectory( sysDir, dimof(sysDir) );
            if (cch < dimof(sysDir)) { // Should always succeed
                sysDir[cch] = 0;
                HANDLE hActCtx = CheckHandle( CreateActCtx( &actCtx ));
                ok = hActCtx ? ActivateActCtx( hActCtx, &actCookie ) : FALSE;
            }
        }
    }
    else if (actCookie)
    {
        #ifdef HAVE_STRUCTURED_EH
        __try {
            ok = DeactivateActCtx( 0, actCookie );
            if (ok) actCookie = 0; // Invalidate
        }
        __except_execute {
            DWORD xCode = GetExceptionCode(); //STATUS_SXS_EARLY_DEACTIVATION / STATUS_SXS_INVALID_DEACTIVATION
            TRACE( DP_ERROR, _F("Exception %#x.\n"), xCode );
            ok = FALSE;
        }
        __end_except;
        #else // __GNUC__; No SEH
            ok = DeactivateActCtx( 0, actCookie );
            if (ok) actCookie = 0; // Invalidate
        #endif // _MSC_VER
    }
    return bool_cast( ok );
}
#endif

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Tray support
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

UINT WM_TaskbarCreated = 0;

#if 0 // This omission have been already been mended by MinGW.
#ifdef __GNUC__
  #if (WINVER >= 0x601)
    #error("FIXME: MinGW's user32 lib lacks ChangeWindowMessageFilter") // See below...
  #endif
  WINUSERAPI BOOL WINAPI
    ChangeWindowMessageFilter( UINT message, DWORD dwFlag );
  #define MSGFLT_ADD 1
  #define MSGFLT_REMOVE 2
#endif // __GNUC__
#endif

void InitTaskbarSupport()
{
    WM_TaskbarCreated = RegisterWindowMessage( _T("TaskbarCreated") );

    // Some bozo at MS thought it a good idea to block TaskbarCreated
    // with User Interface Privilege Isolation, apparently not realizing
    // this will rumpfuck any "non-admin" app that uses tray icons, every
    // time Explorer crashes and has to restart (which is none too rare
    // given the plethora of less-than-perfect shell extenders around).
    // What a blooper :/

  #if WINVER >= 0x601
    if (IsWin7()) { // Are we on Win7++ ?
        TRACE( DP_DEBUG, _T("Windows 7++ : Unblocking WM_TaskbarCreated.\n") );
        CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT), 0 };
        ChangeWindowMessageFilterEx( hMainWnd, WM_TaskbarCreated, MSGFLT_ALLOW, &cfs );
    }
    #ifndef __GNUC__
    else // If WINVER==x601 and __GNUC__ this would become a spurious 'else' (see above).
    #endif
  #endif
  #if (WINVER >= 0x600) && !defined(__GNUC__) // MinGW's user32 lib lacks this API
    if (IsWinVista()) { // Are we on Vista++ ?
        TRACE( DP_DEBUG, _T("Windows Vista++ : Unblocking WM_TaskbarCreated.\n") );
        ChangeWindowMessageFilter( WM_TaskbarCreated, MSGFLT_ADD );
    }
  #endif
}

// Was e.g: ShellNotify( hMainWnd, NIM_ADD, Icons[0], "Remind Me", WM_APP );

BOOL SetTrayIconNotification(
    UINT Action, HWND hNfy, UINT Id, HICON hIcon, CSTR Hint, UINT cbkMsg
    )
{
    NOTIFYICONDATA nic;

    nic.cbSize = sizeof(nic);
    nic.hWnd = hNfy;
    nic.uID = Id;

    switch( Action )
    {
    case NIM_ADD:
    case NIM_MODIFY:
        nic.hIcon = hIcon;
        nic.uCallbackMessage = cbkMsg;
        nic.uFlags = NIF_ICON | NIF_MESSAGE;
        if (Hint)
        {
            _tcscpy_s( nic.szTip, dimof(nic.szTip), Hint );
            nic.uFlags |= NIF_TIP;
        }
        break;

    default:
        nic.uFlags = 0;
        break;
    }
    return Shell_NotifyIcon( Action, &nic );
}

// EOF