Changeset 6810 for trunk/src

Timestamp:

Sep 25, 2001, 12:54:55 PM (24 years ago)

Author:

sandervl

Message:

wine update

Location:

trunk/src

Files:

• comctl32/comctl32undoc.c (modified) (12 diffs)
• shell32/shell32_main.h (modified) (2 diffs)
• shell32/shellord.c (modified) (18 diffs)

trunk/src/comctl32/comctl32undoc.c

@@ -19 +19 @@
 #define WINE_LARGE_INTEGER
 #endif
+
 #include <string.h>
 #include <stdlib.h> /* atoi */
@@ -27 +28 @@
 #include "winbase.h"
 #include "winerror.h"
+#include "winreg.h"
 
 #include "wine/unicode.h"
@@ -34 +36 @@
 
 DEFAULT_DEBUG_CHANNEL(commctrl);
-
 
 #ifdef __WIN32OS2__
@@ -423 +424 @@
  */
 
+#ifdef __WIN32OS2__
+#include <wine\undoccomctl32.h>
+#else
 typedef struct tagCREATEMRULIST
 {
@@ -446 +450 @@
  */
 
-typedef struct tagMRU
-{
-    DWORD  dwParam1;  /* some kind of flag */
-    DWORD  dwParam2;
-    DWORD  dwParam3;
-    HKEY   hkeyMRU;
-    LPCSTR lpszSubKey;
-    DWORD  dwParam6;
-} MRU, *HMRU;
+typedef struct tagWINEMRUITEM
+{
+    DWORD          size;        /* size of data stored               */
+    DWORD          itemFlag;    /* flags                             */
+    BYTE           datastart;
+} WINEMRUITEM, *LPWINEMRUITEM;
+
+/* itemFlag */
+#define WMRUIF_CHANGED   0x0001 /* this dataitem changed             */
+
+typedef struct tagWINEMRULIST
+{
+    CREATEMRULIST  extview;     /* original create information       */
+    DWORD          wineFlags;   /* internal flags                    */
+    DWORD          cursize;     /* current size of realMRU           */
+    LPSTR          realMRU;     /* pointer to string of index names  */
+    LPWINEMRUITEM  *array;      /* array of pointers to data         */
+                                /* in 'a' to 'z' order               */
+} WINEMRULIST, *LPWINEMRULIST;
+
+/* wineFlags */
+#define WMRUF_CHANGED  0x0001   /* MRU list has changed              */
 
 HANDLE WINAPI
 CreateMRUListLazyA (LPCREATEMRULIST lpcml, DWORD dwParam2,
                     DWORD dwParam3, DWORD dwParam4);
-
+#endif
+
+/**************************************************************************
+ *              MRU_SaveChanged - Localize MRU saving code
+ *
+ */
+VOID MRU_SaveChanged( LPWINEMRULIST mp )
+{
+    INT i, err;
+    HKEY newkey;
+    CHAR realname[2];
+    LPWINEMRUITEM witem;
+
+    /* or should we do the following instead of RegOpenKeyEx:
+     */
+
+    /* open the sub key */
+    if ((err = RegOpenKeyExA( mp->extview.hKey, mp->extview.lpszSubKey, 
+                               0, KEY_WRITE, &newkey))) {
+        /* not present - what to do ??? */
+        ERR("Can not open key, error=%d, attempting to create\n",
+            err);
+        if ((err = RegCreateKeyExA( mp->extview.hKey, mp->extview.lpszSubKey,
+                                    0,
+                                    "",
+                                    REG_OPTION_NON_VOLATILE,
+                                    KEY_READ | KEY_WRITE,
+                                    0,
+                                    &newkey,
+                                    0))) {
+            ERR("failed to create key /%s/, err=%d\n",
+                mp->extview.lpszSubKey, err);
+            return;
+        }
+    }
+    if (mp->wineFlags & WMRUF_CHANGED) {
+        mp->wineFlags &= ~WMRUF_CHANGED;
+        err = RegSetValueExA(newkey, "MRUList", 0, REG_SZ, 
+                             mp->realMRU, lstrlenA(mp->realMRU) + 1);
+        if (err) {
+            ERR("error saving MRUList, err=%d\n", err);
+        }
+        TRACE("saving MRUList=/%s/\n", mp->realMRU);
+    }
+    realname[1] = 0;
+    for(i=0; i<mp->cursize; i++) {
+        witem = mp->array[i];
+        if (witem->itemFlag & WMRUIF_CHANGED) {
+            witem->itemFlag &= ~WMRUIF_CHANGED;
+            realname[0] = 'a' + i;
+            err = RegSetValueExA(newkey, realname, 0, 
+                                 (mp->extview.dwFlags & MRUF_BINARY_LIST) ? 
+                                 REG_BINARY : REG_SZ,
+                                 &witem->datastart, witem->size);
+            if (err) {
+                ERR("error saving /%s/, err=%d\n", realname, err);
+            }
+            TRACE("saving value for name /%s/ size=%ld\n",
+                  realname, witem->size);
+        }
+    }
+    RegCloseKey( newkey );
+}
 
 /**************************************************************************
@@ -486 +565 @@
 FreeMRUListA (HANDLE hMRUList)
 {
-    FIXME("(%08x) empty stub!\n", hMRUList);
-
-#if 0
-    if (!(hmru->dwParam1 & 1001)) {
-        RegSetValueExA (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
-                          hmru->lpszMRUString,
-                          strlen (hmru->lpszMRUString));
-    }
-
-
-    RegClosKey (hmru->hkeyMRU
-    COMCTL32_Free32 (hmru->lpszMRUString);
-#endif
-
-    return COMCTL32_Free ((LPVOID)hMRUList);
+    LPWINEMRULIST mp = (LPWINEMRULIST)hMRUList;
+    INT i;
+
+    TRACE("\n");
+    if (mp->wineFlags & WMRUF_CHANGED) {
+        /* need to open key and then save the info */
+        MRU_SaveChanged( mp );
+    }
+
+    for(i=0; i<mp->extview.nMaxItems; i++) {
+        if (mp->array[i])
+            COMCTL32_Free(mp->array[i]);
+    }
+    COMCTL32_Free(mp->realMRU);
+    COMCTL32_Free(mp->array);
+    return COMCTL32_Free(mp);
+}
+
+
+/**************************************************************************
+ *                  FindMRUData [COMCTL32.169]
+ * 
+ * Searches binary list for item that matches lpData of length cbData.
+ * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
+ * corresponding to item's reg. name will be stored in it ('a' -> 0).
+ *
+ * PARAMS
+ *    hList [I] list handle
+ *    lpData [I] data to find
+ *    cbData [I] length of data
+ *    lpRegNum [O] position in registry (maybe NULL)
+ *
+ * RETURNS
+ *    Position in list 0 -> MRU.  -1 if item not found.
+ */
+INT WINAPI
+FindMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum)
+{
+    LPWINEMRULIST mp = (LPWINEMRULIST)hList;
+    INT i, ret;
+
+    if (!mp->extview.lpfnCompare) {
+        ERR("MRU list not properly created. No compare procedure.\n");
+        return -1;
+    }
+
+    for(i=0; i<mp->cursize; i++) {
+        if (mp->extview.dwFlags & MRUF_BINARY_LIST) {
+            if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart, 
+                                         cbData))
+                break;
+        }
+        else {
+            if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart))
+                break;
+        }
+    }
+    if (i < mp->cursize)
+        ret = i;
+    else
+        ret = -1;
+    if (lpRegNum && (ret != -1))
+        *lpRegNum = 'a' + i;
+
+    TRACE("(%08x, %p, %ld, %p) returning %d\n",
+           hList, lpData, cbData, lpRegNum, ret);
+
+    return ret;
 }
 
@@ -523 +655 @@
 AddMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData)
 {
-    FIXME("(%08x, %p, %ld) empty stub!\n", hList, lpData, cbData);
-
-    return 0;
+    LPWINEMRULIST mp = (LPWINEMRULIST)hList;
+    LPWINEMRUITEM witem;
+    INT i, replace, ret;
+
+    if ((replace = FindMRUData (hList, lpData, cbData, NULL)) < 0) {
+        /* either add a new entry or replace oldest */
+        if (mp->cursize < mp->extview.nMaxItems) {
+            /* Add in a new item */
+            replace = mp->cursize;
+            mp->cursize++;
+        }
+        else {
+            /* get the oldest entry and replace data */
+            replace = mp->realMRU[mp->cursize - 1] - 'a';
+            COMCTL32_Free(mp->array[replace]);
+        }
+    }
+    else {
+        /* free up the old data */
+        COMCTL32_Free(mp->array[replace]);
+    }
+
+    /* Allocate space for new item and move in the data */
+    mp->array[replace] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(cbData + 
+                                                               sizeof(WINEMRUITEM));
+    witem->itemFlag |= WMRUIF_CHANGED;
+    witem->size = cbData;
+    memcpy( &witem->datastart, lpData, cbData);
+
+    /* now rotate MRU list */
+    mp->wineFlags |= WMRUF_CHANGED;
+    for(i=mp->cursize-1; i>=1; i--) {
+        mp->realMRU[i] = mp->realMRU[i-1];
+    }
+    mp->realMRU[0] = replace + 'a';
+    TRACE("(%08x, %p, %ld) adding data, /%c/ now most current\n", 
+          hList, lpData, cbData, replace+'a');
+    ret = replace;
+
+    if (!(mp->extview.dwFlags & MRUF_DELAYED_SAVE)) {
+        /* save changed stuff right now */
+        MRU_SaveChanged( mp );
+    }
+
+    return ret;
 }
 
@@ -571 +745 @@
 
 /**************************************************************************
- *                  FindMRUData [COMCTL32.169]
- * 
- * Searches binary list for item that matches lpData of length cbData.
- * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
- * corresponding to item's reg. name will be stored in it ('a' -> 0).
- *
- * PARAMS
- *    hList [I] list handle
- *    lpData [I] data to find
- *    cbData [I] length of data
- *    lpRegNum [O] position in registry (maybe NULL)
- *
- * RETURNS
- *    Position in list 0 -> MRU.  -1 if item not found.
- */
-INT WINAPI
-FindMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum)
-{
-    FIXME("(%08x, %p, %ld, %p) empty stub!\n",
-           hList, lpData, cbData, lpRegNum);
-
-    return 0;
-}
-
-/**************************************************************************
  *                  FindMRUStringA [COMCTL32.155]
  * 
@@ -613 +762 @@
 FindMRUStringA (HANDLE hList, LPCSTR lpszString, LPINT lpRegNum)
 {
-    FIXME("(%08x, %s, %p) empty stub!\n", hList, debugstr_a(lpszString),
-          lpRegNum);
-
-    return 0;
+    return FindMRUData(hList, (LPVOID)lpszString, lstrlenA(lpszString),
+                       lpRegNum);
 }
 
@@ -625 +772 @@
 CreateMRUListLazyA (LPCREATEMRULIST lpcml, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4)
 {
-    /* DWORD  dwLocal1;   *
-     * HKEY   hkeyResult; *
-     * DWORD  dwLocal3;   *
-     * LPVOID lMRU;       *
-     * DWORD  dwLocal5;   *
-     * DWORD  dwLocal6;   *
-     * DWORD  dwLocal7;   *
-     * DWORD  dwDisposition; */
-
-    /* internal variables */
-    LPVOID ptr;
-
-    FIXME("(%p) empty stub!\n", lpcml);
+    LPWINEMRULIST mp;
+    INT i, err;
+    HKEY newkey;
+    DWORD datasize, dwdisp;
+    CHAR realname[2];
+    LPWINEMRUITEM witem;
+    DWORD type;
 
     if (lpcml == NULL)
@@ -645 +786 @@
         return 0;
 
-    FIXME("(%lu %lu %lx %lx \"%s\" %p)\n",
+    mp = (LPWINEMRULIST) COMCTL32_Alloc(sizeof(WINEMRULIST));
+    memcpy(mp, lpcml, sizeof(CREATEMRULIST));
+
+    /* get space to save indexes that will turn into names
+     * but in order of most to least recently used
+     */
+    mp->realMRU = (LPSTR) COMCTL32_Alloc(mp->extview.nMaxItems + 2);
+
+    /* get space to save pointers to actual data in order of
+     * 'a' to 'z' (0 to n).
+     */
+    mp->array = (LPVOID) COMCTL32_Alloc(mp->extview.nMaxItems *
+                                        sizeof(LPVOID));
+
+    /* open the sub key */
+     if ((err = RegCreateKeyExA( mp->extview.hKey, mp->extview.lpszSubKey, 
+                               0,
+                                "",
+                                REG_OPTION_NON_VOLATILE, 
+                                KEY_READ | KEY_WRITE,
+                                0,
+                                &newkey,
+                                &dwdisp))) {
+        /* error - what to do ??? */
+        ERR("(%lu %lu %lx %lx \"%s\" %p): Can not open key, error=%d\n",
+            lpcml->cbSize, lpcml->nMaxItems, lpcml->dwFlags,
+            (DWORD)lpcml->hKey, lpcml->lpszSubKey, lpcml->lpfnCompare,
+            err);
+        return 0;
+    }
+
+    /* get values from key 'MRUList' */
+    if (newkey) {
+        datasize = mp->extview.nMaxItems + 1;
+        if((err=RegQueryValueExA( newkey, "MRUList", 0, &type, mp->realMRU, 
+                                  &datasize))) {
+            /* not present - set size to 1 (will become 0 later) */
+            datasize = 1;
+            *mp->realMRU = 0;
+        }
+
+        TRACE("MRU list = %s\n", mp->realMRU);
+
+        mp->cursize = datasize - 1;
+        /* datasize now has number of items in the MRUList */
+
+        /* get actual values for each entry */
+        realname[1] = 0;
+        for(i=0; i<mp->cursize; i++) {
+            realname[0] = 'a' + i;
+            if(RegQueryValueExA( newkey, realname, 0, &type, 0, &datasize)) {
+                /* not present - what to do ??? */
+                ERR("Key %s not found 1\n", realname);
+            }
+            mp->array[i] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(datasize + 
+                                                                 sizeof(WINEMRUITEM));
+            witem->size = datasize;
+            if(RegQueryValueExA( newkey, realname, 0, &type, 
+                                 &witem->datastart, &datasize)) {
+                /* not present - what to do ??? */
+                ERR("Key %s not found 2\n", realname);
+            }
+        }
+        RegCloseKey( newkey );
+    }
+    else
+        mp->cursize = 0;
+
+    TRACE("(%lu %lu %lx %lx \"%s\" %p): Current Size = %ld\n",
           lpcml->cbSize, lpcml->nMaxItems, lpcml->dwFlags,
-          (DWORD)lpcml->hKey, lpcml->lpszSubKey, lpcml->lpfnCompare);
-
-    /* dummy pointer creation */
-    ptr = COMCTL32_Alloc (32);
-
-    FIXME("-- ret = %p\n", ptr);
-
-    return (HANDLE)ptr;
+          (DWORD)lpcml->hKey, lpcml->lpszSubKey, lpcml->lpfnCompare,
+          mp->cursize);
+
+    return (HANDLE)mp;
 }
 
@@ -678 +883 @@
 DWORD nBufferSize)
 {
-    FIXME("(%08x, %d, %p, %ld): stub\n", hList, nItemPos, lpBuffer,
-          nBufferSize);
-    return 0;
+    LPWINEMRULIST mp = (LPWINEMRULIST) hList;
+    LPWINEMRUITEM witem;
+    INT desired, datasize;
+
+    if (nItemPos >= mp->cursize) return -1;
+    if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
+    desired = mp->realMRU[nItemPos];
+    desired -= 'a';
+    TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
+    witem = mp->array[desired];
+    datasize = min( witem->size, nBufferSize ); 
+    memcpy( lpBuffer, &witem->datastart, datasize);
+    TRACE("(%08x, %d, %p, %ld): returning len=%d\n", 
+          hList, nItemPos, lpBuffer, nBufferSize, datasize);
+    return datasize;
 }
 

trunk/src/shell32/shell32_main.h

@@ -1 @@
-/* $Id: shell32_main.h,v 1.10 2001-09-15 09:26:23 sandervl Exp $ */
 /*
  *      internal Shell32 Library definitions
@@ -63 +62 @@
 #define pCreateIconFromResourceEx    CreateIconFromResourceEx
 
+#include <wine\undoccomctl32.h>
+
+#define pAddMRUData     AddMRUData
+#define pFindMRUData    FindMRUData
+#define pEnumMRUListA   EnumMRUListA
+#define pFreeMRUListA   FreeMRUListA
+#define pCreateMRUListA CreateMRUListA
+
 /* ole2 */
 /*

trunk/src/shell32/shellord.c

@@ -14 +14 @@
 #include "heap.h"
 
+#include "shlwapi.h"
 #include "shellapi.h"
 #include "shlguid.h"
 #include "shlobj.h"
 #include "shell32_main.h"
-#include "wine/undocshell.h"
+#ifdef __WIN32OS2__
+#include "wine\undocshell.h"
+#else
+#include "undocshell.h"
+#endif
 
 DEFAULT_DEBUG_CHANNEL(shell);
@@ -65 +70 @@
 DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len) 
 {
-        FIXME("('%s',0x%08lx,%p,%ld) stub.\n",
+        FIXME("(%s,0x%08lx,%p,%ld) stub\n",
           debugstr_w(src), nField, dst, len);
         return FALSE;
@@ -71 +76 @@
 
 /*************************************************************************
- * ParseFieldAW                 [SHELL32.58]
+ * ParseField                   [SHELL32.58]
  */
 DWORD WINAPI ParseFieldAW(LPCVOID src, DWORD nField, LPVOID dst, DWORD len) 
@@ -435 +440 @@
 
 /*************************************************************************
- * SHAddToRecentDocs                            [SHELL32.234]
+ * SHADD_get_policy - helper function for SHAddToRecentDocs
+ *
+ * PARAMETERS
+ *   policy    [IN]  policy name (null termed string) to find
+ *   type      [OUT] ptr to DWORD to receive type
+ *   buffer    [OUT] ptr to area to hold data retrieved
+ *   len       [IN/OUT] ptr to DWORD holding size of buffer and getting
+ *                      length filled
+ *
+ * RETURNS
+ *   result of the SHQueryValueEx call
+ */
+static INT SHADD_get_policy(LPSTR policy, LPDWORD type, LPVOID buffer, LPDWORD len)
+{
+    HKEY Policy_basekey;
+    INT ret;
+
+    /* Get the key for the policies location in the registry 
+     */
+    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
+                      "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
+                      0, KEY_READ, &Policy_basekey)) {
+
+        if (RegOpenKeyExA(HKEY_CURRENT_USER,
+                          "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
+                          0, KEY_READ, &Policy_basekey)) {
+            ERR("No Explorer Policies location\n");
+            *len = 0;
+            return ERROR_FILE_NOT_FOUND;
+        }
+    }
+
+    /* Retrieve the data if it exists
+     */
+    ret = SHQueryValueExA(Policy_basekey, policy, 0, type, buffer, len);
+    RegCloseKey(Policy_basekey);
+    return ret;
+}
+
+
+/*************************************************************************
+ * SHADD_compare_mru - helper function for SHAddToRecentDocs
+ *
+ * PARAMETERS
+ *   data1     [IN] data being looked for
+ *   data2     [IN] data in MRU
+ *   cbdata    [IN] length from FindMRUData call (not used)
+ *
+ * RETURNS
+ *   position within MRU list that data was added.
+ */
+static INT CALLBACK SHADD_compare_mru(LPCVOID data1, LPCVOID data2, DWORD cbData)
+{
+    return lstrcmpiA(data1, data2);
+}
+
+/*************************************************************************
+ * SHADD_create_add_mru_data - helper function for SHAddToRecentDocs
+ *
+ * PARAMETERS
+ *   mruhandle    [IN] handle for created MRU list
+ *   doc_name     [IN] null termed pure doc name
+ *   new_lnk_name [IN] null termed path and file name for .lnk file
+ *   buffer       [IN/OUT] 2048 byte area to consturct MRU data
+ *   len          [OUT] ptr to int to receive space used in buffer
+ *
+ * RETURNS
+ *   position within MRU list that data was added.
+ */
+static INT SHADD_create_add_mru_data(HANDLE mruhandle, LPSTR doc_name, LPSTR new_lnk_name,
+                                     LPSTR buffer, INT *len)
+{
+    LPSTR ptr;
+    INT wlen;
+    
+    /*FIXME: Document:
+     *  RecentDocs MRU data structure seems to be:
+     *    +0h   document file name w/ terminating 0h
+     *    +nh   short int w/ size of remaining
+     *    +n+2h 02h 30h, or 01h 30h, or 00h 30h  -  unknown 
+     *    +n+4h 10 bytes zeros  -   unknown
+     *    +n+eh shortcut file name w/ terminating 0h
+     *    +n+e+nh 3 zero bytes  -  unknown
+     */
+
+    /* Create the MRU data structure for "RecentDocs"
+         */
+    ptr = buffer;
+    lstrcpyA(ptr, doc_name);
+    ptr += (lstrlenA(buffer) + 1);
+    wlen= lstrlenA(new_lnk_name) + 1 + 12;
+    *((short int*)ptr) = wlen;
+    ptr += 2;   /* step past the length */
+    *(ptr++) = 0x30;  /* unknown reason */
+    *(ptr++) = 0;     /* unknown, but can be 0x00, 0x01, 0x02 */
+    memset(ptr, 0, 10);
+    ptr += 10;
+    lstrcpyA(ptr, new_lnk_name);
+    ptr += (lstrlenA(new_lnk_name) + 1);
+    memset(ptr, 0, 3);
+    ptr += 3;
+    *len = ptr - buffer;
+
+    /* Add the new entry into the MRU list 
+     */
+    return pAddMRUData(mruhandle, (LPCVOID)buffer, *len);
+}
+
+/*************************************************************************
+ * SHAddToRecentDocs                            [SHELL32.@]
  *
  * PARAMETERS
@@ -443 +557 @@
  * NOTES
  *     exported by name
+ *
+ * FIXME: ?? MSDN shows this as a VOID
  */
 DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)   
-{ if (SHARD_PIDL==uFlags)
-  { FIXME("(0x%08x,pidl=%p):stub.\n", uFlags,pv);
+{
+
+#ifndef __WIN32OS2__
+/* FIXME: !!! move CREATEMRULIST and flags to header file !!! */
+/*        !!! it is in both here and comctl32undoc.c      !!! */
+typedef struct tagCREATEMRULIST
+{
+    DWORD  cbSize;        /* size of struct */
+    DWORD  nMaxItems;     /* max no. of items in list */
+    DWORD  dwFlags;       /* see below */
+    HKEY   hKey;          /* root reg. key under which list is saved */
+    LPCSTR lpszSubKey;    /* reg. subkey */
+    PROC   lpfnCompare;   /* item compare proc */
+} CREATEMRULIST, *LPCREATEMRULIST;
+
+/* dwFlags */
+#define MRUF_STRING_LIST  0 /* list will contain strings */
+#define MRUF_BINARY_LIST  1 /* list will contain binary data */
+#define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */
+
+/* If list is a string list lpfnCompare has the following prototype
+ * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
+ * for binary lists the prototype is
+ * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
+ * where cbData is the no. of bytes to compare.
+ * Need to check what return value means identical - 0?
+ */
+#endif
+
+    UINT olderrormode;
+    HKEY HCUbasekey;
+    CHAR doc_name[MAX_PATH];
+    CHAR link_dir[MAX_PATH];
+    CHAR new_lnk_filepath[MAX_PATH];
+    CHAR new_lnk_name[MAX_PATH];
+    IMalloc *ppM;
+    LPITEMIDLIST pidl;
+    HWND hwnd = 0;       /* FIXME:  get real window handle */
+    INT ret;
+    DWORD data[64], datalen, type;
+
+    /*FIXME: Document:
+     *  RecentDocs MRU data structure seems to be:
+     *    +0h   document file name w/ terminating 0h
+     *    +nh   short int w/ size of remaining
+     *    +n+2h 02h 30h, or 01h 30h, or 00h 30h  -  unknown 
+     *    +n+4h 10 bytes zeros  -   unknown
+     *    +n+eh shortcut file name w/ terminating 0h
+     *    +n+e+nh 3 zero bytes  -  unknown
+     */
+
+    /* See if we need to do anything.
+     */
+    datalen = 64;
+    ret=SHADD_get_policy( "NoRecentDocsHistory", &type, &data, &datalen);
+    if ((ret > 0) && (ret != ERROR_FILE_NOT_FOUND)) {
+        ERR("Error %d getting policy \"NoRecentDocsHistory\"\n", ret);
+        return 0;
+    }
+    if (ret == ERROR_SUCCESS) {
+        if (!( (type == REG_DWORD) || 
+               ((type == REG_BINARY) && (datalen == 4)) )) {
+            ERR("Error policy data for \"NoRecentDocsHistory\" not formated correctly, type=%ld, len=%ld\n",
+                type, datalen);
+            return 0;
         }
-        else
-        { FIXME("(0x%08x,%s):stub.\n", uFlags,(char*)pv);
+
+        TRACE("policy value for NoRecentDocsHistory = %08lx\n", data[0]);
+        /* now test the actual policy value */
+        if ( data[0] != 0)
+            return 0;
+    }
+
+    /* Open key to where the necessary info is
+     */
+    /* FIXME: This should be done during DLL PROCESS_ATTACH (or THREAD_ATTACH)
+     *        and the close should be done during the _DETACH. The resulting
+     *        key is stored in the DLL global data.
+     */
+    RegOpenKeyExA(HKEY_CURRENT_USER,
+                  "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
+                  0,
+                  KEY_READ,
+                  &HCUbasekey);
+
+    /* Get path to user's "Recent" directory
+     */
+    if(SUCCEEDED(SHGetMalloc(&ppM))) {
+        if (SUCCEEDED(SHGetSpecialFolderLocation(hwnd, CSIDL_RECENT, 
+                                                 &pidl))) {
+            SHGetPathFromIDListA(pidl, link_dir);
+            IMalloc_Free(ppM, pidl);
         }
-  return 0;
-}
+        IMalloc_Release(ppM);
+    }
+    else {
+        /* serious issues */
+        link_dir[0] = 0;
+        ERR("serious issues\n");
+    }
+    TRACE("Users Recent dir %s\n", link_dir);
+
+    /* If no input, then go clear the lists */
+    if (!pv) {
+        /* clear user's Recent dir
+         */
+
+        /* FIXME: delete all files in "link_dir"
+         *
+         * while( more files ) {
+         *    lstrcpyA(old_lnk_name, link_dir);
+         *    PathAppendA(old_lnk_name, filenam);
+         *    DeleteFileA(old_lnk_name);
+         * }
+         */
+        FIXME("should delete all files in %s\\ \n", link_dir);
+
+        /* clear MRU list
+         */
+        /* MS Bug ?? v4.72.3612.1700 of shell32 does the delete against
+         *  HKEY_LOCAL_MACHINE version of ...CurrentVersion\Explorer
+         *  and naturally it fails w/ rc=2. It should do it against
+         *  HKEY_CURRENT_USER which is where it is stored, and where
+         *  the MRU routines expect it!!!!
+         */
+        RegDeleteKeyA(HCUbasekey, "RecentDocs");
+        RegCloseKey(HCUbasekey);
+        return 0;
+    }
+
+    /* Have data to add, the jobs to be done:
+     *   1. Add document to MRU list in registry "HKCU\Software\
+     *      Microsoft\Windows\CurrentVersion\Explorer\RecentDocs".
+     *   2. Add shortcut to document in the user's Recent directory 
+     *      (CSIDL_RECENT).
+     *   3. Add shortcut to Start menu's Documents submenu.
+     */
+
+    /* Get the pure document name from the input
+     */
+    if (uFlags & SHARD_PIDL) {
+        SHGetPathFromIDListA((LPCITEMIDLIST) pv, doc_name);
+    }
+    else {
+        lstrcpyA(doc_name, (LPSTR) pv);
+    }
+    TRACE("full document name %s\n", doc_name);
+    PathStripPathA(doc_name);;
+    TRACE("stripped document name %s\n", doc_name);
+
+
+    /* ***  JOB 1: Update registry for ...\Explorer\RecentDocs list  *** */
+
+    {  /* on input needs: 
+        *      doc_name    -  pure file-spec, no path 
+        *      link_dir    -  path to the user's Recent directory
+        *      HCUbasekey  -  key of ...Windows\CurrentVersion\Explorer" node
+        * creates:
+        *      new_lnk_name-  pure file-spec, no path for new .lnk file
+        *      new_lnk_filepath
+        *                  -  path and file name of new .lnk file 
+        */
+        CREATEMRULIST mymru;
+        HANDLE mruhandle;
+        INT len, pos, bufused, err;
+        INT i;
+        DWORD attr;
+        CHAR buffer[2048];
+        CHAR *ptr;
+        CHAR old_lnk_name[MAX_PATH];
+        short int slen;
+
+        mymru.cbSize = sizeof(CREATEMRULIST);
+        mymru.nMaxItems = 15;
+        mymru.dwFlags = MRUF_BINARY_LIST | MRUF_DELAYED_SAVE;
+        mymru.hKey = HCUbasekey;
+        mymru.lpszSubKey = "RecentDocs";
+        mymru.lpfnCompare = &SHADD_compare_mru;
+        mruhandle = pCreateMRUListA(&mymru);
+        if (!mruhandle) {
+            /* MRU failed */
+            ERR("MRU processing failed, handle zero\n");
+            RegCloseKey(HCUbasekey);
+            return 0;
+        }
+        len = lstrlenA(doc_name);
+        pos = pFindMRUData(mruhandle, doc_name, len, 0);
+
+        /* Now get the MRU entry that will be replaced 
+         * and delete the .lnk file for it 
+         */
+        if ((bufused = pEnumMRUListA(mruhandle, (pos == -1) ? 14 : pos, 
+                                     buffer, 2048)) != -1) {
+            ptr = buffer;
+            ptr += (lstrlenA(buffer) + 1);
+            slen = *((short int*)ptr);
+            ptr += 2;  /* skip the length area */
+            if (bufused >= slen + (ptr-buffer)) {
+                /* buffer size looks good */
+                ptr += 12; /* get to string */
+                len = bufused - (ptr-buffer);  /* get length of buf remaining */
+                if ((lstrlenA(ptr) > 0) && (lstrlenA(ptr) <= len-1)) {
+                    /* appears to be good string */
+                    lstrcpyA(old_lnk_name, link_dir);
+                    PathAppendA(old_lnk_name, ptr);
+                    if (!DeleteFileA(old_lnk_name)) {
+                        if ((attr = GetFileAttributesA(old_lnk_name)) == -1) {
+                            if ((err = GetLastError()) != ERROR_FILE_NOT_FOUND) {
+                                ERR("Delete for %s failed, err=%d, attr=%08lx\n",
+                                    old_lnk_name, err, attr);
+                            }
+                            else {
+                                TRACE("old .lnk file %s did not exist\n",
+                                      old_lnk_name);
+                            }
+                        }
+                        else {
+                            ERR("Delete for %s failed, attr=%08lx\n",
+                                old_lnk_name, attr);
+                        }
+                    }
+                    else {
+                        TRACE("deleted old .lnk file %s\n", old_lnk_name);
+                    }
+                }
+            }
+        }
+
+        /* Create usable .lnk file name for the "Recent" directory
+         */
+        wsprintfA(new_lnk_name, "%s.lnk", doc_name);
+        lstrcpyA(new_lnk_filepath, link_dir);
+        PathAppendA(new_lnk_filepath, new_lnk_name);
+        i = 1;
+        olderrormode = SetErrorMode(SEM_FAILCRITICALERRORS);
+        while (GetFileAttributesA(new_lnk_filepath) != -1) {
+            i++;
+            wsprintfA(new_lnk_name, "%s (%u).lnk", doc_name, i);
+            lstrcpyA(new_lnk_filepath, link_dir);
+            PathAppendA(new_lnk_filepath, new_lnk_name);
+        }
+        SetErrorMode(olderrormode);
+        TRACE("new shortcut will be %s\n", new_lnk_filepath);
+
+        /* Now add the new MRU entry and data
+         */
+        pos = SHADD_create_add_mru_data(mruhandle, doc_name, new_lnk_name,
+                                        buffer, &len);
+        pFreeMRUListA(mruhandle);
+        TRACE("Updated MRU list, new doc is position %d\n", pos);
+    }
+
+    /* ***  JOB 2: Create shortcut in user's "Recent" directory  *** */
+
+    {  /* on input needs: 
+        *      doc_name    -  pure file-spec, no path
+        *      new_lnk_filepath
+        *                  -  path and file name of new .lnk file 
+        *      uFlags[in]  -  flags on call to SHAddToRecentDocs
+        *      pv[in]      -  document path/pidl on call to SHAddToRecentDocs
+        */
+        IShellLinkA *psl = NULL;
+        IPersistFile *pPf = NULL;
+        HRESULT hres;
+        CHAR desc[MAX_PATH];
+        WCHAR widelink[MAX_PATH];
+
+        CoInitialize(0);
+
+        hres = CoCreateInstance( &CLSID_ShellLink,
+                                 NULL,
+                                 CLSCTX_INPROC_SERVER,
+                                 &IID_IShellLinkA,
+                                 (LPVOID )&psl);
+        if(SUCCEEDED(hres)) {
+
+            hres = IShellLinkA_QueryInterface(psl, &IID_IPersistFile, 
+                                             (LPVOID *)&pPf);
+            if(FAILED(hres)) {
+                /* bombed */
+                ERR("failed QueryInterface for IPersistFile %08lx\n", hres);
+                goto fail;
+            }
+
+            /* Set the document path or pidl */
+            if (uFlags & SHARD_PIDL) {
+                hres = IShellLinkA_SetIDList(psl, (LPCITEMIDLIST) pv);
+            } else {
+                hres = IShellLinkA_SetPath(psl, (LPCSTR) pv);
+            }
+            if(FAILED(hres)) {
+                /* bombed */
+                ERR("failed Set{IDList|Path} %08lx\n", hres);
+                goto fail;
+            }
+
+            lstrcpyA(desc, "Shortcut to ");
+            lstrcatA(desc, doc_name);
+            hres = IShellLinkA_SetDescription(psl, desc);
+            if(FAILED(hres)) {
+                /* bombed */
+                ERR("failed SetDescription %08lx\n", hres);
+                goto fail;
+            }
+
+            MultiByteToWideChar(CP_ACP, 0, new_lnk_filepath, -1, 
+                                widelink, MAX_PATH);
+            /* create the short cut */
+            hres = IPersistFile_Save(pPf, widelink, TRUE);
+            if(FAILED(hres)) {
+                /* bombed */
+                ERR("failed IPersistFile::Save %08lx\n", hres);
+                IPersistFile_Release(pPf);
+                IShellLinkA_Release(psl);
+                goto fail;
+            }
+            hres = IPersistFile_SaveCompleted(pPf, widelink);
+            IPersistFile_Release(pPf);
+            IShellLinkA_Release(psl);
+            TRACE("shortcut %s has been created, result=%08lx\n", 
+                  new_lnk_filepath, hres);
+        }
+        else {
+            ERR("CoCreateInstance failed, hres=%08lx\n", hres);
+        }
+    }
+
+ fail:
+    CoUninitialize();
+
+    /* all done */
+    RegCloseKey(HCUbasekey);
+    return 0;
+}
+
 /*************************************************************************
  * SHCreateShellFolderViewEx                    [SHELL32.174]
@@ -666 +1109 @@
 }
 /*************************************************************************
- * SHGetInstanceExplorer                        [SHELL32.256]
+ * SHGetInstanceExplorer                        [SHELL32.@]
  *
  * NOTES
@@ -717 +1160 @@
 }
 /*************************************************************************
- * ReadCabinetState                             [NT 4.0:SHELL32.651]
+ * ReadCabinetState                             [SHELL32.651] NT 4.0
  *
  */
@@ -725 +1168 @@
 }
 /*************************************************************************
- * WriteCabinetState                            [NT 4.0:SHELL32.652]
+ * WriteCabinetState                            [SHELL32.652] NT 4.0
  *
  */
@@ -741 +1184 @@
 }
 /*************************************************************************
- * IsUserAdmin                                  [NT 4.0:SHELL32.680]
+ * IsUserAdmin                                  [SHELL32.680] NT 4.0
  *
  */
@@ -884 +1327 @@
 
 /************************************************************************
- *      shell32_654                             [SHELL32.654]
+ *      @                               [SHELL32.654]
  *
  * NOTES: first parameter seems to be a pointer (same as passed to WriteCabinetState)
@@ -917 +1360 @@
 
 /************************************************************************
- *      DoEnvironmentSubstA                     [SHELL32.1222]
+ *      DoEnvironmentSubstA                     [SHELL32.@]
  *
  */
@@ -927 +1370 @@
 
 /************************************************************************
- *      DoEnvironmentSubstW                     [SHELL32.1223]
+ *      DoEnvironmentSubstW                     [SHELL32.@]
  *
  */
@@ -948 +1391 @@
 
 /*************************************************************************
- *      shell32_243                             [SHELL32.243]
+ *      @                             [SHELL32.243]
  * 
  * Win98+ by-ordinal routine.  In Win98 this routine returns zero and
@@ -961 +1404 @@
 
 /*************************************************************************
- *      SHELL32_714     [SHELL32]
+ *      @       [SHELL32.714]
  */
 DWORD WINAPI SHELL32_714(LPVOID x)
@@ -970 +1413 @@
 
 /*************************************************************************
- *      SHAddFromPropSheetExtArray      [SHELL32]
+ *      SHAddFromPropSheetExtArray      [SHELL32.167]
  */
 DWORD WINAPI SHAddFromPropSheetExtArray(DWORD a, DWORD b, DWORD c)
@@ -979 +1422 @@
 
 /*************************************************************************
- *      SHCreatePropSheetExtArray       [SHELL32]
+ *      SHCreatePropSheetExtArray       [SHELL32.168]
  */
 DWORD WINAPI SHCreatePropSheetExtArray(DWORD a, LPCSTR b, DWORD c)
@@ -988 +1431 @@
 
 /*************************************************************************
- *      SHReplaceFromPropSheetExtArray  [SHELL]
+ *      SHReplaceFromPropSheetExtArray  [SHELL32.170]
  */
 DWORD WINAPI SHReplaceFromPropSheetExtArray(DWORD a, DWORD b, DWORD c, DWORD d)
@@ -997 +1440 @@
 
 /*************************************************************************
- *      SHDestroyPropSheetExtArray      [SHELL32]
+ *      SHDestroyPropSheetExtArray      [SHELL32.169]
  */
 DWORD WINAPI SHDestroyPropSheetExtArray(DWORD a)