changenotify.cpp File Reference

#include "precomp.h"

Include dependency graph for changenotify.cpp:

Go to the source code of this file.

Classes
class	CChangeNotifyBroker
struct	ALIAS_PIDL

Macros
#define	DUMPEV(x)   ,( event & SHCNE_##x )? #x " " : ""

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shcn)
static HWND	GetNotificationServer (BOOL bCreate)
EXTERN_C void	InitChangeNotifications (void)
EXTERN_C void	FreeChangeNotifications (void)
static HRESULT	Shell_ParsePrinterName (_In_ LPCWSTR pszName, _Out_ LPITEMIDLIST *ppidl, _In_ IBindCtx *pBindCtx)
static HWND	CreateNotificationBroker (HWND hwnd, UINT wMsg)
static HANDLE	CreateNotificationParam (LONG wEventId, UINT uFlags, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, DWORD dwOwnerPID, DWORD dwTick)
static LPHANDBAG	DoGetHandbagFromTicket (HANDLE hTicket, DWORD dwOwnerPID)
static HANDLE	CreateRegistrationParam (ULONG nRegID, HWND hwnd, UINT wMsg, INT fSources, LONG fEvents, LONG fRecursive, LPCITEMIDLIST pidl, DWORD dwOwnerPID, HWND hwndBroker)
static void	CreateNotificationParamAndSend (LONG wEventId, UINT uFlags, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, DWORD dwTick)
static VOID	DoInitAliasPIDLs (void)
static BOOL	DoGetAliasPIDLs (LPITEMIDLIST apidls[2], PCIDLIST_ABSOLUTE pidl)
EXTERN_C ULONG WINAPI	SHChangeNotifyRegister (HWND hwnd, INT fSources, LONG wEventMask, UINT uMsg, INT cItems, SHChangeNotifyEntry *lpItems)
EXTERN_C BOOL WINAPI	SHChangeNotifyDeregister (ULONG hNotify)
EXTERN_C BOOL WINAPI	SHChangeNotifyUpdateEntryList (DWORD unknown1, DWORD unknown2, DWORD unknown3, DWORD unknown4)
static LPCSTR	DumpEvent (LONG event)
EXTERN_C BOOL WINAPI	SHChangeRegistrationReceive (LPVOID lpUnknown1, DWORD dwUnknown2)
EXTERN_C VOID WINAPI	SHChangeNotifyReceiveEx (LONG lEvent, UINT uFlags, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, DWORD dwTick)
EXTERN_C VOID WINAPI	SHChangeNotifyReceive (LONG lEvent, UINT uFlags, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
EXTERN_C VOID WINAPI	SHChangeNotifyTransmit (LONG lEvent, UINT uFlags, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, DWORD dwTick)
EXTERN_C void WINAPI	SHChangeNotify (LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
EXTERN_C ULONG WINAPI	NTSHChangeNotifyRegister (HWND hwnd, INT fSources, LONG fEvents, UINT msg, INT count, SHChangeNotifyEntry *idlist)
EXTERN_C HANDLE WINAPI	SHChangeNotification_Lock (HANDLE hTicket, DWORD dwOwnerPID, LPITEMIDLIST **lppidls, LPLONG lpwEventId)
EXTERN_C BOOL WINAPI	SHChangeNotification_Unlock (HANDLE hLock)
EXTERN_C DWORD WINAPI	NTSHChangeNotifyDeregister (ULONG hNotify)
EXTERN_C BOOL WINAPI	SHChangeNotifySuspendResume (BOOL bSuspend, LPITEMIDLIST pidl, BOOL bRecursive, DWORD dwReserved)

Variables
CRITICAL_SECTION	SHELL32_ChangenotifyCS
static ALIAS_PIDL	AliasPIDLs []

Macro Definition Documentation

DUMPEV

#define DUMPEV

(

x

)

,( event & SHCNE_##x )? #x " " : ""

Function Documentation

CreateNotificationBroker()

static HWND CreateNotificationBroker ( HWND  hwnd, UINT  wMsg  )

static

Definition at line 153 of file changenotify.cpp.

{
    // Create a new broker. It will be freed when the window gets destroyed
    CChangeNotifyBroker* pBroker = new CChangeNotifyBroker(hwnd, wMsg);
    if (pBroker == NULL)
    {
        ERR("Out of memory\n");
        return NULL;
    }
 
    HWND hwndBroker = SHCreateDefaultWorkerWindow();
    if (hwndBroker == NULL)
    {
        ERR("hwndBroker == NULL\n");
        delete pBroker;
        return NULL;
    }
 
    pBroker->SubclassWindow(hwndBroker);
    return hwndBroker;
}

Referenced by SHChangeNotifyRegister().

CreateNotificationParam()

static HANDLE CreateNotificationParam ( LONG  wEventId, UINT  uFlags, LPCITEMIDLIST  pidl1, LPCITEMIDLIST  pidl2, DWORD  dwOwnerPID, DWORD  dwTick  )

static

Definition at line 178 of file changenotify.cpp.

{
    // pidl1 and pidl2 have variable length. To store them into the delivery ticket,
    // we have to consider the offsets and the sizes of pidl1 and pidl2.
    DWORD cbPidl1 = 0, cbPidl2 = 0, ibOffset1 = 0, ibOffset2 = 0;
    if (pidl1)
    {
        cbPidl1 = ILGetSize(pidl1);
        ibOffset1 = DWORD_ALIGNMENT(sizeof(DELITICKET));
    }
    if (pidl2)
    {
        cbPidl2 = ILGetSize(pidl2);
        ibOffset2 = DWORD_ALIGNMENT(ibOffset1 + cbPidl1);
    }
 
    // allocate the delivery ticket
    DWORD cbSize = ibOffset2 + cbPidl2;
    HANDLE hTicket = SHAllocShared(NULL, cbSize, dwOwnerPID);
    if (hTicket == NULL)
    {
        ERR("Out of memory\n");
        return NULL;
    }
 
    // lock the ticket
    LPDELITICKET pTicket = (LPDELITICKET)SHLockSharedEx(hTicket, dwOwnerPID, TRUE);
    if (pTicket == NULL)
    {
        ERR("SHLockSharedEx failed\n");
        SHFreeShared(hTicket, dwOwnerPID);
        return NULL;
    }
 
    // populate the ticket
    pTicket->dwMagic  = DELITICKET_MAGIC;
    pTicket->wEventId = wEventId;
    pTicket->uFlags = uFlags;
    pTicket->ibOffset1 = ibOffset1;
    pTicket->ibOffset2 = ibOffset2;
    if (pidl1)
        memcpy((LPBYTE)pTicket + ibOffset1, pidl1, cbPidl1);
    if (pidl2)
        memcpy((LPBYTE)pTicket + ibOffset2, pidl2, cbPidl2);
 
    // unlock the ticket and return
    SHUnlockShared(pTicket);
    return hTicket;
}

Referenced by CreateNotificationParamAndSend().

CreateNotificationParamAndSend()

static void CreateNotificationParamAndSend ( LONG  wEventId, UINT  uFlags, LPCITEMIDLIST  pidl1, LPCITEMIDLIST  pidl2, DWORD  dwTick  )

static

Definition at line 320 of file changenotify.cpp.

{
    // get server window
    HWND hwndServer = GetNotificationServer(FALSE);
    if (hwndServer == NULL)
        return;
 
    // the ticket owner is the process of the notification server
    DWORD pid;
    GetWindowThreadProcessId(hwndServer, &pid);
 
    // create a delivery ticket
    HANDLE hTicket = CreateNotificationParam(wEventId, uFlags, pidl1, pidl2, pid, dwTick);
    if (hTicket == NULL)
        return;
 
    TRACE("hTicket: %p, 0x%lx\n", hTicket, pid);
 
    // send the ticket by using CN_DELIVER_NOTIFICATION
    if (pid != GetCurrentProcessId() ||
        (uFlags & (SHCNF_FLUSH | SHCNF_FLUSHNOWAIT)) == SHCNF_FLUSH)
    {
        SendMessageW(hwndServer, CN_DELIVER_NOTIFICATION, (WPARAM)hTicket, pid);
    }
    else
    {
        SendNotifyMessageW(hwndServer, CN_DELIVER_NOTIFICATION, (WPARAM)hTicket, pid);
    }
}

Referenced by SHChangeNotifyReceiveEx().

CreateRegistrationParam()

static HANDLE CreateRegistrationParam ( ULONG  nRegID, HWND  hwnd, UINT  wMsg, INT  fSources, LONG  fEvents, LONG  fRecursive, LPCITEMIDLIST  pidl, DWORD  dwOwnerPID, HWND  hwndBroker  )

static

Definition at line 269 of file changenotify.cpp.

{
    // pidl has variable length. To store it into the registration entry,
    // we have to consider the length of pidl.
    DWORD cbPidl = ILGetSize(pidl);
    DWORD ibPidl = DWORD_ALIGNMENT(sizeof(REGENTRY));
    DWORD cbSize = ibPidl + cbPidl;
 
    // create the registration entry and lock it
    HANDLE hRegEntry = SHAllocShared(NULL, cbSize, dwOwnerPID);
    if (hRegEntry == NULL)
    {
        ERR("Out of memory\n");
        return NULL;
    }
    LPREGENTRY pRegEntry = (LPREGENTRY)SHLockSharedEx(hRegEntry, dwOwnerPID, TRUE);
    if (pRegEntry == NULL)
    {
        ERR("SHLockSharedEx failed\n");
        SHFreeShared(hRegEntry, dwOwnerPID);
        return NULL;
    }
 
    // populate the registration entry
    pRegEntry->dwMagic = REGENTRY_MAGIC;
    pRegEntry->cbSize = cbSize;
    pRegEntry->nRegID = nRegID;
    pRegEntry->hwnd = hwnd;
    pRegEntry->uMsg = wMsg;
    pRegEntry->fSources = fSources;
    pRegEntry->fEvents = fEvents;
    pRegEntry->fRecursive = fRecursive;
    pRegEntry->hwndBroker = hwndBroker;
    pRegEntry->ibPidl = 0;
    if (pidl)
    {
        pRegEntry->ibPidl = ibPidl;
        memcpy((LPBYTE)pRegEntry + ibPidl, pidl, cbPidl);
    }
 
    // unlock and return
    SHUnlockShared(pRegEntry);
    return hRegEntry;
}

Referenced by SHChangeNotifyRegister().

DoGetAliasPIDLs()

static BOOL DoGetAliasPIDLs ( LPITEMIDLIST  apidls[2], PCIDLIST_ABSOLUTE  pidl  )

static

Definition at line 387 of file changenotify.cpp.

{
    DoInitAliasPIDLs();
 
    apidls[0] = apidls[1] = NULL;
 
    INT k = 0;
    for (SIZE_T i = 0; i < _countof(AliasPIDLs); ++i)
    {
        const ALIAS_PIDL *alias = &AliasPIDLs[i];
        if (ILIsEqual(pidl, alias->pidl1))
        {
            if (alias->csidl1 == alias->csidl2)
            {
                apidls[k++] = ILCreateFromPathW(alias->szPath2);
            }
            else
            {
                apidls[k++] = ILClone(alias->pidl2);
            }
            if (k >= 2)
                break;
        }
    }
 
    return k > 0;
}

Referenced by SHChangeNotifyRegister().

DoGetHandbagFromTicket()

static LPHANDBAG DoGetHandbagFromTicket ( HANDLE  hTicket, DWORD  dwOwnerPID  )

static

Definition at line 234 of file changenotify.cpp.

{
    // lock and validate the delivery ticket
    LPDELITICKET pTicket = (LPDELITICKET)SHLockSharedEx(hTicket, dwOwnerPID, FALSE);
    if (pTicket == NULL || pTicket->dwMagic != DELITICKET_MAGIC)
    {
        ERR("pTicket is invalid\n");
        SHUnlockShared(pTicket);
        return NULL;
    }
 
    // allocate the handbag
    LPHANDBAG pHandbag = (LPHANDBAG)LocalAlloc(LMEM_FIXED, sizeof(HANDBAG));
    if (pHandbag == NULL)
    {
        ERR("Out of memory\n");
        SHUnlockShared(pTicket);
        return NULL;
    }
 
    // populate the handbag
    pHandbag->dwMagic = HANDBAG_MAGIC;
    pHandbag->pTicket = pTicket;
 
    pHandbag->pidls[0] = pHandbag->pidls[1] = NULL;
    if (pTicket->ibOffset1)
        pHandbag->pidls[0] = (LPITEMIDLIST)((LPBYTE)pTicket + pTicket->ibOffset1);
    if (pTicket->ibOffset2)
        pHandbag->pidls[1] = (LPITEMIDLIST)((LPBYTE)pTicket + pTicket->ibOffset2);
 
    return pHandbag;
}

Referenced by SHChangeNotification_Lock().

DoInitAliasPIDLs()

static VOID DoInitAliasPIDLs ( void  )

static

Definition at line 368 of file changenotify.cpp.

{
    static BOOL s_bInit = FALSE;
    if (!s_bInit)
    {
        for (SIZE_T i = 0; i < _countof(AliasPIDLs); ++i)
        {
            ALIAS_PIDL *alias = &AliasPIDLs[i];
 
            SHGetSpecialFolderLocation(NULL, alias->csidl1, &alias->pidl1);
            SHGetPathFromIDListW(alias->pidl1, alias->szPath1);
 
            SHGetSpecialFolderLocation(NULL, alias->csidl2, &alias->pidl2);
            SHGetPathFromIDListW(alias->pidl2, alias->szPath2);
        }
        s_bInit = TRUE;
    }
}

Referenced by DoGetAliasPIDLs().

DumpEvent()

static LPCSTR DumpEvent ( LONG  event )

static

Definition at line 583 of file changenotify.cpp.

{
    if (event == SHCNE_ALLEVENTS)
        return "SHCNE_ALLEVENTS";
#define DUMPEV(x)  ,( event & SHCNE_##x )? #x " " : ""
    return wine_dbg_sprintf( "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s"
    DUMPEV(RENAMEITEM)
    DUMPEV(CREATE)
    DUMPEV(DELETE)
    DUMPEV(MKDIR)
    DUMPEV(RMDIR)
    DUMPEV(MEDIAINSERTED)
    DUMPEV(MEDIAREMOVED)
    DUMPEV(DRIVEREMOVED)
    DUMPEV(DRIVEADD)
    DUMPEV(NETSHARE)
    DUMPEV(NETUNSHARE)
    DUMPEV(ATTRIBUTES)
    DUMPEV(UPDATEDIR)
    DUMPEV(UPDATEITEM)
    DUMPEV(SERVERDISCONNECT)
    DUMPEV(UPDATEIMAGE)
    DUMPEV(DRIVEADDGUI)
    DUMPEV(RENAMEFOLDER)
    DUMPEV(FREESPACE)
    DUMPEV(EXTENDED_EVENT)
    DUMPEV(ASSOCCHANGED)
    DUMPEV(INTERRUPT)
    );
#undef DUMPEV
}

Referenced by SHChangeNotify().

FreeChangeNotifications()

EXTERN_C void FreeChangeNotifications

(

void

)

Definition at line 52 of file changenotify.cpp.

{
    HWND hwndServer = GetNotificationServer(FALSE);
    if (hwndServer)
        SendMessageW(hwndServer, CN_UNREGISTER_PROCESS, GetCurrentProcessId(), 0);
    DeleteCriticalSection(&SHELL32_ChangenotifyCS);
}

GetNotificationServer()

static HWND GetNotificationServer ( BOOL  bCreate )

static

Definition at line 16 of file changenotify.cpp.

{
    static HWND s_hwndServer = NULL;
 
    // use cache if any
    if (s_hwndServer && IsWindow(s_hwndServer))
        return s_hwndServer;
 
    // get the shell window
    HWND hwndShell = GetShellWindow();
    if (hwndShell == NULL)
    {
        TRACE("GetShellWindow() returned NULL\n");
        return NULL;
    }
 
    // Get the window of the notification server that runs in explorer
    HWND hwndServer = (HWND)SendMessageW(hwndShell, WM_DESKTOP_GET_CNOTIFY_SERVER, bCreate, 0);
    if (!IsWindow(hwndServer))
    {
        ERR("Unable to get server window\n");
        hwndServer = NULL;
    }
 
    // save and return
    s_hwndServer = hwndServer;
    return hwndServer;
}

Referenced by CreateNotificationParamAndSend(), FreeChangeNotifications(), SHChangeNotify(), SHChangeNotifyDeregister(), and SHChangeNotifyRegister().

InitChangeNotifications()

EXTERN_C void InitChangeNotifications

(

void

)

Definition at line 46 of file changenotify.cpp.

{
    InitializeCriticalSection(&SHELL32_ChangenotifyCS);
}

Referenced by if().

NTSHChangeNotifyDeregister()

EXTERN_C DWORD WINAPI NTSHChangeNotifyDeregister

(

ULONG

hNotify

)

Definition at line 856 of file changenotify.cpp.

{
    FIXME("(0x%08x):semi stub.\n", hNotify);
    return SHChangeNotifyDeregister(hNotify);
}

NTSHChangeNotifyRegister()

EXTERN_C ULONG WINAPI NTSHChangeNotifyRegister	(	HWND	hwnd,
		INT	fSources,
		LONG	fEvents,
		UINT	msg,
		INT	count,
		SHChangeNotifyEntry *	idlist
	)

Definition at line 796 of file changenotify.cpp.

{
    return SHChangeNotifyRegister(hwnd, fSources | SHCNRF_NewDelivery,
                                  fEvents, msg, count, idlist);
}

SHChangeNotification_Lock()

EXTERN_C HANDLE WINAPI SHChangeNotification_Lock	(	HANDLE	hTicket,
		DWORD	dwOwnerPID,
		LPITEMIDLIST **	lppidls,
		LPLONG	lpwEventId
	)

Definition at line 807 of file changenotify.cpp.

{
    TRACE("%p %08x %p %p\n", hTicket, dwOwnerPID, lppidls, lpwEventId);
 
    // create a handbag from the ticket
    LPHANDBAG pHandbag = DoGetHandbagFromTicket(hTicket, dwOwnerPID);
    if (pHandbag == NULL || pHandbag->dwMagic != HANDBAG_MAGIC)
    {
        ERR("pHandbag is invalid\n");
        return NULL;
    }
 
    // populate parameters from the handbag
    if (lppidls)
        *lppidls = pHandbag->pidls;
    if (lpwEventId)
        *lpwEventId = (pHandbag->pTicket->wEventId & ~SHCNE_INTERRUPT);
 
    // return the handbag
    return pHandbag;
}

Referenced by CChangeNotifyBroker::BrokerNotification(), CDefView::OnChangeNotify(), OnShellNotify(), and testwindow_wndproc().

SHChangeNotification_Unlock()

EXTERN_C BOOL WINAPI SHChangeNotification_Unlock

(

HANDLE

hLock

)

Definition at line 834 of file changenotify.cpp.

{
    TRACE("%p\n", hLock);
 
    // validate the handbag
    LPHANDBAG pHandbag = (LPHANDBAG)hLock;
    if (pHandbag == NULL || pHandbag->dwMagic != HANDBAG_MAGIC)
    {
        ERR("pHandbag is invalid\n");
        return FALSE;
    }
 
    // free the handbag
    BOOL ret = SHUnlockShared(pHandbag->pTicket);
    LocalFree(hLock);
    return ret;
}

Referenced by CChangeNotifyBroker::BrokerNotification(), CDefView::OnChangeNotify(), OnShellNotify(), and testwindow_wndproc().

SHChangeNotify()

EXTERN_C void WINAPI SHChangeNotify	(	LONG	wEventId,
		UINT	uFlags,
		LPCVOID	dwItem1,
		LPCVOID	dwItem2
	)

Definition at line 652 of file changenotify.cpp.

{
    TRACE("(0x%08x,0x%08x,%p,%p)\n", wEventId, uFlags, dwItem1, dwItem2);
 
    if (!GetNotificationServer(FALSE))
        return;
 
    DWORD dwTick = GetTickCount();
 
    WCHAR szPath1[MAX_PATH], szPath2[MAX_PATH];
    LPITEMIDLIST pidl1 = NULL, pidl2 = NULL;
    LPWSTR psz1, psz2;
    SHChangeDWORDAsIDList dwidl;
    DWORD dwType;
 
Retry:
    dwType = (uFlags & SHCNF_TYPE);
    switch (dwType)
    {
        case SHCNF_IDLIST:
        {
            if (wEventId == SHCNE_FREESPACE)
            {
                szPath1[0] = szPath2[0] = UNICODE_NULL;
                if (dwItem1)
                    SHGetPathFromIDList((LPCITEMIDLIST)dwItem1, szPath1);
                if (dwItem2)
                    SHGetPathFromIDList((LPCITEMIDLIST)dwItem2, szPath2);
 
                uFlags = SHCNF_PATHW;
                dwItem1 = (szPath1[0] ? szPath1 : NULL);
                dwItem2 = (szPath2[0] ? szPath2 : NULL);
                goto Retry;
            }
 
            pidl1 = (LPITEMIDLIST)dwItem1;
            pidl2 = (LPITEMIDLIST)dwItem2;
            break;
        }
        case SHCNF_PATHA:
        case SHCNF_PRINTERA:
        {
            psz1 = psz2 = NULL;
            szPath1[0] = szPath2[0] = UNICODE_NULL;
            if (dwItem1)
            {
                SHAnsiToUnicode((LPCSTR)dwItem1, szPath1, _countof(szPath1));
                psz1 = szPath1;
            }
            if (dwItem2)
            {
                SHAnsiToUnicode((LPCSTR)dwItem2, szPath2, _countof(szPath2));
                psz2 = szPath2;
            }
 
            uFlags = ((dwType == SHCNF_PRINTERA) ? SHCNF_PRINTERW : SHCNF_PATHW);
            dwItem1 = psz1;
            dwItem2 = psz2;
            goto Retry;
        }
        case SHCNF_PATHW:
        {
            if (wEventId == SHCNE_FREESPACE)
            {
                INT iDrive1 = -1, iDrive2 = -1;
                if (dwItem1)
                    iDrive1 = PathGetDriveNumberW((LPCWSTR)dwItem1);
                if (dwItem2)
                    iDrive2 = PathGetDriveNumberW((LPCWSTR)dwItem2);
 
                DWORD dwValue = 0;
                if (iDrive1 >= 0)
                    dwValue |= (1 << iDrive1);
                if (iDrive2 >= 0)
                    dwValue |= (1 << iDrive2);
 
                if (!dwValue)
                    return;
 
                uFlags = SHCNF_DWORD;
                dwItem1 = UlongToPtr(dwValue);
                dwItem2 = NULL;
                goto Retry;
            }
 
            if (dwItem1)
                pidl1 = SHSimpleIDListFromPathW((LPCWSTR)dwItem1);
            if (dwItem2)
                pidl2 = SHSimpleIDListFromPathW((LPCWSTR)dwItem2);
            break;
        }
        case SHCNF_PRINTERW:
        {
            if (dwItem1)
            {
                HRESULT hr = Shell_ParsePrinterName((LPCWSTR)dwItem1, &pidl1, NULL);
                if (FAILED_UNEXPECTEDLY(hr))
                    return;
            }
 
            if (dwItem2)
            {
                HRESULT hr = Shell_ParsePrinterName((LPCWSTR)dwItem2, &pidl2, NULL);
                if (FAILED_UNEXPECTEDLY(hr))
                {
                    ILFree(pidl1);
                    return;
                }
            }
            break;
        }
        case SHCNF_DWORD:
        {
            dwidl.cb = offsetof(SHChangeDWORDAsIDList, cbZero);
            dwidl.dwItem1 = PtrToUlong(dwItem1);
            dwidl.dwItem2 = PtrToUlong(dwItem2);
            dwidl.cbZero = 0;
            pidl1 = (LPITEMIDLIST)&dwidl;
            break;
        }
        default:
        {
            FIXME("Unknown type: 0x%X\n", dwType);
            return;
        }
    }
 
    if (pidl1 || !wEventId || (wEventId & SHCNE_ASSOCCHANGED))
    {
        TRACE("notifying event %s(%x)\n", DumpEvent(wEventId), wEventId);
        SHChangeNotifyTransmit(wEventId, uFlags, pidl1, pidl2, dwTick);
    }
 
    if ((dwType == SHCNF_PATHW) || (dwType == SHCNF_PRINTERW))
    {
        ILFree(pidl1);
        ILFree(pidl2);
    }
}

Referenced by CFSDropTarget::_DoDrop(), delete_files(), CDefaultContextMenu::DoCreateNewFolder(), DrivesContextMenuCallback(), CFontExt::Drop(), EditTypeDlg_OnOK(), FinishDlgProc(), CZipCreatorImpl::JustDoIt(), NotifyFileSystemChange(), CLayerUIPropPage::OnApply(), CDesktopBrowser::OnDeviceChange(), CShellLink::OnNotify(), CShellLink::Save(), CNewMenu::SelectNewItem(), CFSFolder::SetNameOf(), SHChangeNotifyWrap(), SHNotifyCopyFileW(), SHNotifyCreateDirectoryW(), SHNotifyDeleteFileW(), SHNotifyMoveFileW(), SHNotifyRemoveDirectoryW(), StageThreadFunc(), test_SHChangeNotify(), VfdCloseImage(), VfdOpenImage(), WelcomeDlgProc(), and CIniPropertyBag::Write().

SHChangeNotifyDeregister()

EXTERN_C BOOL WINAPI SHChangeNotifyDeregister

(

ULONG

hNotify

)

Definition at line 553 of file changenotify.cpp.

{
    TRACE("(0x%08x)\n", hNotify);
 
    // get the server window
    HWND hwndServer = GetNotificationServer(FALSE);
    if (hwndServer == NULL)
        return FALSE;
 
    // send CN_UNREGISTER message and try to unregister
    BOOL ret = (BOOL)SendMessageW(hwndServer, CN_UNREGISTER, hNotify, 0);
    if (!ret)
        ERR("CN_UNREGISTER failed\n");
 
    return ret;
}

Referenced by BrsFolder_OnDestroy(), NTSHChangeNotifyDeregister(), CDefView::OnDestroy(), test_SHChangeNotify(), and UnInitSHCN().

SHChangeNotifyReceive()

EXTERN_C VOID WINAPI SHChangeNotifyReceive	(	LONG	lEvent,
		UINT	uFlags,
		LPCITEMIDLIST	pidl1,
		LPCITEMIDLIST	pidl2
	)

Definition at line 637 of file changenotify.cpp.

{
    SHChangeNotifyReceiveEx(lEvent, uFlags, pidl1, pidl2, GetTickCount());
}

SHChangeNotifyReceiveEx()

EXTERN_C VOID WINAPI SHChangeNotifyReceiveEx	(	LONG	lEvent,
		UINT	uFlags,
		LPCITEMIDLIST	pidl1,
		LPCITEMIDLIST	pidl2,
		DWORD	dwTick
	)

Definition at line 626 of file changenotify.cpp.

{
    // TODO: Queueing notifications
    CreateNotificationParamAndSend(lEvent, uFlags, pidl1, pidl2, dwTick);
}

Referenced by SHChangeNotifyReceive(), and SHChangeNotifyTransmit().

SHChangeNotifyRegister()

EXTERN_C ULONG WINAPI SHChangeNotifyRegister	(	HWND	hwnd,
		INT	fSources,
		LONG	wEventMask,
		UINT	uMsg,
		INT	cItems,
		SHChangeNotifyEntry *	lpItems
	)

Definition at line 419 of file changenotify.cpp.

{
    HWND hwndServer, hwndBroker = NULL;
    HANDLE hRegEntry;
    INT iItem;
    ULONG nRegID = INVALID_REG_ID;
    DWORD dwOwnerPID;
    LPREGENTRY pRegEntry;
 
    TRACE("(%p,0x%08x,0x%08x,0x%08x,%d,%p)\n",
          hwnd, fSources, wEventMask, uMsg, cItems, lpItems);
 
    // sanity check
    if (wEventMask == 0 || cItems <= 0 || cItems > 0x7FFF || lpItems == NULL ||
        hwnd == NULL || !IsWindow(hwnd))
    {
        return INVALID_REG_ID;
    }
 
    // request the window of the server
    hwndServer = GetNotificationServer(TRUE);
    if (hwndServer == NULL)
        return INVALID_REG_ID;
 
    // disable recursive interrupt in specific condition
    if ((fSources & SHCNRF_RecursiveInterrupt) && !(fSources & SHCNRF_InterruptLevel))
    {
        fSources &= ~SHCNRF_RecursiveInterrupt;
    }
 
    // if it is old delivery method, then create a broker window
    if ((fSources & SHCNRF_NewDelivery) == 0)
    {
        hwndBroker = hwnd = CreateNotificationBroker(hwnd, uMsg);
        uMsg = WM_BROKER_NOTIFICATION;
    }
 
    // The owner PID is the process ID of the server
    GetWindowThreadProcessId(hwndServer, &dwOwnerPID);
 
    EnterCriticalSection(&SHELL32_ChangenotifyCS);
    for (iItem = 0; iItem < cItems; ++iItem)
    {
        // create a registration entry
        hRegEntry = CreateRegistrationParam(nRegID, hwnd, uMsg, fSources, wEventMask,
                                            lpItems[iItem].fRecursive, lpItems[iItem].pidl,
                                            dwOwnerPID, hwndBroker);
        if (hRegEntry)
        {
            TRACE("CN_REGISTER: hwnd:%p, hRegEntry:%p, pid:0x%lx\n",
                  hwndServer, hRegEntry, dwOwnerPID);
 
            // send CN_REGISTER to the server
            SendMessageW(hwndServer, CN_REGISTER, (WPARAM)hRegEntry, dwOwnerPID);
 
            // update nRegID
            pRegEntry = (LPREGENTRY)SHLockSharedEx(hRegEntry, dwOwnerPID, FALSE);
            if (pRegEntry)
            {
                nRegID = pRegEntry->nRegID;
                SHUnlockShared(pRegEntry);
            }
 
            // free registration entry
            SHFreeShared(hRegEntry, dwOwnerPID);
        }
 
        if (nRegID == INVALID_REG_ID)
        {
            ERR("Delivery failed\n");
 
            if (hwndBroker)
            {
                // destroy the broker
                DestroyWindow(hwndBroker);
            }
            break;
        }
 
        // PIDL alias
        LPITEMIDLIST apidlAlias[2];
        if (DoGetAliasPIDLs(apidlAlias, lpItems[iItem].pidl))
        {
            if (apidlAlias[0])
            {
                // create another registration entry
                hRegEntry = CreateRegistrationParam(nRegID, hwnd, uMsg, fSources, wEventMask,
                                                    lpItems[iItem].fRecursive, apidlAlias[0],
                                                    dwOwnerPID, hwndBroker);
                if (hRegEntry)
                {
                    TRACE("CN_REGISTER: hwnd:%p, hRegEntry:%p, pid:0x%lx\n",
                          hwndServer, hRegEntry, dwOwnerPID);
 
                    // send CN_REGISTER to the server
                    SendMessageW(hwndServer, CN_REGISTER, (WPARAM)hRegEntry, dwOwnerPID);
 
                    // free registration entry
                    SHFreeShared(hRegEntry, dwOwnerPID);
                }
                ILFree(apidlAlias[0]);
            }
 
            if (apidlAlias[1])
            {
                // create another registration entry
                hRegEntry = CreateRegistrationParam(nRegID, hwnd, uMsg, fSources, wEventMask,
                                                    lpItems[iItem].fRecursive, apidlAlias[1],
                                                    dwOwnerPID, hwndBroker);
                if (hRegEntry)
                {
                    TRACE("CN_REGISTER: hwnd:%p, hRegEntry:%p, pid:0x%lx\n",
                          hwndServer, hRegEntry, dwOwnerPID);
 
                    // send CN_REGISTER to the server
                    SendMessageW(hwndServer, CN_REGISTER, (WPARAM)hRegEntry, dwOwnerPID);
 
                    // free registration entry
                    SHFreeShared(hRegEntry, dwOwnerPID);
                }
                ILFree(apidlAlias[1]);
            }
        }
    }
    LeaveCriticalSection(&SHELL32_ChangenotifyCS);
 
    return nRegID;
}

Referenced by BrsFolder_OnCreate(), CExplorerBand::InitializeExplorerBand(), InitSHCN(), NTSHChangeNotifyRegister(), CDefView::OnCreate(), and test_SHChangeNotify().

SHChangeNotifySuspendResume()

EXTERN_C BOOL WINAPI SHChangeNotifySuspendResume	(	BOOL	bSuspend,
		LPITEMIDLIST	pidl,
		BOOL	bRecursive,
		DWORD	dwReserved
	)

Definition at line 867 of file changenotify.cpp.

{
    FIXME("SHChangeNotifySuspendResume() stub\n");
    return FALSE;
}

SHChangeNotifyTransmit()

EXTERN_C VOID WINAPI SHChangeNotifyTransmit	(	LONG	lEvent,
		UINT	uFlags,
		LPCITEMIDLIST	pidl1,
		LPCITEMIDLIST	pidl2,
		DWORD	dwTick
	)

Definition at line 643 of file changenotify.cpp.

{
    SHChangeNotifyReceiveEx(lEvent, uFlags, pidl1, pidl2, dwTick);
}

Referenced by SHChangeNotify().

SHChangeNotifyUpdateEntryList()

EXTERN_C BOOL WINAPI SHChangeNotifyUpdateEntryList	(	DWORD	unknown1,
		DWORD	unknown2,
		DWORD	unknown3,
		DWORD	unknown4
	)

Definition at line 574 of file changenotify.cpp.

{
    FIXME("(0x%08x, 0x%08x, 0x%08x, 0x%08x)\n",
          unknown1, unknown2, unknown3, unknown4);
    return TRUE;
}

SHChangeRegistrationReceive()

EXTERN_C BOOL WINAPI SHChangeRegistrationReceive	(	LPVOID	lpUnknown1,
		DWORD	dwUnknown2
	)

Definition at line 619 of file changenotify.cpp.

{
    TRACE("\n");
    return FALSE; /* Just return FALSE */
}

Shell_ParsePrinterName()

static HRESULT Shell_ParsePrinterName ( _In_ LPCWSTR  pszName, _Out_ LPITEMIDLIST *  ppidl, _In_ IBindCtx *  pBindCtx  )

static

Definition at line 61 of file changenotify.cpp.

{
    *ppidl = NULL;
 
    CComHeapPtr<ITEMIDLIST> pidlPrinters;
    HRESULT hr = SHGetSpecialFolderLocation(NULL, CSIDL_PRINTERS, &pidlPrinters);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    CComPtr<IShellFolder> pFolder;
    hr = SHBindToObject(NULL, pidlPrinters, IID_PPV_ARG(IShellFolder, &pFolder));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    CComHeapPtr<ITEMIDLIST> pidlTemp;
    hr = pFolder->ParseDisplayName(NULL, pBindCtx, (LPWSTR)pszName, NULL, &pidlTemp, NULL);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return SHILCombine(pidlPrinters, pidlTemp, ppidl);
}

Referenced by SHChangeNotify().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shcn

)

Variable Documentation

AliasPIDLs

ALIAS_PIDL AliasPIDLs[]

static

Initial value:

=
{
    { CSIDL_PERSONAL, CSIDL_PERSONAL },
    { CSIDL_DESKTOP, CSIDL_COMMON_DESKTOPDIRECTORY, },
    { CSIDL_DESKTOP, CSIDL_DESKTOPDIRECTORY },
}

Definition at line 361 of file changenotify.cpp.

Referenced by DoGetAliasPIDLs(), and DoInitAliasPIDLs().

SHELL32_ChangenotifyCS

CRITICAL_SECTION SHELL32_ChangenotifyCS

Definition at line 12 of file changenotify.cpp.

Referenced by FreeChangeNotifications(), InitChangeNotifications(), and SHChangeNotifyRegister().