hdiffpatch 1.0.0__cp310-cp310-win32.whl

hdiffpatch/_c_src/lzma/CPP/Windows/Shell.cpp

@@ -0,0 +1,839 @@
+// Windows/Shell.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/MyCom.h"
+#include "../Common/StringConvert.h"
+
+#include "COM.h"
+#include "FileName.h"
+#include "MemoryGlobal.h"
+#include "Shell.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+// MSVC6 and old SDK don't support this function:
+// #define LWSTDAPI  EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
+// LWSTDAPI StrRetToStrW(STRRET *pstr, LPCITEMIDLIST pidl, LPWSTR *ppsz);
+
+// #define SHOW_DEBUG_SHELL
+
+#ifdef SHOW_DEBUG_SHELL
+
+#include "../Common/IntToString.h"
+
+static void Print_Number(UInt32 number, const char *s)
+{
+  AString s2;
+  s2.Add_UInt32(number);
+  s2.Add_Space();
+  s2 += s;
+  OutputDebugStringA(s2);
+}
+
+#define ODS(sz) { OutputDebugStringA(sz); }
+#define ODS_U(s) { OutputDebugStringW(s); }
+#define ODS_(op) { op; }
+
+#else
+
+#define ODS(sz)
+#define ODS_U(s)
+#define ODS_(op)
+
+#endif
+
+
+namespace NWindows {
+namespace NShell {
+
+#ifndef UNDER_CE
+
+// SHGetMalloc is unsupported in Windows Mobile?
+
+void CItemIDList::Free()
+{
+  if (!m_Object)
+    return;
+  /* DOCs:
+      SHGetMalloc was introduced in Windows 95 and Microsoft Windows NT 4.0,
+      but as of Windows 2000 it is no longer necessary.
+      In its place, programs can call the equivalent (and easier to use) CoTaskMemAlloc and CoTaskMemFree.
+     Description from oldnewthings:
+       shell functions could work without COM (if OLE32.DLL is not loaded),
+       but now if OLE32.DLL is loaded, then shell functions and com functions do same things.
+     22.02: so we use OLE32.DLL function to free memory:
+  */
+  /*
+  CMyComPtr<IMalloc> shellMalloc;
+  if (::SHGetMalloc(&shellMalloc) != NOERROR)
+    throw 41099;
+  shellMalloc->Free(m_Object);
+  */
+  CoTaskMemFree(m_Object);
+  m_Object = NULL;
+}
+
+/*
+CItemIDList::(LPCITEMIDLIST itemIDList): m_Object(NULL)
+  {  *this = itemIDList; }
+CItemIDList::(const CItemIDList& itemIDList): m_Object(NULL)
+  {  *this = itemIDList; }
+
+CItemIDList& CItemIDList::operator=(LPCITEMIDLIST object)
+{
+  Free();
+  if (object != 0)
+  {
+    UINT32 size = GetSize(object);
+    m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
+    if (m_Object != NULL)
+      MoveMemory(m_Object, object, size);
+  }
+  return *this;
+}
+
+CItemIDList& CItemIDList::operator=(const CItemIDList &object)
+{
+  Free();
+  if (object.m_Object != NULL)
+  {
+    UINT32 size = GetSize(object.m_Object);
+    m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
+    if (m_Object != NULL)
+      MoveMemory(m_Object, object.m_Object, size);
+  }
+  return *this;
+}
+*/
+
+
+static HRESULT ReadUnicodeStrings(const wchar_t *p, size_t size, UStringVector &names)
+{
+  names.Clear();
+  const wchar_t *lim = p + size;
+  UString s;
+  /*
+  if (size == 0 || p[size - 1] != 0)
+    return E_INVALIDARG;
+  if (size == 1)
+    return S_OK;
+  if (p[size - 2] != 0)
+    return E_INVALIDARG;
+  */
+  for (;;)
+  {
+    const wchar_t *start = p;
+    for (;;)
+    {
+      if (p == lim) return E_INVALIDARG; // S_FALSE
+      if (*p++ == 0)
+        break;
+    }
+    const size_t num = (size_t)(p - start);
+    if (num == 1)
+    {
+      if (p != lim) return E_INVALIDARG; // S_FALSE
+      return S_OK;
+    }
+    s.SetFrom(start, (unsigned)(num - 1));
+    ODS_U(s)
+    names.Add(s);
+    // names.ReserveOnePosition();
+    // names.AddInReserved_Ptr_of_new(new UString((unsigned)num - 1, start));
+  }
+}
+
+
+static HRESULT ReadAnsiStrings(const char *p, size_t size, UStringVector &names)
+{
+  names.Clear();
+  AString name;
+  for (; size != 0; size--)
+  {
+    const char c = *p++;
+    if (c == 0)
+    {
+      if (name.IsEmpty())
+        return S_OK;
+      names.Add(GetUnicodeString(name));
+      name.Empty();
+    }
+    else
+      name.Add_Char(c);
+  }
+  return E_INVALIDARG;
+}
+
+
+#define INIT_FORMATETC_HGLOBAL(type) { (type), NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }
+
+static HRESULT DataObject_GetData_HGLOBAL(IDataObject *dataObject, CLIPFORMAT cf, NCOM::CStgMedium &medium)
+{
+  FORMATETC etc = INIT_FORMATETC_HGLOBAL(cf);
+  RINOK(dataObject->GetData(&etc, &medium))
+  if (medium.tymed != TYMED_HGLOBAL)
+    return E_INVALIDARG;
+  return S_OK;
+}
+
+static HRESULT DataObject_GetData_HDROP_Names(IDataObject *dataObject, UStringVector &names)
+{
+  names.Clear();
+  NCOM::CStgMedium medium;
+  
+  /* Win10 : if (dataObject) is from IContextMenu::Initialize() and
+    if (len_of_path >= MAX_PATH (260) for some file in data object)
+    {
+      GetData() returns HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)
+        "The data area passed to a system call is too small",
+      Is there a way to fix this code for long paths?
+    } */
+
+  RINOK(DataObject_GetData_HGLOBAL(dataObject, CF_HDROP, medium))
+  const size_t blockSize = GlobalSize(medium.hGlobal);
+  if (blockSize < sizeof(DROPFILES))
+    return E_INVALIDARG;
+  NMemory::CGlobalLock dropLock(medium.hGlobal);
+  const DROPFILES *dropFiles = (const DROPFILES *)dropLock.GetPointer();
+  if (!dropFiles)
+    return E_INVALIDARG;
+  if (blockSize < dropFiles->pFiles
+      || dropFiles->pFiles < sizeof(DROPFILES)
+      // || dropFiles->pFiles != sizeof(DROPFILES)
+      )
+    return E_INVALIDARG;
+  const size_t size = blockSize - dropFiles->pFiles;
+  const void *namesData = (const Byte *)(const void *)dropFiles + dropFiles->pFiles;
+  HRESULT hres;
+  if (dropFiles->fWide)
+  {
+    if (size % sizeof(wchar_t) != 0)
+      return E_INVALIDARG;
+    hres = ReadUnicodeStrings((const wchar_t *)namesData, size / sizeof(wchar_t), names);
+  }
+  else
+    hres = ReadAnsiStrings((const char *)namesData, size, names);
+
+  ODS_(Print_Number(names.Size(), "DataObject_GetData_HDROP_Names"))
+  return hres;
+}
+
+
+
+// CF_IDLIST:
+#define MYWIN_CFSTR_SHELLIDLIST  TEXT("Shell IDList Array")
+
+typedef struct
+{
+  UINT cidl;
+  UINT aoffset[1];
+} MYWIN_CIDA;
+/*
+  cidl : number of PIDLs that are being transferred, not including the parent folder.
+  aoffset : An array of offsets, relative to the beginning of this structure.
+  aoffset[0] - fully qualified PIDL of a parent folder.
+               If this PIDL is empty, the parent folder is the desktop.
+  aoffset[1] ... aoffset[cidl] : offset to one of the PIDLs to be transferred.
+  All of these PIDLs are relative to the PIDL of the parent folder.
+*/
+
+static HRESULT DataObject_GetData_IDLIST(IDataObject *dataObject, UStringVector &names)
+{
+  names.Clear();
+  NCOM::CStgMedium medium;
+  RINOK(DataObject_GetData_HGLOBAL(dataObject, (CLIPFORMAT)
+      RegisterClipboardFormat(MYWIN_CFSTR_SHELLIDLIST), medium))
+  const size_t blockSize = GlobalSize(medium.hGlobal);
+  if (blockSize < sizeof(MYWIN_CIDA) || blockSize >= (UInt32)((UInt32)0 - 1))
+    return E_INVALIDARG;
+  NMemory::CGlobalLock dropLock(medium.hGlobal);
+  const MYWIN_CIDA *cida = (const MYWIN_CIDA *)dropLock.GetPointer();
+  if (!cida)
+    return E_INVALIDARG;
+  if (cida->cidl == 0)
+  {
+    // is it posssible to have no selected items?
+    // it's unexpected case.
+    return E_INVALIDARG;
+  }
+  if (cida->cidl >= (blockSize - (UInt32)sizeof(MYWIN_CIDA)) / sizeof(UINT))
+    return E_INVALIDARG;
+  const UInt32 start = cida->cidl * (UInt32)sizeof(UINT) + (UInt32)sizeof(MYWIN_CIDA);
+
+  STRRET strret;
+  CMyComPtr<IShellFolder> parentFolder;
+  {
+    const UINT offset = cida->aoffset[0];
+    if (offset < start || offset >= blockSize
+        // || offset != start
+        )
+      return E_INVALIDARG;
+
+    CMyComPtr<IShellFolder> desktopFolder;
+    RINOK(::SHGetDesktopFolder(&desktopFolder))
+    if (!desktopFolder)
+      return E_FAIL;
+    
+    LPCITEMIDLIST const lpcItem = (LPCITEMIDLIST)(const void *)((const Byte *)cida + offset);
+
+   #ifdef SHOW_DEBUG_SHELL
+    {
+      const HRESULT res = desktopFolder->GetDisplayNameOf(
+          lpcItem, SHGDN_FORPARSING, &strret);
+      if (res == S_OK && strret.uType == STRRET_WSTR)
+      {
+        ODS_U(strret.pOleStr)
+        /* if lpcItem is empty, the path will be
+             "C:\Users\user_name\Desktop"
+           if lpcItem is "My Computer" folder, the path will be
+             "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" */
+        CoTaskMemFree(strret.pOleStr);
+      }
+    }
+   #endif
+    
+    RINOK(desktopFolder->BindToObject(lpcItem,
+        NULL, IID_IShellFolder, (void **)&parentFolder))
+    if (!parentFolder)
+      return E_FAIL;
+  }
+  
+  names.ClearAndReserve(cida->cidl);
+  UString path;
+  
+  // for (int y = 0; y < 1; y++) // for debug
+  for (unsigned i = 1; i <= cida->cidl; i++)
+  {
+    const UINT offset = cida->aoffset[i];
+    if (offset < start || offset >= blockSize)
+      return E_INVALIDARG;
+    const void *p = (const Byte *)(const void *)cida + offset;
+    /* ITEMIDLIST of file can contain more than one SHITEMID item.
+       In win10 only SHGDN_FORPARSING returns path that contains
+       all path parts related to parts of ITEMIDLIST.
+       So we can use only SHGDN_FORPARSING here.
+       Don't use (SHGDN_INFOLDER)
+       Don't use (SHGDN_INFOLDER | SHGDN_FORPARSING)
+    */
+    RINOK(parentFolder->GetDisplayNameOf((LPCITEMIDLIST)p, SHGDN_FORPARSING, &strret))
+
+    /*
+    // MSVC6 and old SDK do not support StrRetToStrW().
+    LPWSTR lpstr;
+    RINOK (StrRetToStrW(&strret, NULL, &lpstr))
+    ODS_U(lpstr)
+    path = lpstr;
+    CoTaskMemFree(lpstr);
+    */
+    if (strret.uType != STRRET_WSTR)
+      return E_INVALIDARG;
+    ODS_U(strret.pOleStr)
+    path = strret.pOleStr;
+    // the path could have super path prefix "\\\\?\\"
+    // we can remove super path prefix here, if we don't need that prefix
+  #ifdef Z7_LONG_PATH
+    // we remove super prefix, if we can work without that prefix
+    NFile::NName::If_IsSuperPath_RemoveSuperPrefix(path);
+  #endif
+    names.AddInReserved(path);
+    CoTaskMemFree(strret.pOleStr);
+  }
+
+  ODS_(Print_Number(cida->cidl, "CFSTR_SHELLIDLIST END"))
+  return S_OK;
+}
+
+
+HRESULT DataObject_GetData_HDROP_or_IDLIST_Names(IDataObject *dataObject, UStringVector &paths)
+{
+  ODS("-- DataObject_GetData_HDROP_or_IDLIST_Names START")
+  HRESULT hres = NShell::DataObject_GetData_HDROP_Names(dataObject, paths);
+  // if (hres == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
+  if (hres != S_OK)
+  {
+    ODS("-- DataObject_GetData_IDLIST START")
+    // for (int y = 0; y < 10000; y++) // for debug
+    hres = NShell::DataObject_GetData_IDLIST(dataObject, paths);
+  }
+  ODS("-- DataObject_GetData_HDROP_or_IDLIST_Names END")
+  return hres;
+}
+
+
+
+// #if (NTDDI_VERSION >= NTDDI_VISTA)
+typedef struct
+{
+  UINT cItems;                    // number of items in rgdwFileAttributes array
+  DWORD dwSumFileAttributes;      // all of the attributes ORed together
+  DWORD dwProductFileAttributes;  // all of the attributes ANDed together
+  DWORD rgdwFileAttributes[1];    // array
+} MYWIN_FILE_ATTRIBUTES_ARRAY;
+
+#define MYWIN_CFSTR_FILE_ATTRIBUTES_ARRAY  TEXT("File Attributes Array")
+
+HRESULT DataObject_GetData_FILE_ATTRS(IDataObject *dataObject, CFileAttribs &attribs)
+{
+  attribs.Clear();
+  NCOM::CStgMedium medium;
+  RINOK(DataObject_GetData_HGLOBAL(dataObject, (CLIPFORMAT)
+      RegisterClipboardFormat(MYWIN_CFSTR_FILE_ATTRIBUTES_ARRAY), medium))
+  const size_t blockSize = GlobalSize(medium.hGlobal);
+  if (blockSize < sizeof(MYWIN_FILE_ATTRIBUTES_ARRAY))
+    return E_INVALIDARG;
+  NMemory::CGlobalLock dropLock(medium.hGlobal);
+  const MYWIN_FILE_ATTRIBUTES_ARRAY *faa = (const MYWIN_FILE_ATTRIBUTES_ARRAY *)dropLock.GetPointer();
+  if (!faa)
+    return E_INVALIDARG;
+  const unsigned numFiles = faa->cItems;
+  if (numFiles == 0)
+  {
+    // is it posssible to have empty array here?
+    return E_INVALIDARG;
+  }
+  if ((blockSize - (sizeof(MYWIN_FILE_ATTRIBUTES_ARRAY) - sizeof(DWORD)))
+      / sizeof(DWORD) != numFiles)
+    return E_INVALIDARG;
+  // attribs.Sum = faa->dwSumFileAttributes;
+  // attribs.Product = faa->dwProductFileAttributes;
+  // attribs.Vals.SetFromArray(faa->rgdwFileAttributes, numFiles);
+  // attribs.IsDirVector.ClearAndSetSize(numFiles);
+
+  if ((faa->dwSumFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
+  {
+    /* in win10: if selected items are volumes (c:\, d:\ ..) in  My Compter,
+       all items have FILE_ATTRIBUTE_DIRECTORY attribute
+       ntfs volume also have FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM
+       udf volume: FILE_ATTRIBUTE_READONLY
+       dvd-rom device: (-1) : all bits are set
+    */
+    const DWORD *attr = faa->rgdwFileAttributes;
+    // DWORD product = (UInt32)0 - 1, sum = 0;
+    for (unsigned i = 0; i < numFiles; i++)
+    {
+      if (attr[i] & FILE_ATTRIBUTE_DIRECTORY)
+      {
+        // attribs.ThereAreDirs = true;
+        attribs.FirstDirIndex = (int)i;
+        break;
+      }
+      // attribs.IsDirVector[i] = (attr[i] & FILE_ATTRIBUTE_DIRECTORY) != 0;
+      // product &= v;
+      // sum |= v;
+    }
+    // ODS_(Print_Number(product, "Product calc FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+    // ODS_(Print_Number(sum, "Sum calc FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+  }
+  // ODS_(Print_Number(attribs.Product, "Product FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+  // ODS_(Print_Number(attribs.Sum, "Sum FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+  ODS_(Print_Number(numFiles, "FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+  return S_OK;
+}
+
+
+/////////////////////////////
+// CDrop
+
+/*
+  win10:
+  DragQueryFile() implementation code is not effective because
+  there is no pointer inside DROP internal file list, so
+  DragQueryFile(fileIndex) runs all names in range [0, fileIndex].
+  DragQueryFile(,, buf, bufSize)
+  if (buf == NULL) by spec
+  {
+    returns value is the required size
+    in characters, of the buffer, not including the terminating null character
+    tests show that if (bufSize == 0), then it also returns  required size.
+  }
+  if (bufSize != NULL)
+  {
+    returns: the count of the characters copied, not including null character.
+    win10: null character is also  copied at position buf[ret_count];
+  }
+*/
+
+/*
+void CDrop::Attach(HDROP object)
+{
+  Free();
+  m_Object = object;
+  m_Assigned = true;
+}
+
+void CDrop::Free()
+{
+  if (m_MustBeFinished && m_Assigned)
+    Finish();
+  m_Assigned = false;
+}
+
+UINT CDrop::QueryCountOfFiles()
+{
+  return QueryFile(0xFFFFFFFF, (LPTSTR)NULL, 0);
+}
+
+void CDrop::QueryFileName(UINT fileIndex, UString &fileName)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    AString fileNameA;
+    const UINT len = QueryFile(fileIndex, (LPTSTR)NULL, 0);
+    const UINT numCopied = QueryFile(fileIndex, fileNameA.GetBuf(len + 2), len + 2);
+    fileNameA.ReleaseBuf_CalcLen(len);
+    if (numCopied != len)
+      throw 20221223;
+    fileName = GetUnicodeString(fileNameA);
+  }
+  else
+  #endif
+  {
+    // kReserve must be >= 3 for additional buffer size
+    //   safety and for optimal performance
+    const unsigned kReserve = 3;
+    {
+      unsigned len = 0;
+      wchar_t *buf = fileName.GetBuf_GetMaxAvail(len);
+      if (len >= kReserve)
+      {
+        const UINT numCopied = QueryFile(fileIndex, buf, len);
+        if (numCopied < len - 1)
+        {
+          // (numCopied < len - 1) case means that it have copied full string.
+          fileName.ReleaseBuf_CalcLen(numCopied);
+          return;
+        }
+      }
+    }
+    const UINT len = QueryFile(fileIndex, (LPWSTR)NULL, 0);
+    const UINT numCopied = QueryFile(fileIndex,
+        fileName.GetBuf(len + kReserve), len + kReserve);
+    fileName.ReleaseBuf_CalcLen(len);
+    if (numCopied != len)
+      throw 20221223;
+  }
+}
+
+
+void CDrop::QueryFileNames(UStringVector &fileNames)
+{
+  UINT numFiles = QueryCountOfFiles();
+  
+  Print_Number(numFiles, "\n====== CDrop::QueryFileNames START ===== \n");
+
+  fileNames.ClearAndReserve(numFiles);
+  UString s;
+  for (UINT i = 0; i < numFiles; i++)
+  {
+    QueryFileName(i, s);
+    if (!s.IsEmpty())
+      fileNames.AddInReserved(s);
+  }
+  Print_Number(numFiles, "\n====== CDrop::QueryFileNames END ===== \n");
+}
+*/
+
+
+// #if (NTDDI_VERSION >= NTDDI_VISTA)
+// SHGetPathFromIDListEx returns a win32 file system path for the item in the name space.
+typedef int Z7_WIN_GPFIDL_FLAGS;
+
+extern "C" {
+#ifndef _UNICODE
+typedef BOOL (WINAPI * Func_SHGetPathFromIDListW)(LPCITEMIDLIST pidl, LPWSTR pszPath); // nt4
+#endif
+
+#if !defined(Z7_WIN32_WINNT_MIN) || Z7_WIN32_WINNT_MIN < 0x0600  // Vista
+#define Z7_USE_DYN_SHGetPathFromIDListEx
+#endif
+
+#ifdef Z7_USE_DYN_SHGetPathFromIDListEx
+Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
+typedef BOOL (WINAPI * Func_SHGetPathFromIDListEx)(LPCITEMIDLIST pidl, PWSTR pszPath, DWORD cchPath, Z7_WIN_GPFIDL_FLAGS uOpts); // vista
+#endif
+}
+
+#ifndef _UNICODE
+
+bool GetPathFromIDList(LPCITEMIDLIST itemIDList, AString &path)
+{
+  path.Empty();
+  const unsigned len = MAX_PATH + 16;
+  const bool result = BOOLToBool(::SHGetPathFromIDList(itemIDList, path.GetBuf(len)));
+  path.ReleaseBuf_CalcLen(len);
+  return result;
+}
+
+#endif
+
+bool GetPathFromIDList(LPCITEMIDLIST itemIDList, UString &path)
+{
+  path.Empty();
+  unsigned len = MAX_PATH + 16;
+
+#ifdef _UNICODE
+  bool result = BOOLToBool(::SHGetPathFromIDList(itemIDList, path.GetBuf(len)));
+#else
+  const
+  Func_SHGetPathFromIDListW
+       shGetPathFromIDListW = Z7_GET_PROC_ADDRESS(
+  Func_SHGetPathFromIDListW, ::GetModuleHandleW(L"shell32.dll"),
+      "SHGetPathFromIDListW");
+  if (!shGetPathFromIDListW)
+    return false;
+  bool result = BOOLToBool(shGetPathFromIDListW(itemIDList, path.GetBuf(len)));
+#endif
+
+  if (!result)
+  {
+    ODS("==== GetPathFromIDList() SHGetPathFromIDList() returned false")
+    /* for long path we need SHGetPathFromIDListEx().
+      win10: SHGetPathFromIDListEx() for long path returns path with
+             with super path prefix "\\\\?\\". */
+#ifdef Z7_USE_DYN_SHGetPathFromIDListEx
+    const
+    Func_SHGetPathFromIDListEx
+    func_SHGetPathFromIDListEx = Z7_GET_PROC_ADDRESS(
+    Func_SHGetPathFromIDListEx, ::GetModuleHandleW(L"shell32.dll"),
+        "SHGetPathFromIDListEx");
+    if (func_SHGetPathFromIDListEx)
+#endif
+    {
+      ODS("==== GetPathFromIDList() (SHGetPathFromIDListEx)")
+      do
+      {
+        len *= 4;
+        result = BOOLToBool(
+#ifdef Z7_USE_DYN_SHGetPathFromIDListEx
+          func_SHGetPathFromIDListEx
+#else
+          SHGetPathFromIDListEx
+#endif
+          (itemIDList, path.GetBuf(len), len, 0));
+        if (result)
+          break;
+      }
+      while (len <= (1 << 16));
+    }
+  }
+
+  path.ReleaseBuf_CalcLen(len);
+  return result;
+}
+
+#endif
+
+#ifdef UNDER_CE
+
+bool BrowseForFolder(LPBROWSEINFO, CSysString)
+{
+  return false;
+}
+
+bool BrowseForFolder(HWND, LPCTSTR, UINT, LPCTSTR, CSysString &)
+{
+  return false;
+}
+
+bool BrowseForFolder(HWND /* owner */, LPCTSTR /* title */,
+    LPCTSTR /* initialFolder */, CSysString & /* resultPath */)
+{
+  /*
+  // SHBrowseForFolder doesn't work before CE 6.0 ?
+  if (GetProcAddress(LoadLibrary(L"ceshell.dll", L"SHBrowseForFolder") == 0)
+    MessageBoxW(0, L"no", L"", 0);
+  else
+    MessageBoxW(0, L"yes", L"", 0);
+  */
+  /*
+  UString s = "all files";
+  s += " (*.*)";
+  return MyGetOpenFileName(owner, title, initialFolder, s, resultPath, true);
+  */
+  return false;
+}
+
+#else
+
+/* win10: SHBrowseForFolder() doesn't support long paths,
+   even if long path suppport is enabled in registry and in manifest.
+   and SHBrowseForFolder() doesn't support super path prefix "\\\\?\\". */
+
+bool BrowseForFolder(LPBROWSEINFO browseInfo, CSysString &resultPath)
+{
+  resultPath.Empty();
+  NWindows::NCOM::CComInitializer comInitializer;
+  LPITEMIDLIST itemIDList = ::SHBrowseForFolder(browseInfo);
+  if (!itemIDList)
+    return false;
+  CItemIDList itemIDListHolder;
+  itemIDListHolder.Attach(itemIDList);
+  return GetPathFromIDList(itemIDList, resultPath);
+}
+
+
+static int CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
+{
+  #ifndef UNDER_CE
+  switch (uMsg)
+  {
+    case BFFM_INITIALIZED:
+    {
+      SendMessage(hwnd, BFFM_SETSELECTION, TRUE, data);
+      break;
+    }
+    /*
+    case BFFM_SELCHANGED:
+    {
+      TCHAR dir[MAX_PATH];
+      if (::SHGetPathFromIDList((LPITEMIDLIST) lp , dir))
+        SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)dir);
+      else
+        SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)TEXT(""));
+      break;
+    }
+    */
+    default:
+      break;
+  }
+  #endif
+  return 0;
+}
+
+
+static bool BrowseForFolder(HWND owner, LPCTSTR title, UINT ulFlags,
+    LPCTSTR initialFolder, CSysString &resultPath)
+{
+  CSysString displayName;
+  BROWSEINFO browseInfo;
+  browseInfo.hwndOwner = owner;
+  browseInfo.pidlRoot = NULL;
+
+  // there are Unicode/Astring problems in some WinCE SDK ?
+  /*
+  #ifdef UNDER_CE
+  browseInfo.pszDisplayName = (LPSTR)displayName.GetBuf(MAX_PATH);
+  browseInfo.lpszTitle = (LPCSTR)title;
+  #else
+  */
+  browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
+  browseInfo.lpszTitle = title;
+  // #endif
+  browseInfo.ulFlags = ulFlags;
+  browseInfo.lpfn = initialFolder ? BrowseCallbackProc : NULL;
+  browseInfo.lParam = (LPARAM)initialFolder;
+  return BrowseForFolder(&browseInfo, resultPath);
+}
+
+#ifdef Z7_OLD_WIN_SDK
+// ShlObj.h:
+#ifndef BIF_NEWDIALOGSTYLE
+#define BIF_NEWDIALOGSTYLE     0x0040
+#endif
+#endif
+
+bool BrowseForFolder(HWND owner, LPCTSTR title,
+    LPCTSTR initialFolder, CSysString &resultPath)
+{
+  return BrowseForFolder(owner, title,
+      #ifndef UNDER_CE
+      BIF_NEWDIALOGSTYLE |
+      #endif
+      BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT, initialFolder, resultPath);
+  // BIF_STATUSTEXT; BIF_USENEWUI   (Version 5.0)
+}
+
+#ifndef _UNICODE
+
+extern "C" {
+typedef LPITEMIDLIST (WINAPI * Func_SHBrowseForFolderW)(LPBROWSEINFOW lpbi);
+}
+
+static bool BrowseForFolder(LPBROWSEINFOW browseInfo, UString &resultPath)
+{
+  NWindows::NCOM::CComInitializer comInitializer;
+  const
+  Func_SHBrowseForFolderW
+     f_SHBrowseForFolderW = Z7_GET_PROC_ADDRESS(
+  Func_SHBrowseForFolderW, ::GetModuleHandleW(L"shell32.dll"),
+      "SHBrowseForFolderW");
+  if (!f_SHBrowseForFolderW)
+    return false;
+  LPITEMIDLIST itemIDList = f_SHBrowseForFolderW(browseInfo);
+  if (!itemIDList)
+    return false;
+  CItemIDList itemIDListHolder;
+  itemIDListHolder.Attach(itemIDList);
+  return GetPathFromIDList(itemIDList, resultPath);
+}
+
+static
+int CALLBACK BrowseCallbackProc2(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
+{
+  switch (uMsg)
+  {
+    case BFFM_INITIALIZED:
+    {
+      SendMessageW(hwnd, BFFM_SETSELECTIONW, TRUE, data);
+      break;
+    }
+    /*
+    case BFFM_SELCHANGED:
+    {
+      wchar_t dir[MAX_PATH * 2];
+
+      if (shGetPathFromIDListW((LPITEMIDLIST)lp , dir))
+        SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)dir);
+      else
+        SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)L"");
+      break;
+    }
+    */
+    default:
+      break;
+  }
+  return 0;
+}
+
+
+static bool BrowseForFolder(HWND owner, LPCWSTR title, UINT ulFlags,
+    LPCWSTR initialFolder, UString &resultPath)
+{
+  UString displayName;
+  BROWSEINFOW browseInfo;
+  browseInfo.hwndOwner = owner;
+  browseInfo.pidlRoot = NULL;
+  browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
+  browseInfo.lpszTitle = title;
+  browseInfo.ulFlags = ulFlags;
+  browseInfo.lpfn = initialFolder ? BrowseCallbackProc2 : NULL;
+  browseInfo.lParam = (LPARAM)initialFolder;
+  return BrowseForFolder(&browseInfo, resultPath);
+}
+
+bool BrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR initialFolder, UString &resultPath)
+{
+  if (g_IsNT)
+    return BrowseForFolder(owner, title,
+      BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
+      //  | BIF_STATUSTEXT // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
+      , initialFolder, resultPath);
+  // BIF_STATUSTEXT; BIF_USENEWUI   (Version 5.0)
+  CSysString s;
+  bool res = BrowseForFolder(owner, GetSystemString(title),
+      BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
+      // | BIF_STATUSTEXT  // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
+      , GetSystemString(initialFolder), s);
+  resultPath = GetUnicodeString(s);
+  return res;
+}
+
+#endif
+
+#endif
+
+}}