comctl32/treeview: Some tests to show edit item label problems.
[wine] / dlls / shell32 / changenotify.c
1 /*
2  *      shell change notification
3  *
4  * Copyright 2000 Juergen Schmied
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22 #include <string.h>
23
24 #define NONAMELESSUNION
25 #define NONAMELESSSTRUCT
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wine/debug.h"
29 #include "shell32_main.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(shell);
32
33 static CRITICAL_SECTION SHELL32_ChangenotifyCS;
34 static CRITICAL_SECTION_DEBUG critsect_debug =
35 {
36     0, 0, &SHELL32_ChangenotifyCS,
37     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
38       0, 0, { (DWORD_PTR)(__FILE__ ": SHELL32_ChangenotifyCS") }
39 };
40 static CRITICAL_SECTION SHELL32_ChangenotifyCS = { &critsect_debug, -1, 0, 0, 0, 0 };
41
42 typedef SHChangeNotifyEntry *LPNOTIFYREGISTER;
43
44 /* internal list of notification clients (internal) */
45 typedef struct _NOTIFICATIONLIST
46 {
47         struct _NOTIFICATIONLIST *next;
48         struct _NOTIFICATIONLIST *prev;
49         HWND hwnd;              /* window to notify */
50         DWORD uMsg;             /* message to send */
51         LPNOTIFYREGISTER apidl; /* array of entries to watch*/
52         UINT cidl;              /* number of pidls in array */
53         LONG wEventMask;        /* subscribed events */
54         LONG wSignalledEvent;   /* event that occurred */
55         DWORD dwFlags;          /* client flags */
56         LPCITEMIDLIST pidlSignaled; /*pidl of the path that caused the signal*/
57     
58 } NOTIFICATIONLIST, *LPNOTIFICATIONLIST;
59
60 static NOTIFICATIONLIST *head, *tail;
61
62 #define SHCNE_NOITEMEVENTS ( \
63    SHCNE_ASSOCCHANGED )
64
65 #define SHCNE_ONEITEMEVENTS ( \
66    SHCNE_ATTRIBUTES | SHCNE_CREATE | SHCNE_DELETE | SHCNE_DRIVEADD | \
67    SHCNE_DRIVEADDGUI | SHCNE_DRIVEREMOVED | SHCNE_FREESPACE | \
68    SHCNE_MEDIAINSERTED | SHCNE_MEDIAREMOVED | SHCNE_MKDIR | \
69    SHCNE_NETSHARE | SHCNE_NETUNSHARE | SHCNE_RMDIR | \
70    SHCNE_SERVERDISCONNECT | SHCNE_UPDATEDIR | SHCNE_UPDATEIMAGE )
71
72 #define SHCNE_TWOITEMEVENTS ( \
73    SHCNE_RENAMEFOLDER | SHCNE_RENAMEITEM | SHCNE_UPDATEITEM )
74
75 /* for dumping events */
76 static const char * DumpEvent( LONG event )
77 {
78     if( event == SHCNE_ALLEVENTS )
79         return "SHCNE_ALLEVENTS";
80 #define DUMPEV(x)  ,( event & SHCNE_##x )? #x " " : ""
81     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"
82     DUMPEV(RENAMEITEM)
83     DUMPEV(CREATE)
84     DUMPEV(DELETE)
85     DUMPEV(MKDIR)
86     DUMPEV(RMDIR)
87     DUMPEV(MEDIAINSERTED)
88     DUMPEV(MEDIAREMOVED)
89     DUMPEV(DRIVEREMOVED)
90     DUMPEV(DRIVEADD)
91     DUMPEV(NETSHARE)
92     DUMPEV(NETUNSHARE)
93     DUMPEV(ATTRIBUTES)
94     DUMPEV(UPDATEDIR)
95     DUMPEV(UPDATEITEM)
96     DUMPEV(SERVERDISCONNECT)
97     DUMPEV(UPDATEIMAGE)
98     DUMPEV(DRIVEADDGUI)
99     DUMPEV(RENAMEFOLDER)
100     DUMPEV(FREESPACE)
101     DUMPEV(EXTENDED_EVENT)
102     DUMPEV(ASSOCCHANGED)
103     DUMPEV(INTERRUPT)
104     );
105 #undef DUMPEV
106 }
107
108 static BOOL RefreshFileTypeAssociations(void)
109 {
110     static WCHAR szWinemenubuilder[] = {
111         'w','i','n','e','m','e','n','u','b','u','i','l','d','e','r','.','e','x','e',
112         ' ','-','a',0 };
113     STARTUPINFOW si;
114     PROCESS_INFORMATION pi;
115     BOOL ret;
116
117     TRACE("starting %s\n",debugstr_w(szWinemenubuilder));
118
119     memset(&si, 0, sizeof(si));
120     si.cb = sizeof(si);
121
122     ret = CreateProcessW( NULL, szWinemenubuilder, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi );
123
124     if (ret)
125     {
126         CloseHandle( pi.hProcess );
127         CloseHandle( pi.hThread );
128     }
129
130     return ret;
131 }
132
133 static const char * NodeName(const NOTIFICATIONLIST *item)
134 {
135     const char *str;
136     WCHAR path[MAX_PATH];
137
138     if(SHGetPathFromIDListW(item->apidl[0].pidl, path ))
139         str = wine_dbg_sprintf("%s", debugstr_w(path));
140     else
141         str = wine_dbg_sprintf("<not a disk file>" );
142     return str;
143 }
144
145 static void AddNode(LPNOTIFICATIONLIST item)
146 {
147     TRACE("item %p\n", item );
148
149     /* link items */
150     item->prev = tail;
151     item->next = NULL;
152     if( tail )
153         tail->next = item;
154     else
155         head = item;
156     tail = item;
157 }
158
159 static LPNOTIFICATIONLIST FindNode( HANDLE hitem )
160 {
161     LPNOTIFICATIONLIST ptr;
162     for( ptr = head; ptr; ptr = ptr->next )
163         if( ptr == hitem )
164             return ptr;
165     return NULL;
166 }
167
168 static void DeleteNode(LPNOTIFICATIONLIST item)
169 {
170     UINT i;
171
172     TRACE("item=%p prev=%p next=%p\n", item, item->prev, item->next);
173
174     /* remove item from list */
175     if( item->prev )
176         item->prev->next = item->next;
177     else
178         head = item->next;
179     if( item->next )
180         item->next->prev = item->prev;
181     else
182         tail = item->prev;
183
184     /* free the item */
185     for (i=0; i<item->cidl; i++)
186         SHFree((LPITEMIDLIST)item->apidl[i].pidl);
187     SHFree(item->apidl);
188     SHFree(item);
189 }
190
191 void InitChangeNotifications(void)
192 {
193 }
194
195 void FreeChangeNotifications(void)
196 {
197     TRACE("\n");
198
199     EnterCriticalSection(&SHELL32_ChangenotifyCS);
200
201     while( head )
202         DeleteNode( head );
203
204     LeaveCriticalSection(&SHELL32_ChangenotifyCS);
205
206     DeleteCriticalSection(&SHELL32_ChangenotifyCS);
207 }
208
209 /*************************************************************************
210  * SHChangeNotifyRegister                       [SHELL32.2]
211  *
212  */
213 ULONG WINAPI
214 SHChangeNotifyRegister(
215     HWND hwnd,
216     int fSources,
217     LONG wEventMask,
218     UINT uMsg,
219     int cItems,
220     SHChangeNotifyEntry *lpItems)
221 {
222     LPNOTIFICATIONLIST item;
223     int i;
224
225     item = SHAlloc(sizeof(NOTIFICATIONLIST));
226
227     TRACE("(%p,0x%08x,0x%08x,0x%08x,%d,%p) item=%p\n",
228         hwnd, fSources, wEventMask, uMsg, cItems, lpItems, item);
229
230     item->next = NULL;
231     item->prev = NULL;
232     item->cidl = cItems;
233     item->apidl = SHAlloc(sizeof(SHChangeNotifyEntry) * cItems);
234     for(i=0;i<cItems;i++)
235     {
236         item->apidl[i].pidl = ILClone(lpItems[i].pidl);
237         item->apidl[i].fRecursive = lpItems[i].fRecursive;
238     }
239     item->hwnd = hwnd;
240     item->uMsg = uMsg;
241     item->wEventMask = wEventMask;
242     item->wSignalledEvent = 0;
243     item->dwFlags = fSources;
244
245     TRACE("new node: %s\n", NodeName( item ));
246
247     EnterCriticalSection(&SHELL32_ChangenotifyCS);
248
249     AddNode(item);
250
251     LeaveCriticalSection(&SHELL32_ChangenotifyCS);
252
253     return (ULONG)item;
254 }
255
256 /*************************************************************************
257  * SHChangeNotifyDeregister                     [SHELL32.4]
258  */
259 BOOL WINAPI SHChangeNotifyDeregister(ULONG hNotify)
260 {
261     LPNOTIFICATIONLIST node;
262
263     TRACE("(0x%08x)\n", hNotify);
264
265     EnterCriticalSection(&SHELL32_ChangenotifyCS);
266
267     node = FindNode((HANDLE)hNotify);
268     if( node )
269         DeleteNode(node);
270
271     LeaveCriticalSection(&SHELL32_ChangenotifyCS);
272
273     return node?TRUE:FALSE;
274 }
275
276 /*************************************************************************
277  * SHChangeNotifyUpdateEntryList                [SHELL32.5]
278  */
279 BOOL WINAPI SHChangeNotifyUpdateEntryList(DWORD unknown1, DWORD unknown2,
280                               DWORD unknown3, DWORD unknown4)
281 {
282     FIXME("(0x%08x, 0x%08x, 0x%08x, 0x%08x)\n",
283           unknown1, unknown2, unknown3, unknown4);
284
285     return -1;
286 }
287
288 static BOOL should_notify( LPCITEMIDLIST changed, LPCITEMIDLIST watched, BOOL sub )
289 {
290     TRACE("%p %p %d\n", changed, watched, sub );
291     if ( !watched )
292         return FALSE;
293     if (ILIsEqual( watched, changed ) )
294         return TRUE;
295     if( sub && ILIsParent( watched, changed, TRUE ) )
296         return TRUE;
297     return FALSE;
298 }
299
300 /*************************************************************************
301  * SHChangeNotify                               [SHELL32.@]
302  */
303 void WINAPI SHChangeNotify(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
304 {
305     LPCITEMIDLIST Pidls[2];
306     LPNOTIFICATIONLIST ptr;
307     UINT typeFlag = uFlags & SHCNF_TYPE;
308
309     Pidls[0] = NULL;
310     Pidls[1] = NULL;
311
312     TRACE("(0x%08x,0x%08x,%p,%p):stub.\n", wEventId, uFlags, dwItem1, dwItem2);
313
314     if( ( wEventId & SHCNE_NOITEMEVENTS ) && ( dwItem1 || dwItem2 ) )
315     {
316         TRACE("dwItem1 and dwItem2 are not zero, but should be\n");
317         dwItem1 = 0;
318         dwItem2 = 0;
319         return;
320     }
321     else if( ( wEventId & SHCNE_ONEITEMEVENTS ) && dwItem2 )
322     {
323         TRACE("dwItem2 is not zero, but should be\n");
324         dwItem2 = 0;
325         return;
326     }
327
328     if( ( ( wEventId & SHCNE_NOITEMEVENTS ) && 
329           ( wEventId & ~SHCNE_NOITEMEVENTS ) ) ||
330         ( ( wEventId & SHCNE_ONEITEMEVENTS ) && 
331           ( wEventId & ~SHCNE_ONEITEMEVENTS ) ) ||
332         ( ( wEventId & SHCNE_TWOITEMEVENTS ) && 
333           ( wEventId & ~SHCNE_TWOITEMEVENTS ) ) )
334     {
335         WARN("mutually incompatible events listed\n");
336         return;
337     }
338
339     /* convert paths in IDLists*/
340     switch (typeFlag)
341     {
342     case SHCNF_PATHA:
343         if (dwItem1) Pidls[0] = SHSimpleIDListFromPathA(dwItem1);
344         if (dwItem2) Pidls[1] = SHSimpleIDListFromPathA(dwItem2);
345         break;
346     case SHCNF_PATHW:
347         if (dwItem1) Pidls[0] = SHSimpleIDListFromPathW(dwItem1);
348         if (dwItem2) Pidls[1] = SHSimpleIDListFromPathW(dwItem2);
349         break;
350     case SHCNF_IDLIST:
351         Pidls[0] = dwItem1;
352         Pidls[1] = dwItem2;
353         break;
354     case SHCNF_PRINTERA:
355     case SHCNF_PRINTERW:
356         FIXME("SHChangeNotify with (uFlags & SHCNF_PRINTER)\n");
357         return;
358     case SHCNF_DWORD:
359     default:
360         FIXME("unknown type %08x\n",typeFlag);
361         return;
362     }
363
364     {
365         WCHAR path[MAX_PATH];
366
367         if( Pidls[0] && SHGetPathFromIDListW(Pidls[0], path ))
368             TRACE("notify %08x on item1 = %s\n", wEventId, debugstr_w(path));
369     
370         if( Pidls[1] && SHGetPathFromIDListW(Pidls[1], path ))
371             TRACE("notify %08x on item2 = %s\n", wEventId, debugstr_w(path));
372     }
373
374     EnterCriticalSection(&SHELL32_ChangenotifyCS);
375
376     /* loop through the list */
377     for( ptr = head; ptr; ptr = ptr->next )
378     {
379         BOOL notify;
380         DWORD i;
381
382         notify = FALSE;
383
384         TRACE("trying %p\n", ptr);
385
386         for( i=0; (i<ptr->cidl) && !notify ; i++ )
387         {
388             LPCITEMIDLIST pidl = ptr->apidl[i].pidl;
389             BOOL subtree = ptr->apidl[i].fRecursive;
390
391             if (wEventId & ptr->wEventMask)
392             {
393                 if( !pidl )          /* all ? */
394                     notify = TRUE;
395                 else if( wEventId & SHCNE_NOITEMEVENTS )
396                     notify = TRUE;
397                 else if( wEventId & ( SHCNE_ONEITEMEVENTS | SHCNE_TWOITEMEVENTS ) )
398                     notify = should_notify( Pidls[0], pidl, subtree );
399                 else if( wEventId & SHCNE_TWOITEMEVENTS )
400                     notify = should_notify( Pidls[1], pidl, subtree );
401             }
402         }
403
404         if( !notify )
405             continue;
406
407         ptr->pidlSignaled = ILClone(Pidls[0]);
408
409         TRACE("notifying %s, event %s(%x) before\n", NodeName( ptr ), DumpEvent(
410                wEventId ),wEventId );
411
412         ptr->wSignalledEvent |= wEventId;
413
414         if (ptr->dwFlags  & SHCNRF_NewDelivery)
415             SendMessageA(ptr->hwnd, ptr->uMsg, (WPARAM) ptr, (LPARAM) GetCurrentProcessId());
416         else
417             SendMessageA(ptr->hwnd, ptr->uMsg, (WPARAM)Pidls, wEventId);
418
419         TRACE("notifying %s, event %s(%x) after\n", NodeName( ptr ), DumpEvent(
420                 wEventId ),wEventId );
421
422     }
423     TRACE("notify Done\n");
424     LeaveCriticalSection(&SHELL32_ChangenotifyCS);
425
426     if (wEventId & SHCNE_ASSOCCHANGED)
427     {
428         TRACE("refreshing file type associations\n");
429         RefreshFileTypeAssociations();
430     }
431     
432     /* if we allocated it, free it. The ANSI flag is also set in its Unicode sibling. */
433     if ((typeFlag & SHCNF_PATHA) || (typeFlag & SHCNF_PRINTERA))
434     {
435         SHFree((LPITEMIDLIST)Pidls[0]);
436         SHFree((LPITEMIDLIST)Pidls[1]);
437     }
438 }
439
440 /*************************************************************************
441  * NTSHChangeNotifyRegister                     [SHELL32.640]
442  * NOTES
443  *   Idlist is an array of structures and Count specifies how many items in the array
444  *   (usually just one I think).
445  */
446 DWORD WINAPI NTSHChangeNotifyRegister(
447     HWND hwnd,
448     LONG events1,
449     LONG events2,
450     DWORD msg,
451     int count,
452     SHChangeNotifyEntry *idlist)
453 {
454     FIXME("(%p,0x%08x,0x%08x,0x%08x,0x%08x,%p):semi stub.\n",
455                 hwnd,events1,events2,msg,count,idlist);
456
457     return SHChangeNotifyRegister(hwnd, events1, events2, msg, count, idlist);
458 }
459
460 /*************************************************************************
461  * SHChangeNotification_Lock                    [SHELL32.644]
462  */
463 HANDLE WINAPI SHChangeNotification_Lock(
464         HANDLE hChange,
465         DWORD dwProcessId,
466         LPITEMIDLIST **lppidls,
467         LPLONG lpwEventId)
468 {
469     DWORD i;
470     LPNOTIFICATIONLIST node;
471     LPCITEMIDLIST *idlist;
472
473     TRACE("%p %08x %p %p\n", hChange, dwProcessId, lppidls, lpwEventId);
474
475     /* EnterCriticalSection(&SHELL32_ChangenotifyCS); */
476
477     node = FindNode( hChange );
478     if( node )
479     {
480         idlist = SHAlloc( sizeof(LPCITEMIDLIST *) * node->cidl );
481         for(i=0; i<node->cidl; i++)
482             idlist[i] = node->pidlSignaled;
483         *lpwEventId = node->wSignalledEvent;
484         *lppidls = (LPITEMIDLIST*)idlist;
485         node->wSignalledEvent = 0;
486     }
487     else
488         ERR("Couldn't find %p\n", hChange );
489
490     /* LeaveCriticalSection(&SHELL32_ChangenotifyCS); */
491
492     return node;
493 }
494
495 /*************************************************************************
496  * SHChangeNotification_Unlock                  [SHELL32.645]
497  */
498 BOOL WINAPI SHChangeNotification_Unlock ( HANDLE hLock)
499 {
500     TRACE("\n");
501     return 1;
502 }
503
504 /*************************************************************************
505  * NTSHChangeNotifyDeregister                   [SHELL32.641]
506  */
507 DWORD WINAPI NTSHChangeNotifyDeregister(ULONG x1)
508 {
509     FIXME("(0x%08x):semi stub.\n",x1);
510
511     return SHChangeNotifyDeregister( x1 );
512 }